IOSS 2.0

Classes | Public Types | Public Member Functions | Private Types | Private Attributes | Friends | List of all members
tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > Class Template Reference

`#include <robin_map.h>`

## Classes
class | KeySelect
class | ValueSelect

## Public Types
using | key_type = typename ht::key_type
using | mapped_type = T
using | value_type = typename ht::value_type
using | size_type = typename ht::size_type
using | difference_type = typename ht::difference_type
using | hasher = typename ht::hasher
using | key_equal = typename ht::key_equal
using | allocator_type = typename ht::allocator_type
using | reference = typename ht::reference
using | const_reference = typename ht::const_reference
using | pointer = typename ht::pointer
using | const_pointer = typename ht::const_pointer
using | iterator = typename ht::iterator
using | const_iterator = typename ht::const_iterator

## Public Member Functions
| robin_map ()
| robin_map (size_type bucket_count, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
| robin_map (size_type bucket_count, const Allocator &alloc)
| robin_map (size_type bucket_count, const Hash &hash, const Allocator &alloc)
| robin_map (const Allocator &alloc)
template<class InputIt >
| robin_map (InputIt first, InputIt last, size_type bucket_count=ht::DEFAULT_INIT_BUCKETS_SIZE, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
template<class InputIt >
| robin_map (InputIt first, InputIt last, size_type bucket_count, const Allocator &alloc)
template<class InputIt >
| robin_map (InputIt first, InputIt last, size_type bucket_count, const Hash &hash, const Allocator &alloc)
| robin_map (std::initializer_list< value_type > init, size_type bucket_count=ht::DEFAULT_INIT_BUCKETS_SIZE, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
| robin_map (std::initializer_list< value_type > init, size_type bucket_count, const Allocator &alloc)
| robin_map (std::initializer_list< value_type > init, size_type bucket_count, const Hash &hash, const Allocator &alloc)
robin_map & | operator= (std::initializer_list< value_type > ilist)
allocator_type | get_allocator () const
iterator | begin () noexcept
const_iterator | begin () const noexcept
const_iterator | cbegin () const noexcept
iterator | end () noexcept
const_iterator | end () const noexcept
const_iterator | cend () const noexcept
bool | empty () const noexcept
size_type | size () const noexcept
size_type | max_size () const noexcept
void | clear () noexcept
std::pair< iterator, bool > | insert (const value_type &value)
template<class P , typename std::enable_if< std::is_constructible< value_type, P &&>::value >::type * = nullptr>
std::pair< iterator, bool > | insert (P &&value)
std::pair< iterator, bool > | insert (value_type &&value)
iterator | insert (const_iterator hint, const value_type &value)
template<class P , typename std::enable_if< std::is_constructible< value_type, P &&>::value >::type * = nullptr>
iterator | insert (const_iterator hint, P &&value)
iterator | insert (const_iterator hint, value_type &&value)
template<class InputIt >
void | insert (InputIt first, InputIt last)
void | insert (std::initializer_list< value_type > ilist)
template<class M >
std::pair< iterator, bool > | insert_or_assign (const key_type &k, M &&obj)
template<class M >
std::pair< iterator, bool > | insert_or_assign (key_type &&k, M &&obj)
template<class M >
iterator | insert_or_assign (const_iterator hint, const key_type &k, M &&obj)
template<class M >
iterator | insert_or_assign (const_iterator hint, key_type &&k, M &&obj)
template<class... Args>
std::pair< iterator, bool > | emplace (Args &&... args)
template<class... Args>
iterator | emplace_hint (const_iterator hint, Args &&... args)
template<class... Args>
std::pair< iterator, bool > | try_emplace (const key_type &k, Args &&... args)
template<class... Args>
std::pair< iterator, bool > | try_emplace (key_type &&k, Args &&... args)
template<class... Args>
iterator | try_emplace (const_iterator hint, const key_type &k, Args &&... args)
template<class... Args>
iterator | try_emplace (const_iterator hint, key_type &&k, Args &&... args)
iterator | erase (iterator pos)
iterator | erase (const_iterator pos)
iterator | erase (const_iterator first, const_iterator last)
size_type | erase (const key_type &key)
size_type | erase (const key_type &key, std::size_t precalculated_hash)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
size_type | erase (const K &key)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
size_type | erase (const K &key, std::size_t precalculated_hash)
void | swap (robin_map &other)
T & | at (const Key &key)
T & | at (const Key &key, std::size_t precalculated_hash)
const T & | at (const Key &key) const
const T & | at (const Key &key, std::size_t precalculated_hash) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
T & | at (const K &key)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
T & | at (const K &key, std::size_t precalculated_hash)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const T & | at (const K &key) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const T & | at (const K &key, std::size_t precalculated_hash) const
T & | operator[] (const Key &key)
T & | operator[] (Key &&key)
size_type | count (const Key &key) const
size_type | count (const Key &key, std::size_t precalculated_hash) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
size_type | count (const K &key) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
size_type | count (const K &key, std::size_t precalculated_hash) const
iterator | find (const Key &key)
iterator | find (const Key &key, std::size_t precalculated_hash)
const_iterator | find (const Key &key) const
const_iterator | find (const Key &key, std::size_t precalculated_hash) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
iterator | find (const K &key)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
iterator | find (const K &key, std::size_t precalculated_hash)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const_iterator | find (const K &key) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const_iterator | find (const K &key, std::size_t precalculated_hash) const
std::pair< iterator, iterator > | equal_range (const Key &key)
std::pair< iterator, iterator > | equal_range (const Key &key, std::size_t precalculated_hash)
std::pair< const_iterator, const_iterator > | equal_range (const Key &key) const
std::pair< const_iterator, const_iterator > | equal_range (const Key &key, std::size_t precalculated_hash) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< iterator, iterator > | equal_range (const K &key)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< iterator, iterator > | equal_range (const K &key, std::size_t precalculated_hash)
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< const_iterator, const_iterator > | equal_range (const K &key) const
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< const_iterator, const_iterator > | equal_range (const K &key, std::size_t precalculated_hash) const
size_type | bucket_count () const
size_type | max_bucket_count () const
float | load_factor () const
float | max_load_factor () const
void | max_load_factor (float ml)
void | rehash (size_type count_)
void | reserve (size_type count_)
hasher | hash_function () const
key_equal | key_eq () const
iterator | mutable_iterator (const_iterator pos)

## Private Types
template<typename U >
using | has_is_transparent = tsl::detail_robin_hash::has_is_transparent< U >
using | ht = detail_robin_hash::robin_hash< std::pair< Key, T >, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >

## Private Attributes
ht | m_ht

## Friends
bool | operator== (const robin_map &lhs, const robin_map &rhs)
bool | operator!= (const robin_map &lhs, const robin_map &rhs)
void | swap (robin_map &lhs, robin_map &rhs)

## Detailed Description

### template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
class tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >

Implementation of a hash map using open-adressing and the robin hood hashing algorithm with backward shift deletion.

For operations modifying the hash map (insert, erase, rehash, ...), the strong exception guarantee is only guaranteed when the expression `std::is_nothrow_swappable<std::pair<Key,T>>::value && std::is_nothrow_move_constructible<std::pair<Key, T>>::value` is true, otherwise if an exception is thrown during the swap or the move, the hash map may end up in a undefined state. Per the standard a `Key` or `T` with a noexcept copy constructor and no move constructor also satisfies the `std::is_nothrow_move_constructible<std::pair<Key, T>>::value` criterion (and will thus guarantee the strong exception for the map).

When `StoreHash` is true, 32 bits of the hash are stored alongside the values. It can improve the performance during lookups if the `KeyEqual` function takes time (if it engenders a cache-miss for example) as we then compare the stored hashes before comparing the keys. When `tsl::rh::power_of_two_growth_policy` is used as `GrowthPolicy`, it may also speed-up the rehash process as we can avoid to recalculate the hash. When it is detected that storing the hash will not incur any memory penality due to alignement (i.e. `sizeof(tsl::detail_robin_hash::bucket_entry<ValueType, true>) == sizeof(tsl::detail_robin_hash::bucket_entry<ValueType, false>)`) and `tsl::rh::power_of_two_growth_policy` is used, the hash will be stored even if `StoreHash` is false so that we can speed-up the rehash (but it will not be used on lookups unless `StoreHash` is true).

`GrowthPolicy` defines how the map grows and consequently how a hash value is mapped to a bucket. By default the map uses `tsl::rh::power_of_two_growth_policy`. This policy keeps the number of buckets to a power of two and uses a mask to map the hash to a bucket instead of the slow modulo. Other growth policies are available and you may define your own growth policy, check `tsl::rh::power_of_two_growth_policy` for the interface.

If the destructor of `Key` or `T` throws an exception, the behaviour of the class is undefined.

Iterators invalidation:

- clear, operator=, reserve, rehash: always invalidate the iterators.
- insert, emplace, emplace_hint, operator[]: if there is an effective insert, invalidate the iterators.
- erase: always invalidate the iterators.

## Member Typedef Documentation

## ◆ allocator_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::allocator_type = typename ht::allocator_type

## ◆ const_iterator

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::const_iterator = typename ht::const_iterator

## ◆ const_pointer

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::const_pointer = typename ht::const_pointer

## ◆ const_reference

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::const_reference = typename ht::const_reference

## ◆ difference_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::difference_type = typename ht::difference_type

## ◆ has_is_transparent

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<typename U >

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::has_is_transparent = tsl::detail_robin_hash::has_is_transparent<U>
| private

## ◆ hasher

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::hasher = typename ht::hasher

## ◆ ht

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::ht = detail_robin_hash::robin_hash<std::pair<Key, T>, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy>
| private

## ◆ iterator

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::iterator = typename ht::iterator

## ◆ key_equal

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::key_equal = typename ht::key_equal

## ◆ key_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::key_type = typename ht::key_type

## ◆ mapped_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::mapped_type = T

## ◆ pointer

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::pointer = typename ht::pointer

## ◆ reference

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::reference = typename ht::reference

## ◆ size_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::size_type = typename ht::size_type

## ◆ value_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

using tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::value_type = typename ht::value_type

## Constructor & Destructor Documentation

## ◆ robin_map() [1/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( |  | ) |
| inline

## ◆ robin_map() [2/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | size_type | bucket_count,
|  | const Hash & | hash = `Hash()`,
|  | const KeyEqual & | equal = `KeyEqual()`,
|  | const Allocator & | alloc = `Allocator()`
| ) |  |
| inline explicit

## ◆ robin_map() [3/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | size_type | bucket_count,
|  | const Allocator & | alloc
| ) |  |
| inline

## ◆ robin_map() [4/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | size_type | bucket_count,
|  | const Hash & | hash,
|  | const Allocator & | alloc
| ) |  |
| inline

## ◆ robin_map() [5/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | const Allocator & | alloc | ) |
| inline explicit

## ◆ robin_map() [6/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class InputIt >

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | InputIt | first,
|  | InputIt | last,
|  | size_type | bucket_count = `ht::DEFAULT_INIT_BUCKETS_SIZE`,
|  | const Hash & | hash = `Hash()`,
|  | const KeyEqual & | equal = `KeyEqual()`,
|  | const Allocator & | alloc = `Allocator()`
| ) |  |
| inline

## ◆ robin_map() [7/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class InputIt >

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | InputIt | first,
|  | InputIt | last,
|  | size_type | bucket_count,
|  | const Allocator & | alloc
| ) |  |
| inline

## ◆ robin_map() [8/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class InputIt >

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | InputIt | first,
|  | InputIt | last,
|  | size_type | bucket_count,
|  | const Hash & | hash,
|  | const Allocator & | alloc
| ) |  |
| inline

## ◆ robin_map() [9/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | std::initializer_list< value_type > | init,
|  | size_type | bucket_count = `ht::DEFAULT_INIT_BUCKETS_SIZE`,
|  | const Hash & | hash = `Hash()`,
|  | const KeyEqual & | equal = `KeyEqual()`,
|  | const Allocator & | alloc = `Allocator()`
| ) |  |
| inline

## ◆ robin_map() [10/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | std::initializer_list< value_type > | init,
|  | size_type | bucket_count,
|  | const Allocator & | alloc
| ) |  |
| inline

## ◆ robin_map() [11/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map | ( | std::initializer_list< value_type > | init,
|  | size_type | bucket_count,
|  | const Hash & | hash,
|  | const Allocator & | alloc
| ) |  |
| inline

## Member Function Documentation

## ◆ at() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const Key & | key | ) |
| inline

## ◆ at() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const Key & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ at() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const Key & | key | ) | const
| inline

## ◆ at() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const Key & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ at() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const K & | key | ) |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ at() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ at() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const K & | key | ) | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ at() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::at | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ begin() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::begin | ( |  | ) |
| inline noexcept

## ◆ begin() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::begin | ( |  | ) | const
| inline noexcept

## ◆ bucket_count()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::bucket_count | ( |  | ) | const
| inline

## ◆ cbegin()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::cbegin | ( |  | ) | const
| inline noexcept

## ◆ cend()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::cend | ( |  | ) | const
| inline noexcept

## ◆ clear()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::clear | ( |  | ) |
| inline noexcept

## ◆ count() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::count | ( | const Key & | key | ) | const
| inline

## ◆ count() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::count | ( | const Key & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ count() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::count | ( | const K & | key | ) | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ count() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::count | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ emplace()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class... Args>

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::emplace | ( | Args &&... | args | ) |
| inline

Due to the way elements are stored, emplace will need to move or copy the key-value once. The method is equivalent to insert(value_type(std::forward<Args>(args)...));

Mainly here for compatibility with the std::unordered_map interface.

## ◆ emplace_hint()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class... Args>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::emplace_hint | ( | const_iterator | hint,
|  | Args &&... | args
| ) |  |
| inline

Due to the way elements are stored, emplace_hint will need to move or copy the key-value once. The method is equivalent to insert(hint, value_type(std::forward<Args>(args)...));

Mainly here for compatibility with the std::unordered_map interface.

## ◆ empty()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

bool tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::empty | ( |  | ) | const
| inline noexcept

## ◆ end() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::end | ( |  | ) |
| inline noexcept

## ◆ end() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::end | ( |  | ) | const
| inline noexcept

## ◆ equal_range() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const Key & | key | ) |
| inline

## ◆ equal_range() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const Key & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ equal_range() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const Key & | key | ) | const
| inline

## ◆ equal_range() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const Key & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ equal_range() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<iterator, iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const K & | key | ) |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ equal_range() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<iterator, iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ equal_range() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<const_iterator, const_iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const K & | key | ) | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ equal_range() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<const_iterator, const_iterator> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::equal_range | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ erase() [1/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase | ( | iterator | pos | ) |
| inline

## ◆ erase() [2/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase | ( | const_iterator | pos | ) |
| inline

## ◆ erase() [3/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase | ( | const_iterator | first,
|  | const_iterator | last
| ) |  |
| inline

## ◆ erase() [4/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase | ( | const key_type & | key | ) |
| inline

## ◆ erase() [5/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase | ( | const key_type & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.

## ◆ erase() [6/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase | ( | const K & | key | ) |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ erase() [7/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.

## ◆ find() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const Key & | key | ) |
| inline

## ◆ find() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const Key & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ find() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const Key & | key | ) | const
| inline

## ◆ find() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const Key & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ find() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const K & | key | ) |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ find() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  |
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ find() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const K & | key | ) | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

## ◆ find() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const_iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::find | ( | const K & | key,
|  | std::size_t | precalculated_hash
| ) |  | const
| inline

This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. If so, K must be hashable and comparable to Key.

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.

## ◆ get_allocator()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

allocator_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::get_allocator | ( |  | ) | const
| inline

## ◆ hash_function()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

hasher tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::hash_function | ( |  | ) | const
| inline

## ◆ insert() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | const value_type & | value | ) |
| inline

## ◆ insert() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class P , typename std::enable_if< std::is_constructible< value_type, P &&>::value >::type * = nullptr>

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | P && | value | ) |
| inline

## ◆ insert() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | value_type && | value | ) |
| inline

## ◆ insert() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | const_iterator | hint,
|  | const value_type & | value
| ) |  |
| inline

## ◆ insert() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class P , typename std::enable_if< std::is_constructible< value_type, P &&>::value >::type * = nullptr>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | const_iterator | hint,
|  | P && | value
| ) |  |
| inline

## ◆ insert() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | const_iterator | hint,
|  | value_type && | value
| ) |  |
| inline

## ◆ insert() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class InputIt >

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | InputIt | first,
|  | InputIt | last
| ) |  |
| inline

## ◆ insert() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert | ( | std::initializer_list< value_type > | ilist | ) |
| inline

## ◆ insert_or_assign() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class M >

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert_or_assign | ( | const key_type & | k,
|  | M && | obj
| ) |  |
| inline

## ◆ insert_or_assign() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class M >

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert_or_assign | ( | key_type && | k,
|  | M && | obj
| ) |  |
| inline

## ◆ insert_or_assign() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class M >

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert_or_assign | ( | const_iterator | hint,
|  | const key_type & | k,
|  | M && | obj
| ) |  |
| inline

## ◆ insert_or_assign() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class M >

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert_or_assign | ( | const_iterator | hint,
|  | key_type && | k,
|  | M && | obj
| ) |  |
| inline

## ◆ key_eq()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

key_equal tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::key_eq | ( |  | ) | const
| inline

## ◆ load_factor()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

float tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::load_factor | ( |  | ) | const
| inline

## ◆ max_bucket_count()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::max_bucket_count | ( |  | ) | const
| inline

## ◆ max_load_factor() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

float tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::max_load_factor | ( |  | ) | const
| inline

## ◆ max_load_factor() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::max_load_factor | ( | float | ml | ) |
| inline

## ◆ max_size()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::max_size | ( |  | ) | const
| inline noexcept

## ◆ mutable_iterator()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::mutable_iterator | ( | const_iterator | pos | ) |
| inline

Convert a const_iterator to an iterator.

## ◆ operator=()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

robin_map& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::operator= | ( | std::initializer_list< value_type > | ilist | ) |
| inline

## ◆ operator[]() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::operator[] | ( | const Key & | key | ) |
| inline

## ◆ operator[]() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

T& tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::operator[] | ( | Key && | key | ) |
| inline

## ◆ rehash()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::rehash | ( | size_type | count_ | ) |
| inline

## ◆ reserve()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::reserve | ( | size_type | count_ | ) |
| inline

## ◆ size()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

size_type tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::size | ( |  | ) | const
| inline noexcept

## ◆ swap()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::swap | ( | robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > & | other | ) |
| inline

## ◆ try_emplace() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class... Args>

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::try_emplace | ( | const key_type & | k,
|  | Args &&... | args
| ) |  |
| inline

## ◆ try_emplace() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class... Args>

std::pair<iterator, bool> tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::try_emplace | ( | key_type && | k,
|  | Args &&... | args
| ) |  |
| inline

## ◆ try_emplace() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class... Args>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::try_emplace | ( | const_iterator | hint,
|  | const key_type & | k,
|  | Args &&... | args
| ) |  |
| inline

## ◆ try_emplace() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
template<class... Args>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::try_emplace | ( | const_iterator | hint,
|  | key_type && | k,
|  | Args &&... | args
| ) |  |
| inline

## Friends And Related Function Documentation

## ◆ operator!=

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

bool operator!= | ( | const robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > & | lhs,
|  | const robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > & | rhs
| ) |  |
| friend

## ◆ operator==

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

bool operator== | ( | const robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > & | lhs,
|  | const robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > & | rhs
| ) |  |
| friend

## ◆ swap

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

void swap | ( | robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > & | lhs,
|  | robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > & | rhs
| ) |  |
| friend

## Member Data Documentation

## ◆ m_ht

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, bool StoreHash = false, class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>

ht tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::m_ht
| private

The documentation for this class was generated from the following file:

- src/hash/robin_map.h