ra_map.hpp

This file defines a Random Access Map template.

A random access map allows for simple traversal by index and a guarantee that a value at a given index will always be at that index unless any map element is deleted. This allows storage of indices for maps with a fixed layout, resulting in easy access.

Note

Status: ALPHA

template<typename KEY_T, typename T, typename Hash = std::hash<KEY_T>, typename KeyEqual = std::equal_to<KEY_T>, typename Allocator = std::allocator<std::pair<const KEY_T, T>>> class ra_map

#include <ra_map.hpp>

This class uses a combination of a hashtable (std::unordered_map) and vector to lookup insert, lookup, and delete values in constant time, while still being able to step through all values (albeit in an arbitrary order).

Note

The arbitrary order of values may change if any values are deleted.

Public Types

using key_type = KEY_T 

using mapped_type = T 

using value_type = std::pair<const KEY_T, T>

using size_type = std::size_t

using difference_type = std::ptrdiff_t

using hasher = Hash 

using key_equal = KeyEqual 

using allocator_type = Allocator 

using reference = value_type&

using const_reference = const value_type&

using pointer = typename std::allocator_traits<Allocator>::pointer

using const_pointer = typename std::allocator_traits<Allocator>::const_pointer

using layout_t = unordered_map<KEY_T, size_t, Hash, KeyEqual>

Public Functions

ra_map() = default

ra_map(const ra_map&) = default

ra_map(ra_map&&) = default

this_t &operator=(const ra_map&) = default

this_t &operator=(ra_map&&) = default

inline auto begin()

inline auto cbegin() const

inline auto end()

inline auto cend() const

inline size_t size() const: Number of entries in map.

inline bool empty() const: Are there NO values in map?

inline size_t max_size() const: Max system limit on size.

inline void clear(): Remove all values from container.

inline size_t insert(const value_type &v): Insert a new value into container by copy; return position.

inline size_t insert(value_type &&v): Insert a new value into container by move; return position.

template<typename ...Ts> inline size_t emplace(Ts&&... args): Construct a new value in place in a container container; return position.

inline bool erase(const KEY_T &key): Erase a specific value from the container.

inline size_t count(const KEY_T &key) const

inline T &operator[](key_type key)

Is value included? (0 or 1).

Index into the ra_map by key.

inline const layout_t &GetLayout() const

inline T &NewEntry(key_type key)

inline bool Has(key_type key) const

inline size_t GetID(key_type key) const

inline key_type &KeyAtID(size_t id)

inline T &AtID(size_t id)

inline const T &AtID(size_t id) const

Private Types

using this_t = ra_map<KEY_T, T, Hash, KeyEqual, Allocator>

Private Members

layout_t id_map: Map to find keys in vector.

vector<value_type> vals: Vector of all values.