StaticVector.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Vector.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Allocator.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
 
#include <cstddef>
#include <iterator>
#include <memory>
#include <type_traits>
 
#define CE_STATIC_VECTOR_ERROR_HANDLING_NONE 0
#define CE_STATIC_VECTOR_ERROR_HANDLING_THROW 1
#define CE_STATIC_VECTOR_ERROR_HANDLING_ASSERT 2
#define CE_STATIC_VECTOR_ERROR_HANDLING_RESCUE 3
#define CE_STATIC_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW 4
#define CE_STATIC_VECTOR_ERROR_HANDLING_ASSERT_AND_RESCUE 5
 
#if !defined(CE_STATIC_VECTOR_ERROR_HANDLING)
#define CE_STATIC_VECTOR_ERROR_HANDLING CE_STATIC_VECTOR_ERROR_HANDLING_THROW
#endif
 
#if CE_STATIC_VECTOR_ERROR_HANDLING == CE_STATIC_VECTOR_ERROR_HANDLING_NONE
#define CE_STATIC_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return)
#elif CE_STATIC_VECTOR_ERROR_HANDLING == CE_STATIC_VECTOR_ERROR_HANDLING_THROW
#include <stdexcept>
#define CE_STATIC_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return) \
    if(cond)                                                  \
    throw std::out_of_range("itlib::StaticVector out of range")
#elif CE_STATIC_VECTOR_ERROR_HANDLING == CE_STATIC_VECTOR_ERROR_HANDLING_ASSERT
#include <cassert>
#define CE_STATIC_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return) assert(!(cond) && "itlib::StaticVector out of range")
#elif CE_STATIC_VECTOR_ERROR_HANDLING == CE_STATIC_VECTOR_ERROR_HANDLING_RESCUE
#define CE_STATIC_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return) \
    if(cond)                                                  \
    return rescue_return
#elif CE_STATIC_VECTOR_ERROR_HANDLING == CE_STATIC_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW
#include <cassert>
#include <stdexcept>
#define CE_STATIC_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return)            \
    do {                                                                 \
        if(cond) {                                                       \
            assert(false && "itlib::StaticVector out of range");         \
            throw std::out_of_range("itlib::StaticVector out of range"); \
        }                                                                \
    } while(false)
#elif CE_STATIC_VECTOR_ERROR_HANDLING == CE_STATIC_VECTOR_ERROR_HANDLING_ASSERT_AND_RESCUE
#include <cassert>
#define CE_STATIC_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return)    \
    do {                                                         \
        if(cond) {                                               \
            assert(false && "itlib::StaticVector out of range"); \
            return rescue_return;                                \
        }                                                        \
    } while(false)
#else
#error "Unknown CE_STATIC_VECTOR_ERRROR_HANDLING"
#endif
 
#if defined(CE_STATIC_VECTOR_NO_DEBUG_BOUNDS_CHECK)
#define CE_STATIC_VECTOR_BOUNDS_CHECK(i)
#else
#include <cassert>
#define CE_STATIC_VECTOR_BOUNDS_CHECK(i) assert((i) < this->size())
#endif
 
namespace CeresEngine {
 
    template<typename T, size_t Capacity> struct StaticVector {
        struct FakeAllocator {
            using value_type = T;
            using pointer = T*;
            using const_pointer = const T*;
        };
 
    public:
        using value_type = T;
        using size_type = size_t;
        using difference_type = ptrdiff_t;
        using reference = T&;
        using const_reference = const T&;
        using pointer = T*;
        using const_pointer = const T*;
        using iterator = T*;
        using const_iterator = const T*;
        using reverse_iterator = std::reverse_iterator<iterator>;
        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
        using allocator_type = FakeAllocator;
 
        StaticVector() = default;
 
        explicit StaticVector(const size_t count) { resize(count); }
 
        StaticVector(const size_t count, const T& value) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(count > Capacity, );
 
            for(size_t i = 0; i < count; ++i) {
                push_back(value);
            }
        }
 
        StaticVector(std::initializer_list<T> l) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(l.size() > Capacity, );
 
            for(auto&& i : l) {
                push_back(i);
            }
        }
 
        StaticVector(const StaticVector& v) {
            for(const auto& i : v) {
                push_back(i);
            }
        }
 
        template<size_t CapacityB> StaticVector(const StaticVector<T, CapacityB>& v) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(v.size() > Capacity, );
 
            for(const auto& i : v) {
                push_back(i);
            }
        }
 
        StaticVector(StaticVector&& v) noexcept(std::is_nothrow_move_constructible<T>::value) {
            for(auto i = v.begin(); i != v.end(); ++i) {
                emplace_back(std::move(*i));
            }
            v.clear();
        }
 
        ~StaticVector() { clear(); }
 
        StaticVector& operator=(const StaticVector& v) {
            if(this == &v) {
                // prevent self usurp
                return *this;
            }
 
            clear();
            for(auto& elem : v) {
                push_back(elem);
            }
 
            return *this;
        }
 
        StaticVector& operator=(StaticVector&& v) noexcept(std::is_nothrow_move_assignable<T>::value) {
            clear();
            for(auto i = v.begin(); i != v.end(); ++i) {
                emplace_back(std::move(*i));
            }
 
            v.clear();
            return *this;
        }
 
        const_reference at(size_type i) const {
            CE_STATIC_VECTOR_BOUNDS_CHECK(i);
            return *reinterpret_cast<const T*>(m_data + i);
        }
 
        reference at(size_type i) {
            CE_STATIC_VECTOR_BOUNDS_CHECK(i);
            return *reinterpret_cast<T*>(m_data + i);
        }
 
        [[nodiscard]] const_reference operator[](const size_type i) const { return at(i); }
        [[nodiscard]] reference operator[](const size_type i) { return at(i); }
 
        [[nodiscard]] const_reference front() const { return at(0); }
        [[nodiscard]] reference front() { return at(0); }
 
        [[nodiscard]] const_reference back() const { return at(m_size - 1); }
        [[nodiscard]] reference back() { return at(m_size - 1); }
 
        [[nodiscard]] const_pointer data() const noexcept { return reinterpret_cast<const T*>(m_data); }
        [[nodiscard]] pointer data() noexcept { return reinterpret_cast<T*>(m_data); }
 
        // iterators
        [[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() + m_size; }
        [[nodiscard]] const_iterator end() const noexcept { return data() + m_size; }
        [[nodiscard]] const_iterator cend() const noexcept { return data() + m_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()); }
 
        // capacity
        [[nodiscard]] bool empty() const noexcept { return m_size == 0; }
        [[nodiscard]] size_t size() const noexcept { return m_size; }
        [[nodiscard]] size_t max_size() const noexcept { return Capacity; }
        [[nodiscard]] size_t capacity() const noexcept { return Capacity; }
 
        // modifiers
        void pop_back() {
            reinterpret_cast<const T*>(m_data + m_size - 1)->~T();
            --m_size;
        }
 
        void clear() noexcept {
            while(!empty()) {
                pop_back();
            }
        }
 
        void push_back(const_reference v) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(size() >= Capacity, );
 
            ::new(m_data + m_size) T(v);
            ++m_size;
        }
 
        void push_back(T&& v) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(size() >= Capacity, );
 
            ::new(m_data + m_size) T(std::move(v));
            ++m_size;
        }
 
        template<typename... Args> void emplace_back(Args&&... args) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(size() >= Capacity, );
 
            ::new(m_data + m_size) T(std::forward<Args>(args)...);
            ++m_size;
        }
 
        iterator insert(iterator position, const value_type& val) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(size() >= Capacity, position);
 
            if(position == end()) {
                emplace_back(val);
                return position;
            }
 
            emplace_back(std::move(back()));
 
            for(auto i = end() - 2; i != position; --i) {
                *i = std::move(*(i - 1));
            }
 
            *position = val;
 
            return position;
        }
 
        template<typename... Args> iterator emplace(iterator position, Args&&... args) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(size() >= Capacity, position);
 
            if(position == end()) {
                emplace_back(std::forward<Args>(args)...);
                return position;
            }
 
            emplace_back(std::move(back()));
 
            for(auto i = end() - 2; i != position; --i) {
                *i = std::move(*(i - 1));
            }
 
            position->~T();
            ::new(position) T(std::forward<Args>(args)...);
 
            return position;
        }
 
        iterator erase(const_iterator position) {
            auto dist = position - begin();
            position->~T();
 
            for(auto i = begin() + dist + 1; i != end(); ++i) {
                *(i - 1) = std::move(*i);
            }
 
            resize(size() - 1);
            return begin() + dist;
        }
 
        void resize(const size_type n) {
            CE_STATIC_VECTOR_OUT_OF_RANGE_IF(n > Capacity, );
 
            while(m_size > n) {
                pop_back();
            }
 
            while(n > m_size) {
                emplace_back();
            }
        }
 
        void swap(StaticVector& v) {
            StaticVector* longer;
            StaticVector* shorter;
 
            if(v.m_size > m_size) {
                longer = &v;
                shorter = this;
            } else {
                longer = this;
                shorter = &v;
            }
 
            for(size_t i = 0; i < shorter->size(); ++i) {
                std::swap(shorter->at(i), longer->at(i));
            }
 
            auto short_size = shorter->m_size;
 
            for(size_t i = shorter->size(); i < longer->size(); ++i) {
                shorter->emplace_back(std::move(longer->at(i)));
                longer->at(i).~T();
            }
 
            longer->m_size = short_size;
        }
 
    private:
        typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type m_data[Capacity];
        size_t m_size = 0;
    };
 
    template<typename T, size_t CapacityA, size_t CapacityB>
    [[nodiscard]] bool operator==(const StaticVector<T, CapacityA>& a, const StaticVector<T, CapacityB>& b) {
        if(a.size() != b.size()) {
            return false;
        }
 
        for(size_t i = 0; i < a.size(); ++i) {
            if(a[i] != b[i]) {
                return false;
            }
        }
 
        return true;
    }
 
    template<typename T, size_t CapacityA, size_t CapacityB>
    [[nodiscard]] bool operator!=(const StaticVector<T, CapacityA>& a, const StaticVector<T, CapacityB>& b) {
        if(a.size() != b.size()) {
            return true;
        }
 
        for(size_t i = 0; i < a.size(); ++i) {
            if(a[i] != b[i]) {
                return true;
            }
        }
 
        return false;
    }
 
} // namespace CeresEngine
 
template<typename T, size_t N> struct std::hash<CeresEngine::StaticVector<T, N>> {
    using Type = CeresEngine::StaticVector<T, N>;
    constexpr size_t operator()(const Type& obj) const {
        size_t seed = CeresEngine::hash(obj.size());
        for(const T& value : obj) {
            CeresEngine::combine(seed, value);
        }
        return seed;
    }
};