static_vector.h

Go to the documentation of this file.

// === static_vector.h =================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_BASE_STATIC_VECTOR_H
#define SEN_CORE_BASE_STATIC_VECTOR_H
 
#include "sen/core/base/assert.h"
#include "sen/core/base/result.h"
#include "sen/core/base/span.h"
 
// std
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <memory>
#include <utility>
 
// Like SEN_EXPECT and SEN_ASSERT, but a passing check makes no call into the library. NOLINTNEXTLINE
#define SEN_VECTOR_CHECK(expr, type)                                                                                   \
  ((expr) ? static_cast<void>(0) : ::sen::impl::senCheckImpl(false, ::sen::impl::CheckType::type, #expr, SEN_SL()))
 
namespace sen
{
 
namespace impl
{

template <typename T, typename Range, typename Index>
inline T& index(Range&& range, Index&& i) noexcept
{
  // check that the index is within the range
  SEN_VECTOR_CHECK(static_cast<ptrdiff_t>(i) < (std::end(range) - std::begin(range)), expect);
 
  // go to the beginning of the range and fetch the element at index i
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  return std::begin(std::forward<Range>(range))[std::forward<Index>(i)];
}

template <typename T, typename Range, typename Index>
inline const T& cindex(Range&& range, Index&& i) noexcept
{
  // check that the index is within the range
  SEN_VECTOR_CHECK(static_cast<ptrdiff_t>(i) < (std::end(range) - std::begin(range)), expect);
 
  // go to the beginning of the range and fetch the element at index i
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  return std::begin(std::forward<Range>(range))[std::forward<Index>(i)];
}
 
}  // namespace impl


enum class StaticVectorError : std::uint8_t
{
  full,      
  badRange,  
  empty,     
};

template <typename T>
class StaticVectorBase
{
public:  // checks
  static constexpr bool nothrowDes = std::is_nothrow_destructible_v<T>;
  static constexpr bool nothrowDefaultCons = std::is_nothrow_default_constructible_v<T>;
  static constexpr bool nothrowCopyCons = std::is_nothrow_copy_constructible_v<T>;
  static constexpr bool nothrowMoveCons = std::is_nothrow_move_constructible_v<T>;
  static constexpr bool nothrowCopyAndDes = nothrowDes && nothrowCopyCons;
  static constexpr bool nothrowDefaultConsAndDes = nothrowDefaultCons && nothrowDes;
 
  // the following types allow compatibility with stdlib algorithms
public:
  using value_type = T;                                                  // NOLINT(readability-identifier-naming)
  using difference_type = ptrdiff_t;                                     // NOLINT(readability-identifier-naming)
  using pointer = T*;                                                    // NOLINT(readability-identifier-naming)
  using const_pointer = T const*;                                        // NOLINT(readability-identifier-naming)
  using reference = T&;                                                  // NOLINT(readability-identifier-naming)
  using const_reference = T const&;                                      // NOLINT(readability-identifier-naming)
  using rvalue_reference = T&&;                                          // NOLINT(readability-identifier-naming)
  using iterator = pointer;                                              // NOLINT(readability-identifier-naming)
  using const_iterator = const_pointer;                                  // NOLINT(readability-identifier-naming)
  using size_type = std::size_t;                                         // NOLINT(readability-identifier-naming)
  using reverse_iterator = std::reverse_iterator<iterator>;              // NOLINT(readability-identifier-naming)
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;  // NOLINT(readability-identifier-naming)
 
public:
  using Maybe = Result<void, StaticVectorError>;
  using MaybeIterator = Result<iterator, StaticVectorError>;
 
public:  // special members
  StaticVectorBase(const StaticVectorBase&) noexcept = delete;
  StaticVectorBase(StaticVectorBase&&) noexcept = delete;
  StaticVectorBase& operator=(StaticVectorBase&&) noexcept = delete;
  StaticVectorBase& operator=(const StaticVectorBase&) noexcept = delete;
 
public:  // getters.
  [[nodiscard]] size_type size() const noexcept { return size_; }

  [[nodiscard]] size_type capacity() const noexcept { return capacity_; }

  [[nodiscard]] size_type maxSize() const noexcept { return capacity(); }

  [[nodiscard]] const_pointer data() const noexcept
  {
    return reinterpret_cast<const_pointer>(dataPtr_);  // NOLINT NOSONAR
  }

  [[nodiscard]] pointer data() noexcept
  {
    return reinterpret_cast<pointer>(dataPtr_);  // NOLINT NOSONAR
  }

  [[nodiscard]] bool empty() const noexcept { return size() == size_type {0U}; }

  [[nodiscard]] bool full() const noexcept { return size() == capacity(); }
 
public:  // assignment
  [[nodiscard]] Maybe assign(size_type n, const T& u) noexcept(nothrowCopyCons);

  [[nodiscard]] Maybe assign(const std::initializer_list<T>& list) noexcept(nothrowCopyCons);

  [[nodiscard]] Maybe assign(std::initializer_list<T>&& list) noexcept(nothrowMoveCons);

  template <class InputIt>
  [[nodiscard]] Maybe assign(InputIt first, InputIt last) noexcept(nothrowCopyCons);
 
public:  // positional iterator accessors
  [[nodiscard]] iterator begin() noexcept { return data(); }

  [[nodiscard]] const_iterator begin() const noexcept { return data(); }

  [[nodiscard]] iterator end() noexcept
  {
    return data() + size();  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  }

  [[nodiscard]] const_iterator end() const noexcept { return data() + size(); }

  [[nodiscard]] reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }

  [[nodiscard]] const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }

  [[nodiscard]] reverse_iterator rend() noexcept { return reverse_iterator(begin()); }

  [[nodiscard]] const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }

  [[nodiscard]] const_iterator cbegin() noexcept { return begin(); }

  [[nodiscard]] const_iterator cbegin() const noexcept { return begin(); }

  [[nodiscard]] const_iterator cend() noexcept { return end(); }

  [[nodiscard]] const_iterator cend() const noexcept { return end(); }
 
public:  // index-based value accessors
  [[nodiscard]] reference operator[](size_type i) noexcept { return impl::index<value_type>(*this, i); }

  [[nodiscard]] const_reference operator[](size_type i) const noexcept { return impl::cindex<value_type>(*this, i); }
 
public:  // position-based value accessors
  [[nodiscard]] reference front() noexcept
  {
    SEN_VECTOR_CHECK(!empty(), expect);
    return impl::index<value_type>(*this, 0U);
  }

  [[nodiscard]] const_reference front() const noexcept
  {
    SEN_VECTOR_CHECK(!empty(), expect);
    return impl::cindex<value_type>(*this, 0U);
  }

  [[nodiscard]] reference back() noexcept
  {
    SEN_VECTOR_CHECK(!empty(), expect);
    return impl::index<value_type>(*this, size() - 1);
  }

  [[nodiscard]] const_reference back() const noexcept
  {
    SEN_VECTOR_CHECK(!empty(), expect);
    return impl::cindex<value_type>(*this, size() - 1);
  }
 
public:  // modifiers
  void clear() noexcept(nothrowDes)
  {
    internalDestroyAll();
    internalSetSize(0U);
  }

  Maybe push_back(T&& value) noexcept(nothrowMoveCons);

  Maybe push_back(const T& value) noexcept(nothrowCopyCons);

  Maybe push_back() noexcept(nothrowDefaultCons);

  template <typename... Args>
  MaybeIterator emplace(iterator position, Args&&... args) noexcept(nothrowMoveCons);

  template <typename... Args>
  Maybe emplace_back(Args&&... args) noexcept(  //  NOLINT(readability-identifier-naming)
    nothrowMoveCons);

  Maybe pop_back() noexcept(nothrowDes);  //  NOLINT(readability-identifier-naming)
 
public:  // insert overloads
  MaybeIterator insert(iterator position, const_reference x) noexcept(nothrowCopyCons);

  MaybeIterator insert(iterator position, value_type&& x) noexcept(nothrowMoveCons);

  MaybeIterator insert(iterator position, size_type n, const T& x) noexcept(nothrowCopyCons);

  MaybeIterator insert(iterator position, std::initializer_list<T> list) noexcept(nothrowCopyCons);

  template <class InputIt>
  MaybeIterator insert(iterator position, InputIt first, InputIt last) noexcept(nothrowCopyCons);

  template <class InputIt>
  MaybeIterator move_insert(iterator position,  //  NOLINT(readability-identifier-naming)
                            InputIt first,
                            InputIt last) noexcept(nothrowMoveCons);
 
public:  // resizing
  Maybe resize(size_type newSize, const T& value) noexcept(nothrowCopyAndDes);

  Maybe resize(size_type newSize) noexcept(nothrowDefaultConsAndDes);
 
public:  // erase
  MaybeIterator erase(iterator position) noexcept(nothrowDes);

  MaybeIterator erase(iterator first, iterator last) noexcept(nothrowDes);
 
private:  // implementation details
  [[nodiscard]] Maybe emplaceMultiple(size_type n) noexcept(nothrowDefaultCons);

  template <typename Iterator>
  [[nodiscard]] Maybe checkIteratorRange(Iterator itr) noexcept;

  template <typename IteratorA, typename IteratorB>
  [[nodiscard]] Maybe checkIteratorPair(IteratorA first, IteratorB last) noexcept;

  template <class Itr>
  void internalDestroy(Itr first, Itr last) noexcept(nothrowDes);

  void internalDestroyAll() noexcept(nothrowDes) { internalDestroy(data(), end()); }
 
protected:
  StaticVectorBase(std::size_t capacity, void* dataPtr) noexcept: capacity_(capacity), dataPtr_(dataPtr)
  {
    SEN_VECTOR_CHECK(dataPtr != nullptr, expect);
  }
  virtual ~StaticVectorBase() noexcept { internalDestroyAll(); }

  void internalSetSize(std::size_t newSize) noexcept;
 
private:
  std::size_t capacity_;
  void* dataPtr_;
  std::size_t size_ = 0U;
};

template <typename T, std::size_t s>
class StaticVector: public StaticVectorBase<T>
{
public:
  static constexpr std::size_t staticCapacity = s;
  static_assert(staticCapacity != 0U, "Vectors of no capacity are not supported");
 
public:
  using Base = StaticVectorBase<T>;
 
public:
  StaticVector() noexcept: StaticVectorBase<T>(s, &data_) {}

  explicit StaticVector(std::size_t n) noexcept;

  StaticVector(std::size_t n, T const& value) noexcept(Base::nothrowCopyCons);

  StaticVector(std::initializer_list<T> list) noexcept(Base::nothrowCopyCons);

  template <class InputIt>
  StaticVector(InputIt first, InputIt last) noexcept(Base::nothrowCopyCons);

  StaticVector(const StaticVector& other) noexcept(Base::nothrowCopyCons);

  StaticVector(StaticVector&& other) noexcept;

  ~StaticVector() noexcept override = default;

  StaticVector& operator=(const StaticVector& other) noexcept(Base::nothrowCopyCons);

  StaticVector& operator=(StaticVector&& other) noexcept;

  void swap(StaticVector& other) noexcept;

  [[nodiscard]] Base& base() noexcept { return *this; }

  [[nodiscard]] const Base& base() const noexcept { return *this; }
 
private:
  alignas(T) std::byte data_[sizeof(T) * s];
};
 
//--------------------------------------------------------------------------------------------------------------
// Comparison operators
//--------------------------------------------------------------------------------------------------------------

template <typename T, std::size_t size>
std::enable_if_t<HasOperator<T>::eq, bool> operator==(
  StaticVector<T, size> const& lhs,
  StaticVector<T, size> const& rhs) noexcept(noexcept(std::declval<T const&>() == std::declval<T const&>()))
{
  if (lhs.size() != rhs.size())
  {
    return false;
  }
 
  return lhs.size() == 0 || std::equal(lhs.begin(), lhs.end(), rhs.begin(), std::equal_to<T> {});
}

template <typename T, std::size_t size>
std::enable_if_t<HasOperator<T>::ne, bool> operator!=(
  StaticVector<T, size> const& lhs,
  StaticVector<T, size> const& rhs) noexcept(noexcept(std::declval<StaticVector<T, size> const&>() ==
                                                      std::declval<StaticVector<T, size> const&>()))
{
  return !(lhs == rhs);
}

template <typename T, std::size_t size>
std::enable_if_t<HasOperator<T>::lt, bool> operator<(const StaticVector<T, size>& lhs,
                                                     const StaticVector<T, size>& rhs)  //
  noexcept(noexcept(std::declval<const T&>() < std::declval<const T&>()))
{
  return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}

template <typename T, std::size_t size>
std::enable_if_t<HasOperator<T>::lt, bool> operator>(const StaticVector<T, size>& lhs,
                                                     const StaticVector<T, size>& rhs)  //
  noexcept(noexcept(std::declval<const T&>() < std::declval<const T&>()))
{
  return std::lexicographical_compare(rhs.begin(), rhs.end(), lhs.begin(), lhs.end());
}

template <typename T, std::size_t size>
[[nodiscard]] Span<const T> makeConstSpan(const StaticVector<T, size>& vector) noexcept
{
  return makeConstSpan(vector.data(), vector.size());
}

 
}  // namespace sen
 
//----------------------------------------------------------------------------------------------------------------------
// Inline implementation
//----------------------------------------------------------------------------------------------------------------------
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define SEN_VECTOR_TRY(...)                                                                                            \
  {                                                                                                                    \
    auto res = __VA_ARGS__;                                                                                            \
    if (res.isError())                                                                                                 \
    {                                                                                                                  \
      return Err(res.getError());                                                                                      \
    }                                                                                                                  \
  }
 
namespace sen
{
 
template <typename T>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::assign(StaticVectorBase::size_type n,
                                                                       const T& u) noexcept(nothrowCopyCons)
{
  if (n > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  // clear and insert the elements at the beginning
  clear();
  return insert(begin(), n, u);
}
 
template <typename T>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::assign(const std::initializer_list<T>& list) noexcept(
  nothrowCopyCons)
{
  if (list.size() > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  clear();
  return insert(begin(), list.begin(), list.end());
}
 
template <typename T>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::assign(std::initializer_list<T>&& list) noexcept(
  nothrowMoveCons)
{
  if (list.size() > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  // clear and move-insert the elements at the beginning
  clear();
  return move_insert(begin(), list.begin(), list.end());
}
 
template <typename T>
template <class InputIt>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::assign(InputIt first,
                                                                       InputIt last) noexcept(nothrowCopyCons)
{
  // check capacity
  if (last - first < 0)
  {
    return Err(StaticVectorError::badRange);
  }
 
  if (static_cast<size_type>(last - first) > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  // clear and insert the elements at the beginning
  clear();
  return insert(begin(), first, last);
}
 
template <typename T>
// NOLINTNEXTLINE(readability-identifier-naming)
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::push_back(T&& value) noexcept(nothrowMoveCons)
{
  if (full())
  {
    return Err(StaticVectorError::full);
  }
  return emplace_back(std::move(value));
}
 
template <typename T>
// NOLINTNEXTLINE(readability-identifier-naming)
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::push_back(const T& value) noexcept(nothrowCopyCons)
{
  if (full())
  {
    return Err(StaticVectorError::full);
  }
 
  return emplace_back(value);
}
 
template <typename T>
// NOLINTNEXTLINE(readability-identifier-naming)
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::push_back() noexcept(nothrowDefaultCons)
{
  static_assert(std::is_default_constructible<T>::value,
                "this version of push_back requires a default constructible type");
 
  if (full())
  {
    return Err(StaticVectorError::full);
  }
  return emplace_back(T {});
}
 
template <typename T>
template <typename... Args>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::emplace(
  StaticVectorBase::iterator position,
  Args&&... args) noexcept(nothrowMoveCons)
{
  if (full())
  {
    return Err(StaticVectorError::full);
  }
 
  // check that the position is valid
  SEN_VECTOR_TRY(checkIteratorRange(position))
 
  if (position == end())
  {
    std::ignore = emplace_back(std::forward<Args>(args)...);  // not full
    return Ok(position);
  }
 
  const auto previousEnd = end();
 
  // move the back to a new extra place
  std::ignore = emplace_back(std::move(back()));  // not full
 
  if (std::distance(position, previousEnd) != 1)
  {
    // move the rest of the elements to make room
    std::move_backward(position, end() - 2, end() - 1);  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
 
    // destroy the element that was in position
    std::destroy_at(position);
  }
 
  // place the new element in position
  ::new (std::addressof(*position)) T(std::forward<Args>(args)...);
 
  return Ok(position);
}
 
template <typename T>
template <typename... Args>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::emplace_back(Args&&... args) noexcept(nothrowMoveCons)
{
  if (full())
  {
    return Err(StaticVectorError::full);
  }
 
  // placement new at the end of the array
  new (end()) T(std::forward<Args>(args)...);
 
  // increase the size
  internalSetSize(size() + 1);
  return Ok();
}
 
template <typename T>
// NOLINTNEXTLINE(readability-identifier-naming)
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::pop_back() noexcept(nothrowDes)
{
  if (empty())
  {
    return Err(StaticVectorError::empty);
  }
 
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  auto ptr = end() - 1;         // get the pointer to the last element
  std::destroy_at(ptr);         // do placement delete
  internalSetSize(size() - 1);  // decrease the size
  return Ok();
}
 
template <typename T>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::insert(
  StaticVectorBase::iterator position,
  const_reference x) noexcept(nothrowCopyCons)
{
  if (full())
  {
    return Err(StaticVectorError::full);
  }
 
  SEN_VECTOR_TRY(checkIteratorRange(position))
  return insert(position, static_cast<size_type>(1), x);
}
 
template <typename T>
template <class InputIt>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::insert(iterator position,
                                                                               InputIt first,
                                                                               InputIt last) noexcept(nothrowCopyCons)
{
  // checks
  SEN_VECTOR_TRY(checkIteratorRange(position))
  SEN_VECTOR_TRY(checkIteratorPair(first, last))
 
  // check if we would be inserting beyond the capacity
  if (size() + static_cast<size_type>(last - first) > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  const size_t insertN = std::distance(first, last);
  const size_t insertBegin = std::distance(begin(), position);
  const size_t insertEnd = insertBegin + insertN;
 
  // move old data.
  size_t copyOldN;
  size_t constructOldN;
  iterator pConstructOld;
 
  auto pEnd = end();
 
  // Elements after the position. insertBegin <= size() is checked above, so no count below wraps.
  const size_t tailN = size() - insertBegin;
 
  if (insertN > tailN)
  {
    copyOldN = 0;
    constructOldN = tailN;
    pConstructOld = begin() + insertEnd;  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  }
  else
  {
    copyOldN = tailN - insertN;
    constructOldN = insertN;
    pConstructOld = pEnd;
  }
 
  const size_t copyNewN = constructOldN;
  const size_t constructNewN = insertN - copyNewN;
 
  // move-construct old on the new (uninitialized memory area).
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::uninitialized_move(pEnd - constructOldN, pEnd, pConstructOld);
 
  // move old to the remaining (already initialized) memory area.
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::move_backward(begin() + insertBegin, begin() + insertBegin + copyOldN, begin() + insertEnd + copyOldN);
 
  // copy-construct new in the (uninitialized) memory area
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::uninitialized_copy(first + copyNewN, first + copyNewN + constructNewN, pEnd);
 
  // copy new to the final location
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::copy(first, first + copyNewN, begin() + insertBegin);
 
  internalSetSize(size_ + insertN);
 
  return Ok(position);
}
 
template <typename T>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::insert(iterator position,
                                                                               value_type&& x) noexcept(nothrowMoveCons)
{
  if (full())
  {
    return Err(StaticVectorError::full);
  }
 
  SEN_VECTOR_TRY(checkIteratorRange(position))
 
  if (position == end())
  {
    std::ignore = emplace_back(std::move(x));  // not full, so cannot fail
  }
  else
  {
    // move the back to a new extra place
    std::ignore = emplace_back(std::move(back()));  // not full, so cannot fail
 
    // move affected range one position
    std::move_backward(position, end() - 2, end() - 1);  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
 
    // move our value into the desired position
    *position = std::move(x);
  }
 
  return Ok(position);
}
 
template <typename T>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::insert(StaticVectorBase::iterator position,
                                                                               StaticVectorBase::size_type n,
                                                                               const T& x) noexcept(nothrowCopyCons)
{
  SEN_VECTOR_TRY(checkIteratorRange(position))
 
  if (const auto newSize = size() + n; newSize > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  if (n == 0U)
  {
    return Ok(position);
  }
 
  const size_t insertN = n;
  const size_t insertBegin = std::distance(begin(), position);
  const size_t insertEnd = insertBegin + insertN;
 
  // copy old data.
  size_t copyOldN;
  size_t constructOldN;
  iterator pConstructOld;
 
  auto pEnd = end();
 
  // Elements after the position. insertBegin <= size() is checked above, so no count below wraps.
  const size_t tailN = size() - insertBegin;
 
  if (insertN > tailN)
  {
    copyOldN = 0;
    constructOldN = tailN;
    pConstructOld = begin() + insertEnd;  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  }
  else
  {
    copyOldN = tailN - insertN;
    constructOldN = insertN;
    pConstructOld = pEnd;
  }
 
  size_t copyNewN = constructOldN;
  size_t constructNewN = insertN - copyNewN;
 
  // move-construct old on the new (uninitialized memory area).
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::uninitialized_move(static_cast<iterator>(pEnd - constructOldN), pEnd, pConstructOld);
 
  // move old to the remaining (already initialized) memory area.
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::move_backward(begin() + insertBegin, begin() + insertBegin + copyOldN, begin() + insertEnd + copyOldN);
 
  // construct new in the (uninitialized) memory area.
  std::uninitialized_fill_n(pEnd, constructNewN, x);
 
  // copy new n values of T
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::fill_n(begin() + insertBegin, copyNewN, x);
 
  internalSetSize(size() + n);
 
  return Ok(position);
}
 
template <typename T>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::insert(
  StaticVectorBase::iterator position,
  std::initializer_list<T> list) noexcept(nothrowCopyCons)
{
  SEN_VECTOR_TRY(checkIteratorRange(position))
  return insert(position, list.begin(), list.end());
}
 
template <typename T>
template <class InputIt>
inline typename StaticVectorBase<T>::MaybeIterator
StaticVectorBase<T>::move_insert(iterator position, InputIt first, InputIt last) noexcept(nothrowMoveCons)
{
  // checks
  SEN_VECTOR_TRY(checkIteratorRange(position))
  SEN_VECTOR_TRY(checkIteratorPair(first, last))
 
  if (size() + static_cast<size_type>(last - first) > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  const size_t insertN = std::distance(first, last);
  const size_t insertBegin = std::distance(begin(), position);
  const size_t insertEnd = insertBegin + insertN;
 
  // move old data.
  size_t moveOldN;
  size_t constructOldN;
  iterator pConstructOld;
  auto pEnd = end();
 
  // Elements after the position. insertBegin <= size() is checked above, so no count below wraps.
  const size_t tailN = size() - insertBegin;
 
  if (insertN > tailN)
  {
    moveOldN = 0;
    constructOldN = tailN;
    pConstructOld = begin() + insertEnd;  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  }
  else
  {
    moveOldN = tailN - insertN;
    constructOldN = insertN;
    pConstructOld = pEnd;
  }
 
  const size_t copyNewN = constructOldN;
  const size_t constructNewN = insertN - copyNewN;
 
  // move-construct old on the new (uninitialized memory area).
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::uninitialized_move(pEnd - constructOldN, pEnd, pConstructOld);
 
  // move old to the remaining (already initialized) memory area.
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::move_backward(begin() + insertBegin, begin() + insertBegin + moveOldN, begin() + insertEnd + moveOldN);
 
  // move-construct new in the (uninitialized) memory area
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::uninitialized_move(first + copyNewN, first + copyNewN + constructNewN, pEnd);
 
  // move new to the final location
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::move(first, first + copyNewN, begin() + insertBegin);
 
  internalSetSize(size_ + insertN);
 
  return Ok(position);
}
 
template <typename T>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::resize(StaticVectorBase::size_type newSize,
                                                                       const T& value) noexcept(nothrowCopyAndDes)
{
  static_assert(std::is_nothrow_copy_constructible<T>::value, "T is not supported");
 
  // do nothing if the size is already the same
  if (newSize == size())
  {
    return Ok();
  }
 
  if (newSize > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  if (newSize > size())
  {
    // insert copies of value at the end
    return insert(end(), newSize - size(), value);
  }
 
  // remove elements from the end
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  return erase(end() - (size() - newSize), end());
}
 
template <typename T>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::resize(StaticVectorBase::size_type newSize) noexcept(
  nothrowDefaultConsAndDes)
{
  // do nothing if the size is already the same
  if (newSize == size())
  {
    return Ok();
  }
 
  if (newSize > capacity())
  {
    return Err(StaticVectorError::full);
  }
 
  if (newSize > size())
  {
    return emplaceMultiple(newSize - size());
  }
 
  // remove elements from the end
  return erase(end() - (size() - newSize), end());  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
}
 
template <typename T>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::erase(
  StaticVectorBase::iterator position) noexcept(nothrowDes)
{
  SEN_VECTOR_TRY(checkIteratorRange(position))
 
  // move elements from [position + 1, end) to position
  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::move(position + 1, end(), position);
 
  // destroy the last element
  auto ptr = end() - 1;  // get the pointer to the last element NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::destroy_at(ptr);  // do placement delete
  internalSetSize(size() - 1);
  return Ok(position);
}
 
template <typename T>
inline typename StaticVectorBase<T>::MaybeIterator StaticVectorBase<T>::erase(
  StaticVectorBase::iterator first,
  StaticVectorBase::iterator last) noexcept(nothrowDes)
{
  SEN_VECTOR_TRY(checkIteratorPair(first, last))
  SEN_VECTOR_TRY(checkIteratorRange(first))
  SEN_VECTOR_TRY(checkIteratorRange(last))
 
  if (first == last)
  {
    return Ok(first);
  }
 
  if (first == begin() && last == end())
  {
    clear();
  }
  else
  {
    // move the remaining elements on top of the erased range
    std::move(last, end(), first);
 
    // destroy the elements left over at the end.
    const auto nDelete = std::distance(first, last);
    std::destroy(end() - nDelete, end());  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
 
    internalSetSize(size() - nDelete);
  }
 
  return Ok(first);
}
 
template <typename T>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::emplaceMultiple(StaticVectorBase::size_type n) noexcept(
  nothrowDefaultCons)
{
  const size_type newSize = size() + n;
  SEN_VECTOR_CHECK(newSize <= capacity(), expect);
 
  while (newSize != size())
  {
    // cannot overflow as newSize != size() && newSize <= capacity
    std::ignore = emplace_back();
  }
 
  return Ok();
}
 
template <typename T>
template <typename Iterator>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::checkIteratorRange(Iterator itr) noexcept
{
  if (itr >= begin() && itr <= end())
  {
    return Ok();
  }
 
  return Err(StaticVectorError::badRange);
}
 
template <typename T>
template <typename IteratorA, typename IteratorB>
inline typename StaticVectorBase<T>::Maybe StaticVectorBase<T>::checkIteratorPair(IteratorA first,
                                                                                  IteratorB last) noexcept
{
  if (first > last)
  {
    return Err(StaticVectorError::badRange);
  }
  return Ok();
}
 
template <typename T>
inline void StaticVectorBase<T>::internalSetSize(std::size_t newSize) noexcept
{
  SEN_VECTOR_CHECK(newSize <= capacity(), expect);  // newSize out-of-bounds [0, Capacity)
  size_ = newSize;
}
 
template <typename T>
template <class InputIt>
inline void StaticVectorBase<T>::internalDestroy(InputIt first, InputIt last) noexcept(nothrowDes)
{
  SEN_VECTOR_CHECK(first >= data(), expect);
  SEN_VECTOR_CHECK(first <= end(), expect);
  SEN_VECTOR_CHECK(last >= data(), expect);
  SEN_VECTOR_CHECK(last <= end(), expect);
 
  for (; first != last; ++first)  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  {
    std::destroy_at(first);
  }
}
 
// StaticVector
 
template <typename T, std::size_t c>
inline StaticVector<T, c>::StaticVector(std::size_t n) noexcept: StaticVectorBase<T>(c, &data_)
{
  auto result = this->resize(n);
  SEN_VECTOR_CHECK(result.isOk(), assert);
  std::ignore = result;
}
 
template <typename T, std::size_t c>
inline StaticVector<T, c>::StaticVector(std::size_t n, const T& value) noexcept(Base::nothrowCopyCons)
  : StaticVectorBase<T>(c, &data_)
{
  auto result = this->resize(n, value);
  SEN_VECTOR_CHECK(result.isOk(), assert);
  std::ignore = result;
}
 
template <typename T, std::size_t c>
inline StaticVector<T, c>::StaticVector(std::initializer_list<T> list) noexcept(Base::nothrowCopyCons)
  : StaticVectorBase<T>(c, &data_)
{
  auto result = this->assign(std::move(list));
  SEN_VECTOR_CHECK(result.isOk(), assert);
  std::ignore = result;
}
 
template <typename T, std::size_t c>
template <class InputIt>
inline StaticVector<T, c>::StaticVector(InputIt first, InputIt last) noexcept(Base::nothrowCopyCons)
  : StaticVectorBase<T>(c, &data_)
{
  auto result = this->assign(first, last);
  SEN_VECTOR_CHECK(result.isOk(), assert);
  std::ignore = result;
}
 
template <typename T, std::size_t c>
inline StaticVector<T, c>::StaticVector(const StaticVector& other) noexcept(Base::nothrowCopyCons)
  : StaticVectorBase<T>(c, &data_)
{
  auto result = this->insert(this->begin(), other.begin(), other.end());
  SEN_VECTOR_CHECK(result.isOk(), assert);
  std::ignore = result;
}
 
template <typename T, std::size_t c>
inline StaticVector<T, c>::StaticVector(StaticVector&& other) noexcept: StaticVectorBase<T>(c, &data_)
{
  auto result = this->move_insert(this->begin(), other.begin(), other.end());
  SEN_VECTOR_CHECK(result.isOk(), assert);
  std::ignore = result;
  other.internalSetSize(0U);
}
 
template <typename T, std::size_t c>
inline StaticVector<T, c>& StaticVector<T, c>::operator=(const StaticVector& other) noexcept(Base::nothrowCopyCons)
{
  if (this != &other)
  {
    // clear and insert the elements at the beginning
    this->clear();
    auto result = this->insert(this->begin(), other.begin(), other.end());
    SEN_VECTOR_CHECK(result.isOk(), assert);
    std::ignore = result;
  }
  return *this;
}
 
template <typename T, std::size_t c>
inline StaticVector<T, c>& StaticVector<T, c>::operator=(StaticVector&& other) noexcept
{
  if (this != &other)
  {
    // clear and move-insert the elements at the beginning
    this->clear();
    auto result = this->move_insert(this->begin(), other.begin(), other.end());
    SEN_VECTOR_CHECK(result.isOk(), assert);
    std::ignore = result;
    other.internalSetSize(0U);
  }
  return *this;
}
 
template <typename T, std::size_t c>
inline void StaticVector<T, c>::swap(StaticVector& other) noexcept
{
  StaticVector tmp = std::move(other);
  other = std::move(*this);
  (*this) = std::move(tmp);
}
 
}  // namespace sen
 
#undef SEN_VECTOR_TRY
#undef SEN_VECTOR_CHECK
 
#endif  // SEN_CORE_BASE_STATIC_VECTOR_H