Class buffer_vector

libs/base/buffer_vector.hpp:20–417

template <class T, size_t N>
class buffer_vector
{
private:
  enum
  {
    USE_DYNAMIC = N + 1
  };
  // TODO (@gmoryes) consider std::aligned_storage
  T m_static[N];
  size_t m_size;
  std::vector<T> m_dynamic;

  bool IsDynamic() const { return m_size == USE_DYNAMIC; }

  void MoveStatic(buffer_vector & rhs) noexcept
  {
    static_assert(std::is_nothrow_move_assignable<T>::value);

    std::move(rhs.m_static, rhs.m_static + rhs.m_size, m_static);
  }

  void SetStaticSize(size_t newSize)
  {
    if constexpr (std::is_destructible<T>::value)
    {
      // Call destructors for old elements.
      for (size_t i = newSize; i < m_size; ++i)
        m_static[i] = T();
    }
    m_size = newSize;
  }

  static constexpr size_t SwitchCapacity() { return 3 * N / 2 + 1; }

public:
  typedef T value_type;
  typedef T const & const_reference;
  typedef T & reference;
  typedef size_t size_type;
  typedef T const * const_iterator;
  typedef T * iterator;

  buffer_vector() : m_size(0) {}
  explicit buffer_vector(size_t n) : m_size(0) { resize(n); }

  buffer_vector(std::initializer_list<T> init) : m_size(0)
  {
    assign(std::make_move_iterator(init.begin()), std::make_move_iterator(init.end()));
  }

  template <typename TIt>
  buffer_vector(TIt beg, TIt end) : m_size(0)
  {
    assign(beg, end);
  }

  buffer_vector(buffer_vector const &) = default;