Create EnumMap

Source/Core/Common/EnumMap.h

@@ -0,0 +1,83 @@
+// Copyright 2021 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <type_traits>
+
+#include "Common/TypeUtils.h"
+
+template <std::size_t position, std::size_t bits, typename T, typename StorageType>
+struct BitField;
+
+namespace Common
+{
+// A type that allows lookup of values associated with an enum as the key.
+// Designed for enums whose numeric values start at 0 and increment continuously with few gaps.
+template <typename V, auto last_member, typename = decltype(last_member)>
+class EnumMap final
+{
+  // The third template argument is needed to avoid compile errors from ambiguity with multiple
+  // enums with the same number of members in GCC prior to 8.  See https://godbolt.org/z/xcKaW1seW
+  // and https://godbolt.org/z/hz7Yqq1P5
+  using T = decltype(last_member);
+  static_assert(std::is_enum_v<T>);
+  static constexpr size_t s_size = static_cast<size_t>(last_member) + 1;
+
+  using array_type = std::array<V, s_size>;
+  using iterator = typename array_type::iterator;
+  using const_iterator = typename array_type::const_iterator;
+
+public:
+  constexpr EnumMap() = default;
+  constexpr EnumMap(const EnumMap& other) = default;
+  constexpr EnumMap& operator=(const EnumMap& other) = default;
+  constexpr EnumMap(EnumMap&& other) = default;
+  constexpr EnumMap& operator=(EnumMap&& other) = default;
+
+  // Constructor that accepts exactly size Vs (enforcing that all must be specified).
+  template <typename... T, typename = std::enable_if_t<Common::IsNOf<V, s_size, T...>::value>>
+  constexpr EnumMap(T... values) : m_array{static_cast<V>(values)...}
+  {
+  }
+
+  constexpr const V& operator[](T key) const { return m_array[static_cast<std::size_t>(key)]; }
+  constexpr V& operator[](T key) { return m_array[static_cast<std::size_t>(key)]; }
+
+  // These only exist to perform the safety check; without them, BitField's implicit conversion
+  // would work (but since BitField is used for game-generated data, we need to be careful about
+  // bounds-checking)
+  template <std::size_t position, std::size_t bits, typename StorageType>
+  constexpr const V& operator[](BitField<position, bits, T, StorageType> key) const
+  {
+    static_assert(1 << bits == s_size, "Unsafe indexing into EnumMap (may go out of bounds)");
+    return m_array[static_cast<std::size_t>(key.Value())];
+  }
+  template <std::size_t position, std::size_t bits, typename StorageType>
+  constexpr V& operator[](BitField<position, bits, T, StorageType> key)
+  {
+    static_assert(1 << bits == s_size, "Unsafe indexing into EnumMap (may go out of bounds)");
+    return m_array[static_cast<std::size_t>(key.value())];
+  }
+
+  constexpr bool InBounds(T key) const { return static_cast<std::size_t>(key) < s_size; }
+
+  constexpr size_t size() const noexcept { return s_size; }
+
+  constexpr V* data() { return m_array.data(); }
+  constexpr const V* data() const { return m_array.data(); }
+
+  constexpr iterator begin() { return m_array.begin(); }
+  constexpr iterator end() { return m_array.end(); }
+  constexpr const_iterator begin() const { return m_array.begin(); }
+  constexpr const_iterator end() const { return m_array.end(); }
+  constexpr const_iterator cbegin() const { return m_array.cbegin(); }
+  constexpr const_iterator cend() const { return m_array.cend(); }
+
+  constexpr void fill(const V& v) { m_array.fill(v); }
+
+private:
+  array_type m_array{};
+};
+}  // namespace Common