#include <Base/include/Framework/Collection/HashMap.hpp>
template<typename K, typename V, typename HashOp = Hash<K>>
bpf::collection::HashMap class

Template parameters
K the key type
V the value type
HashOp the hash operator

Contents

Hash table using open-hashing algorithm

Public types

struct Entry
enum EntryState { ENTRY_STATE_INSTANCE_DELETE, ENTRY_STATE_NON_EXISTANT, ENTRY_STATE_OCCUPIED }
using Iterator = HashMapIterator<HashMap<K, V, HashOp>, Entry, Node>
using CIterator = HashMapConstIterator<HashMap<K, V, HashOp>, Entry, Node>
using ReverseIterator = HashMapReverseIterator<HashMap<K, V, HashOp>, Entry, Node>
using CReverseIterator = HashMapConstReverseIterator<HashMap<K, V, HashOp>, Entry, Node>

Constructors, destructors, conversion operators

HashMap()
HashMap(const HashMap& other)
HashMap(HashMap&& other) noexcept
HashMap(const std::initializer_list<Entry>& entries)
~HashMap()

Public functions

void Add(const K& key, const V& value)
void Add(const K& key, V&& value)
void RemoveAt(const K& key)
void RemoveAt(Iterator& pos)
void RemoveAt(Iterator&& pos)
void Swap(const Iterator& a, const Iterator& b)
void Clear()
template<template<typename> class Comparator = ops::Equal>
void Remove(const V& value, bool all = true)
auto operator==(const HashMap<K, V, HashOp>& other) const -> bool noexcept
auto operator!=(const HashMap<K, V, HashOp>& other) const -> bool noexcept
auto FindByKey(const K& key) -> Iterator
template<template<typename> class Comparator = ops::Equal>
auto FindByValue(const V& val) -> Iterator
auto Find(const std::function<bool(Iterator it)>& comparator) -> Iterator
auto operator[](const K& key) const -> const V&
auto operator[](const K& key) -> V&
auto operator=(const HashMap& other) -> HashMap&
auto operator=(HashMap&& other) -> HashMap& noexcept
auto operator+(const HashMap& other) const -> HashMap
void operator+=(const HashMap& other)
auto HasKey(const K& key) const -> bool
auto Size() const -> fsize
auto begin() const -> CIterator
auto end() const -> CIterator
auto begin() -> Iterator
auto end() -> Iterator
auto rbegin() const -> CReverseIterator
auto rend() const -> CReverseIterator
auto rbegin() -> ReverseIterator
auto rend() -> ReverseIterator

Function documentation

template<typename K, typename V, typename HashOp>
bpf::collection::HashMap<K, V, HashOp>::HashMap()

Constructs an empty HashMap

template<typename K, typename V, typename HashOp>
bpf::collection::HashMap<K, V, HashOp>::HashMap(const HashMap& other)

Copy constructor

template<typename K, typename V, typename HashOp>
bpf::collection::HashMap<K, V, HashOp>::HashMap(HashMap&& other) noexcept

Move constructor

template<typename K, typename V, typename HashOp>
bpf::collection::HashMap<K, V, HashOp>::HashMap(const std::initializer_list<Entry>& entries)

Parameters
entries the initial list of key-value pairs to add to this new HashMap

Constructs a HashMap from an existing initializer list

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::Add(const K& key, const V& value)

Parameters
key the key of the element
value the value to insert

Adds a new element in this hash map, replaces if key already exists

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::Add(const K& key, V&& value)

Parameters
key the key of the element
value the value to insert

Adds a new element in this hash map, replaces if key already exists

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::RemoveAt(const K& key)

Parameters
key the key of the element to remove

Removes an element from the hash table

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::RemoveAt(Iterator& pos)

Parameters
pos iterator of the element to remove, it is undefined behavior to pass a derived Iterator type

Removes an element from the hash table

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::RemoveAt(Iterator&& pos)

Parameters
pos iterator of the element to remove, it is undefined behavior to pass a derived Iterator type

Removes an element from the hash table

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::Swap(const Iterator& a, const Iterator& b)

Parameters
a first element
b second element

Swap two elements by iterator in the HashMap

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::Clear()

Clears the content of this HashMap WARNING: Does not automatically deallocate existing items in this map

template<typename K, typename V, typename HashOp> template<template<typename> class Comparator = ops::Equal>
void bpf::collection::HashMap<K, V, HashOp>::Remove(const V& value, bool all = true)

Template parameters
Comparator the comparision operator to use for comparing values
Parameters
value the value to search for
all wether to remove all occurances or just the first one

Removes an element by value

template<typename K, typename V, typename HashOp>
bool bpf::collection::HashMap<K, V, HashOp>::operator==(const HashMap<K, V, HashOp>& other) const noexcept

Parameters
other HashMap to compare with
Returns true if the two maps are equal, false otherwise

Compare HashMap by performing a per-element check

template<typename K, typename V, typename HashOp>
bool bpf::collection::HashMap<K, V, HashOp>::operator!=(const HashMap<K, V, HashOp>& other) const noexcept

Parameters
other HashMap to compare with
Returns false if the two maps are equal, true otherwise

Compare HashMap by performing a per-element check

template<typename K, typename V, typename HashOp>
Iterator bpf::collection::HashMap<K, V, HashOp>::FindByKey(const K& key)

Parameters
key the key of the item to search for
Returns iterator to the found item or end() if none

Locate an item by key inside this map

template<typename K, typename V, typename HashOp> template<template<typename> class Comparator = ops::Equal>
Iterator bpf::collection::HashMap<K, V, HashOp>::FindByValue(const V& val)

Template parameters
Comparator comparision operator to use
Parameters
val the value to search for
Returns iterator to the found item or end() if none

Locate an item by performing per-element check

template<typename K, typename V, typename HashOp>
Iterator bpf::collection::HashMap<K, V, HashOp>::Find(const std::function<bool(Iterator it)>& comparator)

Parameters
comparator the comparision function to use
Returns iterator to the found item or end() if none

Locate an item by performing per-element check

template<typename K, typename V, typename HashOp>
const V& bpf::collection::HashMap<K, V, HashOp>::operator[](const K& key) const

Parameters
key the key of the element
Returns immutable item
Exceptions
IndexException if key is not in this map

Returns an element const mode

template<typename K, typename V, typename HashOp>
V& bpf::collection::HashMap<K, V, HashOp>::operator[](const K& key)

Parameters
key the key of the element
Returns mutable item
Exceptions
IndexException if key is not in this map and cannot be created

Returns an element non-const mode

template<typename K, typename V, typename HashOp>
HashMap& bpf::collection::HashMap<K, V, HashOp>::operator=(const HashMap& other)

Copy assignment operator

template<typename K, typename V, typename HashOp>
HashMap& bpf::collection::HashMap<K, V, HashOp>::operator=(HashMap&& other) noexcept

Move assignment operator

template<typename K, typename V, typename HashOp>
HashMap bpf::collection::HashMap<K, V, HashOp>::operator+(const HashMap& other) const

Parameters
other map to concatenate with
Returns new HashMap

Create a new HashMap from concatenation of two maps

template<typename K, typename V, typename HashOp>
void bpf::collection::HashMap<K, V, HashOp>::operator+=(const HashMap& other)

Parameters
other map to append

Appends the content of a HashMap at the end of this map

template<typename K, typename V, typename HashOp>
bool bpf::collection::HashMap<K, V, HashOp>::HasKey(const K& key) const

Parameters
key the key to check
Returns true if the specified key exists, false otherwise

Check if a particular key exists

template<typename K, typename V, typename HashOp>
fsize bpf::collection::HashMap<K, V, HashOp>::Size() const

Returns number of items as unsigned

Returns the number of items in this map

template<typename K, typename V, typename HashOp>
CIterator bpf::collection::HashMap<K, V, HashOp>::begin() const

Returns new iterator

Returns an iterator to the begining of the collection

template<typename K, typename V, typename HashOp>
CIterator bpf::collection::HashMap<K, V, HashOp>::end() const

Returns new iterator

Returns an iterator to the end of the collection

template<typename K, typename V, typename HashOp>
Iterator bpf::collection::HashMap<K, V, HashOp>::begin()

Returns new iterator

Returns an iterator to the begining of the collection

template<typename K, typename V, typename HashOp>
Iterator bpf::collection::HashMap<K, V, HashOp>::end()

Returns new iterator

Returns an iterator to the end of the collection

template<typename K, typename V, typename HashOp>
CReverseIterator bpf::collection::HashMap<K, V, HashOp>::rbegin() const

Returns new iterator

Returns a reverse iterator to the begining of the collection

template<typename K, typename V, typename HashOp>
CReverseIterator bpf::collection::HashMap<K, V, HashOp>::rend() const

Returns new iterator

Returns a reverse iterator to the end of the collection

template<typename K, typename V, typename HashOp>
ReverseIterator bpf::collection::HashMap<K, V, HashOp>::rbegin()

Returns new iterator

Returns a reverse iterator to the begining of the collection

template<typename K, typename V, typename HashOp>
ReverseIterator bpf::collection::HashMap<K, V, HashOp>::rend()

Returns new iterator

Returns a reverse iterator to the end of the collection