tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > Class Template Reference

#include <robin_map.h>

Collaboration diagram for tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >:

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
bool	contains (const Key &key) const
bool	contains (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>
bool	contains (const K &key) const
template<class K, class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
bool	contains (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	min_load_factor () const
float	max_load_factor () const
void	min_load_factor (float ml)
void	max_load_factor (float ml)
void	rehash (size_type my_count)
void	reserve (size_type my_count)
hasher	hash_function () const
key_equal	key_eq () const
iterator	mutable_iterator (const_iterator pos)
template<class Serializer>
void	serialize (Serializer &serializer) const

Static Public Member Functions
template<class Deserializer>
static robin_map	deserialize (Deserializer &deserializer, bool hash_compatible=false)

Private Types
template<typename U>
using	has_is_transparent = tsl::detail_robin_hash::has_is_transparent<U>
using	ht

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-addressing 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 penalty due to alignment (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.

std::pair<Key, T> must be swappable.

Key and T must be copy and/or move constructible.

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

private

Initial value:

 detail_robin_hash::robin_hash<std::pair<Key, T>, KeySelect, ValueSelect, Hash,
                                             KeyEqual, Allocator, StoreHash, GrowthPolicy>

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() )

inlineexplicit

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 )

inlineexplicit

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>>

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() [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 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

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>>

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

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

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>>

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

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>>

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

inline

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>>

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

inline

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>>

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). Useful to speed-up the lookup if you already have the hash.

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>>

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

inline

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>>

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

inlinenoexcept

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>>

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

inlinenoexcept

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

inlinenoexcept

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

inlinenoexcept

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 ( )

inlinenoexcept

contains() [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 K, class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

bool tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::contains ( 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.

contains() [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 K, class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

bool tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::contains ( const K & 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). Useful to speed-up the lookup if you already have the hash.

contains() [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>>

bool tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::contains ( const Key & key ) const

inline

contains() [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>>

bool tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::contains ( 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). Useful to speed-up the lookup if you already have the hash.

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>>

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() [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 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

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Useful 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>>

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

inline

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>>

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). Useful to speed-up the lookup if you already have the hash.

deserialize()

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 Deserializer>

static robin_map tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::deserialize ( Deserializer & deserializer, bool hash_compatible = false )

inlinestatic

Deserialize a previously serialized map through the deserializer parameter.

The deserializer parameter must be a function object that supports the following call:

• template<typename U> U operator()(); where the types std::int16_t, std::uint32_t, std::uint64_t, float and std::pair<Key, T> must be supported for U.

If the deserialized hash map type is hash compatible with the serialized map, the deserialization process can be sped up by setting hash_compatible to true. To be hash compatible, the Hash, KeyEqual and GrowthPolicy must behave the same way than the ones used on the serialized map and the StoreHash must have the same value. The std::size_t must also be of the same size as the one on the platform used to serialize the map. If these criteria are not met, the behaviour is undefined with hash_compatible sets to true.

The behaviour is undefined if the type Key and T of the robin_map are not the same as the types used during serialization.

The implementation leaves binary compatibility (endianness, IEEE 754 for floats, size of int, ...) of the types it deserializes in the hands of the Deserializer function object if compatibility is required.

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

inlinenoexcept

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>>

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

inlinenoexcept

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>>

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

inlinenoexcept

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>>

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() [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 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

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>>

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

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

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>>

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

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>>

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

inline

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>>

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() [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>>

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). Useful to speed-up the lookup if you already have the hash.

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>>

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

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>>

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() [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>>

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

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

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>>

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

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, 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). Useful to speed-up the lookup to the value if you already have the hash.

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>>

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

inline

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>>

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

inline

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>>

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

inline

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>>

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() [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 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

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>>

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

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

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>>

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

Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same as hash_function()(key). Useful 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>>

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

inline

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>>

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

inline

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>>

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). Useful to speed-up the lookup if you already have the hash.

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>>

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

inline

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>>

iterator tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert ( const_iterator hint, const value_type & 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>>

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() [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, 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 InputIt>

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

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>>

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() [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>>

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

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>>

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

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>

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() [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, 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>

std::pair< iterator, bool > tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert_or_assign ( 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

inlinenoexcept

min_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 >::min_load_factor ( ) const

inline

min_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 >::min_load_factor ( float ml )

inline

Set the min_load_factor to ml. When the load_factor of the map goes below min_load_factor after some erase operations, the map will be shrunk when an insertion occurs. The erase method itself never shrinks the map.

The default value of min_load_factor is 0.0f, the map never shrinks by default.

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 my_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 my_count )

inline

serialize()

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 Serializer>

void tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::serialize ( Serializer & serializer ) const

inline

Serialize the map through the serializer parameter.

The serializer parameter must be a function object that supports the following call:

• template<typename U> void operator()(const U& value); where the types std::int16_t, std::uint32_t, std::uint64_t, float and std::pair<Key, T> must be supported for U.

The implementation leaves binary compatibility (endianness, IEEE 754 for floats, ...) of the types it serializes in the hands of the Serializer function object if compatibility is required.

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

inlinenoexcept

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>

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() [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, 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>

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

inline

Friends And Related Symbol 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:

• robin_map.h