Class DenseEnumMap

include/common/dense_enum_map.h:25–73

template <std::size_t Size, class Key, class T = std::string_view>
class DenseEnumMap {
  static_assert(std::is_enum_v<Key>, "Key should be an enum type!");

public:
  class ConstIterator;
  using key_type = Key;
  using mapped_type = T;
  using value_type = const std::pair<Key, T>;
  using size_type = std::size_t;
  using difference_type = std::ptrdiff_t;
  using reference = value_type &;
  using const_reference = const value_type &;
  using pointer = value_type *;
  using const_pointer = const value_type *;
  using iterator = ConstIterator;
  using const_iterator = ConstIterator;

  constexpr DenseEnumMap() noexcept = delete;
  constexpr DenseEnumMap(const DenseEnumMap &) noexcept = delete;
  constexpr DenseEnumMap(DenseEnumMap &&) noexcept = default;
  constexpr DenseEnumMap &operator=(const DenseEnumMap &) noexcept = delete;
  constexpr DenseEnumMap &operator=(DenseEnumMap &&) noexcept = default;

  constexpr DenseEnumMap(
      const std::pair<Key, std::string_view> (&Array)[Size]) noexcept {
    for (size_type I = 0; I < Size; ++I) {
      Data[static_cast<size_type>(Array[I].first)] = Array[I].second;
    }
  }

  constexpr const mapped_type &operator[](key_type K) const noexcept {
    return Data[static_cast<size_type>(K)];
  }

  constexpr const_iterator begin() const noexcept {
    return {Data, static_cast<size_type>(0)};
  }

  constexpr const_iterator end() const noexcept {
    return {Data, static_cast<size_type>(Size)};
  }

  constexpr const_iterator find(key_type K) const noexcept {
    return {Data, std::min(static_cast<size_type>(K), Size)};
  }

private:
  std::array<T, Size> Data;
};

template <class Key, std::size_t Size>
DenseEnumMap(const std::pair<Key, std::string_view> (&)[Size])