static_vector.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include <cstddef>
#include <iterator>
#include <stdexcept>
#include <type_traits>
#include <uni20/common/trace.hpp>
#include <utility>
 
template <typename T, std::size_t MaxSize> class static_vector {
  public:
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = T&;
    using const_reference = T const&;
    using pointer = T*;
    using const_pointer = T const*;
    using iterator = T*;
    using const_iterator = T const*;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    static_vector() noexcept : size_(0) {}
 
    explicit static_vector(size_type count) : size_(count)
    {
      DEBUG_PRECONDITION(count <= MaxSize);
      for (size_type i = 0; i < size_; ++i)
      {
        ::new (data() + i) T();
      }
    }
 
    static_vector(size_type count, T const& value) : size_(count)
    {
      DEBUG_PRECONDITION(count <= MaxSize);
      for (size_type i = 0; i < size_; ++i)
      {
        ::new (data() + i) T(value);
      }
    }
 
    static_vector(std::initializer_list<T> init) : size_(init.size())
    {
      DEBUG_PRECONDITION(init.size() <= MaxSize);
      size_type i = 0;
      for (T const& v : init)
      {
        ::new (data() + i++) T(v);
      }
    }
 
    static_vector(static_vector const& o) : size_(o.size_)
    {
      for (size_type i = 0; i < size_; ++i)
      {
        ::new (data() + i) T(o.data()[i]);
      }
    }
 
    static_vector(static_vector&& o) noexcept(std::is_nothrow_move_constructible<T>::value) : size_(o.size_)
    {
      for (size_type i = 0; i < size_; ++i)
      {
        ::new (data() + i) T(std::move(o.data()[i]));
        o.data()[i].~T();
      }
      o.size_ = 0;
    }
 
    ~static_vector() { clear(); }
 
    static_vector& operator=(static_vector const& o)
    {
      if (this != &o)
      {
        clear();
        size_ = o.size_;
        for (size_type i = 0; i < size_; ++i)
        {
          ::new (data() + i) T(o.data()[i]);
        }
      }
      return *this;
    }
 
    static_vector& operator=(static_vector&& o) noexcept(std::is_nothrow_move_assignable<T>::value)
    {
      if (this != &o)
      {
        clear();
        size_ = o.size_;
        for (size_type i = 0; i < size_; ++i)
        {
          ::new (data() + i) T(std::move(o.data()[i]));
          o.data()[i].~T();
        }
        o.size_ = 0;
      }
      return *this;
    }
 
    static_vector& operator=(std::initializer_list<T> init)
    {
      clear();
      size_ = init.size();
      DEBUG_PRECONDITION(size_ <= MaxSize);
      size_type i = 0;
      for (T const& v : init)
      {
        ::new (data() + i++) T(v);
      }
      return *this;
    }
 
    [[nodiscard]] reference at(size_type pos)
    {
      if (pos >= size_) throw std::out_of_range("static_vector::at");
      return data()[pos];
    }
 
    [[nodiscard]] const_reference at(size_type pos) const
    {
      if (pos >= size_) throw std::out_of_range("static_vector::at");
      return data()[pos];
    }
 
    reference operator[](size_type pos)
    {
      DEBUG_PRECONDITION(pos < size_);
      return data()[pos];
    }
 
    const_reference operator[](size_type pos) const
    {
      DEBUG_PRECONDITION(pos < size_);
      return data()[pos];
    }
 
    [[nodiscard]] reference front()
    {
      DEBUG_PRECONDITION(size_ > 0);
      return data()[0];
    }
 
    [[nodiscard]] const_reference front() const
    {
      DEBUG_PRECONDITION(size_ > 0);
      return data()[0];
    }
 
    [[nodiscard]] reference back()
    {
      DEBUG_PRECONDITION(size_ > 0);
      return data()[size_ - 1];
    }
 
    [[nodiscard]] const_reference back() const
    {
      DEBUG_PRECONDITION(size_ > 0);
      return data()[size_ - 1];
    }
 
    [[nodiscard]] pointer data() noexcept { return reinterpret_cast<T*>(storage_.buf); }
    [[nodiscard]] const_pointer data() const noexcept { return reinterpret_cast<T const*>(storage_.buf); }
 
    [[nodiscard]] iterator begin() noexcept { return data(); }
    [[nodiscard]] const_iterator begin() const noexcept { return data(); }
    [[nodiscard]] const_iterator cbegin() const noexcept { return data(); }
 
    [[nodiscard]] iterator end() noexcept { return data() + size_; }
    [[nodiscard]] const_iterator end() const noexcept { return data() + size_; }
    [[nodiscard]] const_iterator cend() 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]] const_reverse_iterator crbegin() 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_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
 
    [[nodiscard]] bool empty() const noexcept { return size_ == 0; }
    [[nodiscard]] size_type size() const noexcept { return size_; }
    static constexpr size_type max_size() noexcept { return MaxSize; }
    static constexpr size_type capacity() noexcept { return MaxSize; }
 
    void clear() noexcept
    {
      for (size_type i = 0; i < size_; ++i)
      {
        data()[i].~T();
      }
      size_ = 0;
    }
 
    void push_back(T const& value)
    {
      DEBUG_PRECONDITION(size_ < MaxSize);
      ::new (data() + size_) T(value);
      ++size_;
    }
 
    void push_back(T&& value)
    {
      DEBUG_PRECONDITION(size_ < MaxSize);
      ::new (data() + size_) T(std::move(value));
      ++size_;
    }
 
    template <class... Args> void emplace_back(Args&&... args)
    {
      DEBUG_PRECONDITION(size_ < MaxSize);
      ::new (data() + size_) T(std::forward<Args>(args)...);
      ++size_;
    }
 
    void pop_back()
    {
      DEBUG_PRECONDITION(size_ > 0);
      data()[--size_].~T();
    }
 
    void resize(size_type count)
    {
      DEBUG_PRECONDITION(count <= MaxSize);
      if (count < size_)
      {
        for (size_type i = count; i < size_; ++i)
        {
          data()[i].~T();
        }
      }
      else
      {
        for (size_type i = size_; i < count; ++i)
        {
          ::new (data() + i) T();
        }
      }
      size_ = count;
    }
 
    void swap(static_vector& other) noexcept(std::is_nothrow_swappable<T>::value)
    {
      size_type m = size_ < other.size_ ? size_ : other.size_;
      for (size_type i = 0; i < m; ++i)
      {
        using std::swap;
        swap(data()[i], other.data()[i]);
      }
      if (size_ < other.size_)
      {
        for (size_type i = m; i < other.size_; ++i)
        {
          emplace_back(std::move(other.data()[i]));
        }
        other.resize(m);
      }
      else if (size_ > other.size_)
      {
        for (size_type i = m; i < size_; ++i)
        {
          other.emplace_back(std::move(data()[i]));
        }
        resize(m);
      }
    }
 
  private:
    struct Storage
    {
        alignas(T) unsigned char buf[MaxSize * sizeof(T)];
    } storage_;
    size_type size_;
};
 
template <typename T> class static_vector<T, 0> {
  public:
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = T&;
    using const_reference = T const&;
    using pointer = T*;
    using const_pointer = T const*;
    using iterator = T*;
    using const_iterator = T const*;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    static_vector() noexcept = default;
    explicit static_vector(size_type count) { DEBUG_CHECK_EQUAL(count, 0); }
    static_vector(size_type count, T const&) { DEBUG_CHECK_EQUAL(count, 0); }
    static_vector(std::initializer_list<T> init) { DEBUG_CHECK_EQUAL(init.size(), 0); }
 
    static_vector(static_vector const&) = default;
    static_vector(static_vector&&) noexcept = default;
    static_vector& operator=(static_vector const&) = default;
    static_vector& operator=(static_vector&&) noexcept = default;
    static_vector& operator=(std::initializer_list<T> init)
    {
      DEBUG_CHECK_EQUAL(init.size(), 0);
      return *this;
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept { return true; }
    [[nodiscard]] constexpr size_type size() const noexcept { return 0; }
    static constexpr size_type max_size() noexcept { return 0; }
    static constexpr size_type capacity() noexcept { return 0; }
 
    void clear() noexcept {}
    void resize(size_type count) { DEBUG_CHECK_EQUAL(count, 0); }
 
    void push_back(T const&) { PANIC("unexpected: push_back() on a static_vector of size 0"); }
    void push_back(T&&) { PANIC("unexpected: push_back() on a static_vector of size 0"); }
    template <typename... Args> void emplace_back(Args&&...)
    {
      PANIC("unexpected: emplace_back() on a static_vector of size 0");
    }
    void pop_back() { PANIC("unexpected: pop_back() on a static_vector of size 0"); }
 
    [[nodiscard]] reference at(size_type) { throw std::out_of_range("static_vector<..., 0>::at"); }
    [[nodiscard]] const_reference at(size_type) const { throw std::out_of_range("static_vector<..., 0>::at"); }
 
    reference operator[](size_type) { PANIC("unexpected: operator[] on a static_vector of size 0"); }
    const_reference operator[](size_type) const { PANIC("unexpected: operator[] on a static_vector of size 0"); }
 
    [[nodiscard]] reference front() { PANIC("unexpected: front() on a static_vector of size 0"); }
    [[nodiscard]] const_reference front() const
    {
      PANIC("unexpected: front() on a static_vector of size 0");
      std::abort();
    }
 
    [[nodiscard]] reference back()
    {
      PANIC("unexpected: back() on a static_vector of size 0");
      std::abort();
    }
    [[nodiscard]] const_reference back() const
    {
      PANIC("unexpected: back() on a static_vector of size 0");
      std::abort();
    }
 
    [[nodiscard]] pointer data() noexcept { return nullptr; }
    [[nodiscard]] const_pointer data() const noexcept { return nullptr; }
 
    [[nodiscard]] iterator begin() noexcept { return nullptr; }
    [[nodiscard]] const_iterator begin() const noexcept { return nullptr; }
    [[nodiscard]] const_iterator cbegin() const noexcept { return nullptr; }
 
    [[nodiscard]] iterator end() noexcept { return nullptr; }
    [[nodiscard]] const_iterator end() const noexcept { return nullptr; }
    [[nodiscard]] const_iterator cend() const noexcept { return nullptr; }
 
    [[nodiscard]] reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
    [[nodiscard]] const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
    [[nodiscard]] const_reverse_iterator crbegin() 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_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
 
    void swap(static_vector&) noexcept {}
 
  private:
    // no storage
};