#include <robin_map.h>

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)

void	erase_fast (iterator pos)

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

void	reserve (size_type 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)

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>
class pxr_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 pxr_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(pxr_tsl::detail_robin_hash::bucket_entry<ValueType, true>) == sizeof(pxr_tsl::detail_robin_hash::bucket_entry<ValueType, false>)) and pxr_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 pxr_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 pxr_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.

Definition at line 96 of file robin_map.h.

Member Typedef Documentation

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 141 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 147 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 145 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 143 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 138 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 139 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 146 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 140 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 134 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 135 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 144 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 142 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 137 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 136 of file robin_map.h.

Constructor & Destructor Documentation

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map ( )

inline

Definition at line 153 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

pxr_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

Definition at line 155 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 160 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 163 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_map ( const Allocator & alloc )

inlineexplicit

Definition at line 166 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class InputIt >

pxr_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

Definition at line 170 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class InputIt >

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

inline

Definition at line 179 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class InputIt >

pxr_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

Definition at line 184 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

pxr_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

Definition at line 188 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

pxr_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

Definition at line 194 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

pxr_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

Definition at line 199 of file robin_map.h.

Member Function Documentation

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 395 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

T& pxr_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.

Definition at line 402 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 406 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 411 of file robin_map.h.

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 = pxr_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& pxr_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.

Definition at line 423 of file robin_map.h.

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

Definition at line 437 of file robin_map.h.

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 = pxr_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& pxr_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.

Definition at line 447 of file robin_map.h.

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

Definition at line 457 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inlinenoexcept

Definition at line 218 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inlinenoexcept

Definition at line 219 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 685 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inlinenoexcept

Definition at line 220 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inlinenoexcept

Definition at line 224 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

void pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::clear ( )

inlinenoexcept

Definition at line 236 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 571 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

bool pxr_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.

Definition at line 578 of file robin_map.h.

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 = pxr_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 pxr_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.

Definition at line 590 of file robin_map.h.

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

Definition at line 604 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 464 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

size_type pxr_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.

Definition at line 471 of file robin_map.h.

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 = pxr_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 pxr_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.

Definition at line 483 of file robin_map.h.

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

Definition at line 497 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class Deserializer >

static robin_map pxr_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.

Definition at line 773 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class... Args>

std::pair<iterator, bool> pxr_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.

Definition at line 303 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class... Args>

iterator pxr_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.

Definition at line 315 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

bool pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::empty ( void ) const

inlinenoexcept

Definition at line 229 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inlinenoexcept

Definition at line 222 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inlinenoexcept

Definition at line 223 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 608 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> pxr_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.

Definition at line 617 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 622 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> pxr_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). Useful to speed-up the lookup if you already have the hash.

Definition at line 629 of file robin_map.h.

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 = pxr_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> pxr_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.

Definition at line 642 of file robin_map.h.

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

Definition at line 656 of file robin_map.h.

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 = pxr_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> pxr_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.

Definition at line 667 of file robin_map.h.

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

Definition at line 677 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 340 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 341 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 342 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 345 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

size_type pxr_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.

Definition at line 360 of file robin_map.h.

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 = pxr_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 pxr_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.

Definition at line 372 of file robin_map.h.

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

Definition at line 386 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

void pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase_fast ( iterator pos )

inline

Erase the element at position 'pos'. In contrast to the regular erase() function, erase_fast() does not return an iterator. This allows it to be faster especially in hash tables with a low load factor, where finding the next nonempty bucket would be costly.

Definition at line 353 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 501 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

iterator pxr_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.

Definition at line 508 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 512 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

Definition at line 517 of file robin_map.h.

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 = pxr_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 pxr_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.

Definition at line 529 of file robin_map.h.

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

Definition at line 543 of file robin_map.h.

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 = pxr_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 pxr_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.

Definition at line 553 of file robin_map.h.

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

Definition at line 567 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 213 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 714 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 238 of file robin_map.h.

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 = pxr_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> pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert ( P && value )

inline

Definition at line 244 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 248 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 252 of file robin_map.h.

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 = pxr_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 pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::insert	(	const_iterator	hint,
		P &&	value
	)

inline

Definition at line 258 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 262 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class InputIt >

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

inline

Definition at line 267 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 271 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class M >

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

inline

Definition at line 276 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class M >

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

inline

Definition at line 281 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class M >

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

inline

Definition at line 286 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class M >

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

inline

Definition at line 291 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 715 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 691 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 686 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 694 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 706 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

size_type pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::max_size ( void ) const

inlinenoexcept

Definition at line 231 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

float pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::min_load_factor ( ) const

inline

Definition at line 693 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

void pxr_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.

Definition at line 705 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Convert a const_iterator to an iterator.

Definition at line 724 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 204 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 461 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 462 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 708 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 709 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class Serializer >

void pxr_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.

Definition at line 742 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

size_type pxr_tsl::robin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::size ( void ) const

inlinenoexcept

Definition at line 230 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

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

inline

Definition at line 390 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class... Args>

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

inline

Definition at line 320 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class... Args>

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

inline

Definition at line 325 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class... Args>

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

inline

Definition at line 330 of file robin_map.h.

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 = pxr_tsl::rh::power_of_two_growth_policy<2>>

template<class... Args>

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

inline

Definition at line 335 of file robin_map.h.

Friends And Related Function Documentation

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

Definition at line 797 of file robin_map.h.

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

Definition at line 781 of file robin_map.h.

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

Definition at line 801 of file robin_map.h.

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

pxr/base/tf/pxrTslRobinMap/robin_map.h

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation