DenseEnumMap.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
namespace Bedrock {
 
template <typename Key, typename Value, std::size_t Size>
    requires std::is_enum_v<Key>
class DenseEnumMap {
public:
    using key_type               = Key;
    using mapped_type            = Value;
    using value_type             = Value;
    using size_type              = std::size_t;
    using reference              = Value&;
    using const_reference        = Value const&;
    using pointer                = Value*;
    using const_pointer          = Value const*;
    using iterator               = typename std::array<Value, Size>::iterator;
    using const_iterator         = typename std::array<Value, Size>::const_iterator;
    using reverse_iterator       = typename std::array<Value, Size>::reverse_iterator;
    using const_reverse_iterator = typename std::array<Value, Size>::const_reverse_iterator;
 
private:
    std::array<Value, Size> mContainer{};
 
public:
    constexpr DenseEnumMap() = default;
 
    constexpr DenseEnumMap(std::initializer_list<Value> init) : mContainer{} {
        std::copy_n(init.begin(), std::min(init.size(), Size), mContainer.begin());
    }
 
    constexpr reference operator[](Key key) noexcept { return mContainer[static_cast<size_type>(key)]; }
 
    constexpr const_reference operator[](Key key) const noexcept { return mContainer[static_cast<size_type>(key)]; }
 
    constexpr reference at(Key key) { return mContainer.at(static_cast<size_type>(key)); }
 
    constexpr const_reference at(Key key) const { return mContainer.at(static_cast<size_type>(key)); }
 
    constexpr pointer       data() noexcept { return mContainer.data(); }
    constexpr const_pointer data() const noexcept { return mContainer.data(); }
 
    constexpr iterator begin() noexcept { return mContainer.begin(); }
    constexpr iterator end() noexcept { return mContainer.end(); }
 
    constexpr const_iterator begin() const noexcept { return mContainer.begin(); }
    constexpr const_iterator end() const noexcept { return mContainer.end(); }
 
    constexpr const_iterator cbegin() const noexcept { return mContainer.cbegin(); }
    constexpr const_iterator cend() const noexcept { return mContainer.cend(); }
 
    constexpr reverse_iterator       rbegin() noexcept { return mContainer.rbegin(); }
    constexpr reverse_iterator       rend() noexcept { return mContainer.rend(); }
    constexpr const_reverse_iterator crbegin() const noexcept { return mContainer.crbegin(); }
    constexpr const_reverse_iterator crend() const noexcept { return mContainer.crend(); }
 
    [[nodiscard]] constexpr std::size_t size() const noexcept { return Size; }
    [[nodiscard]] constexpr bool        empty() const noexcept { return Size == 0; }
 
    constexpr void fill(Value const& value) { mContainer.fill(value); }
};
 
} // namespace Bedrock