Template Class HybridMap

• Defined in File HybridMap.h

Class Documentation

template<typename ValueT, typename PairArrayT, PairArrayT PairArray>
class HybridMap

A hybrid map is just like a normal map with keys as string, but elements can also be accessed using an enum for the keys. This is much faster than using strings for the lookup.

Template Parameters:

Enum – an enum with continuous values. The last element must be named “End”.

Public Types

using Map = std::map<std::string, ValueT>

using Vec = std::vector<typename Map::iterator>

using Enum = std::decay_t<decltype(PairArray[0].second)>

using key_type = typename Map::key_type

using mapped_type = typename Map::mapped_type

using iterator = typename Map::iterator

using const_iterator = typename Map::const_iterator

using value_type = typename Map::value_type

using difference_type = typename Map::difference_type

using size_type = typename Map::size_type

Public Functions

HybridMap() noexcept = default

inline HybridMap(HybridMap &&rhs) noexcept

inline HybridMap &operator=(HybridMap &&rhs) noexcept

inline HybridMap(const HybridMap &rhs)

inline HybridMap &operator=(const HybridMap &rhs)

inline HybridMap(const std::initializer_list<std::pair<const std::string, ValueT>> &list)

template<typename InputIterator>
inline HybridMap(InputIterator begin, InputIterator end)

~HybridMap() noexcept = default

inline iterator find(const key_type &k)

inline iterator find(Enum k)

inline const_iterator find(const key_type &k) const

inline const_iterator find(Enum k) const

inline iterator begin()

inline iterator end()

inline const_iterator begin() const

inline const_iterator end() const

inline std::pair<iterator, bool> insert(const value_type &v)

inline iterator insert(const_iterator hint, const value_type &v)

inline iterator erase(const_iterator pos)

inline size_type erase(const std::string &k)

inline ValueT &operator[](const key_type &k)

inline ValueT &operator[](const Enum &k)

inline const ValueT &at(const key_type &k) const

inline const ValueT &at(const Enum &k) const

inline ValueT &at(const key_type &k)

inline ValueT &at(const Enum &k)

inline void clear()

inline bool empty() const

inline size_t size() const

inline auto key_comp() const

inline auto value_comp() const

inline bool operator==(const HybridMap &other) const

inline bool operator!=(const HybridMap &other) const