Trying this out, but too big, instead i will modify where i need it.

small-vector.hxx

#pragma once
#include <array>
#include <vector>

using std::array;
using std::vector;




template <class T, size_t C=128>
class SmallVector {
  array<T, C> s; // small
  vector<T>   l; // large
  size_t N;

  // Cute helpers.
  constexpr bool is() const { return N<=C; } // small?

  // Member types.
  using value_type              = vector<T>::value_type;
  using size_type               = vector<T>::size_type;
  using difference_type         = vector<T>::difference_type;
  using reference               = vector<T>::reference;
  using const_reference         = vector<T>::const_reference;
  using pointer                 = vector<T>::pointer;
  using const_pointer           = vector<T>::const_pointer;
  using iterator                = vector<T>::iterator;
  using const_iterator          = vector<T>::const_iterator;
  using reverse_iterator        = vector<T>::reverse_iterator;
  using const_reverse_iterator  = vector<T>::const_reverse_iterator;

  // Element access.
  public:
  constexpr       T& at(size_t i)       { return is()? s.at(i) : l.at(i); }
  constexpr const T& at(size_t i) const { return is()? s.at(i) : l.at(i); }
  constexpr       T& operator[](size_t i)       { return is()? s[i] : l[i]; }
  constexpr const T& operator[](size_t i) const { return is()? s[i] : l[i]; }
  constexpr       T& front()       { return is()? s.front() : l.front(); }
  constexpr const T& front() const { return is()? s.front() : l.front(); }
  constexpr       T& back()       { return is()? s.back() : l.back(); }
  constexpr const T& back() const { return is()? s.back() : l.back(); }
  constexpr       T* data()       { return is()? s.data() : l.data(); }
  constexpr const T* data() const { return is()? s.data() : l.data(); }

  // Iterators.
  public:
  constexpr       iterator  begin()       noexcept { return is()? s.begin()  : l.begin(); }
  constexpr const_iterator  begin() const noexcept { return is()? s.begin()  : l.begin(); }
  constexpr const_iterator cbegin() const noexcept { return is()? s.cbegin() : l.cbegin(); }
  constexpr       iterator  end()       noexcept { return is()? s.end()  : l.end(); }
  constexpr const_iterator  end() const noexcept { return is()? s.end()  : l.end(); }
  constexpr const_iterator cend() const noexcept { return is()? s.cend() : l.cend(); }
  constexpr       reverse_iterator  rbegin()       noexcept { return is()? s.rbegin()  : l.rbegin(); }
  constexpr const_reverse_iterator  rbegin() const noexcept { return is()? s.rbegin()  : l.rbegin(); }
  constexpr const_reverse_iterator crbegin() const noexcept { return is()? s.crbegin() : l.crbegin(); }
  constexpr       reverse_iterator  rend()       noexcept { return is()? s.rend()  : l.rend(); }
  constexpr const_reverse_iterator  rend() const noexcept { return is()? s.rend()  : l.rend(); }
  constexpr const_reverse_iterator crend() const noexcept { return is()? s.crend() : l.crend(); }

  // Non-member functions.
  public:
  bool operator==(const SmallVector<T, C>& l, const SmallVector<T, C>& r) {
  }
};