#include <sparse_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
	sparse_map ()

	sparse_map (size_type bucket_count, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())

	sparse_map (size_type bucket_count, const Allocator &alloc)

	sparse_map (size_type bucket_count, const Hash &hash, const Allocator &alloc)

	sparse_map (const Allocator &alloc)

template<class InputIt >
	sparse_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 >
	sparse_map (InputIt first, InputIt last, size_type bucket_count, const Allocator &alloc)

template<class InputIt >
	sparse_map (InputIt first, InputIt last, size_type bucket_count, const Hash &hash, const Allocator &alloc)

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

	sparse_map (std::initializer_list< value_type > init, size_type bucket_count, const Allocator &alloc)

	sparse_map (std::initializer_list< value_type > init, size_type bucket_count, const Hash &hash, const Allocator &alloc)

sparse_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 (sparse_map &other)

T &	at (const Key &key)

T &	at (const Key &key, std::size_t precalculated_hash)

const T &	at (const Key &key) const

const T &	at (const Key &key, std::size_t precalculated_hash) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
T &	at (const K &key)

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
T &	at (const K &key, std::size_t precalculated_hash)

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const T &	at (const K &key) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const T &	at (const K &key, std::size_t precalculated_hash) const

T &	operator[] (const Key &key)

T &	operator[] (Key &&key)

size_type	count (const Key &key) const

size_type	count (const Key &key, std::size_t precalculated_hash) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
size_type	count (const K &key) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
size_type	count (const K &key, std::size_t precalculated_hash) const

iterator	find (const Key &key)

iterator	find (const Key &key, std::size_t precalculated_hash)

const_iterator	find (const Key &key) const

const_iterator	find (const Key &key, std::size_t precalculated_hash) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
iterator	find (const K &key)

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
iterator	find (const K &key, std::size_t precalculated_hash)

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const_iterator	find (const K &key) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
const_iterator	find (const K &key, std::size_t precalculated_hash) const

std::pair< iterator, iterator >	equal_range (const Key &key)

std::pair< iterator, iterator >	equal_range (const Key &key, std::size_t precalculated_hash)

std::pair< const_iterator, const_iterator >	equal_range (const Key &key) const

std::pair< const_iterator, const_iterator >	equal_range (const Key &key, std::size_t precalculated_hash) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< iterator, iterator >	equal_range (const K &key)

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< iterator, iterator >	equal_range (const K &key, std::size_t precalculated_hash)

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< const_iterator, const_iterator >	equal_range (const K &key) const

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
std::pair< const_iterator, const_iterator >	equal_range (const K &key, std::size_t precalculated_hash) const

size_type	bucket_count () const

size_type	max_bucket_count () const

float	load_factor () const

float	max_load_factor () const

void	max_load_factor (float ml)

void	rehash (size_type count)

void	reserve (size_type count)

hasher	hash_function () const

key_equal	key_eq () const

iterator	mutable_iterator (const_iterator pos)

template<class Serializer >
void	serialize (Serializer &serializer) const

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

Friends
bool	operator== (const sparse_map &lhs, const sparse_map &rhs)

bool	operator!= (const sparse_map &lhs, const sparse_map &rhs)

void	swap (sparse_map &lhs, sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>
class tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >

Implementation of a sparse hash map using open-addressing with quadratic probing. The goal on the hash map is to be the most memory efficient possible, even at low load factor, while keeping reasonable performances.

GrowthPolicy defines how the map grows and consequently how a hash value is mapped to a bucket. By default the map uses tsl::sh::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::sh::power_of_two_growth_policy for the interface.

ExceptionSafety defines the exception guarantee provided by the class. By default only the basic exception safety is guaranteed which mean that all resources used by the hash map will be freed (no memory leaks) but the hash map may end-up in an undefined state if an exception is thrown (undefined here means that some elements may be missing). This can ONLY happen on rehash (either on insert or if rehash is called explicitly) and will occur if the Allocator can't allocate memory (std::bad_alloc) or if the copy constructor (when a nothrow move constructor is not available) throws an exception. This can be avoided by calling reserve beforehand. This basic guarantee is similar to the one of google::sparse_hash_map and spp::sparse_hash_map. It is possible to ask for the strong exception guarantee with tsl::sh::exception_safety::strong, the drawback is that the map will be slower on rehashes and will also need more memory on rehashes.

Sparsity defines how much the hash set will compromise between insertion speed and memory usage. A high sparsity means less memory usage but longer insertion times, and vice-versa for low sparsity. The default tsl::sh::sparsity::medium sparsity offers a good compromise. It doesn't change the lookup speed.

Key and T must be nothrow move constructible and/or copy 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::difference_type = typename ht::difference_type

◆ 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::hasher = typename ht::hasher

◆ 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

using tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::value_type = typename ht::value_type

Constructor & Destructor Documentation

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map ( )

inline

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map	(	size_type	bucket_count,
		const Hash &	hash = `Hash()`,
		const KeyEqual &	equal = `KeyEqual()`,
		const Allocator &	alloc = `Allocator()`
	)

inlineexplicit

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map	(	size_type	bucket_count,
		const Allocator &	alloc
	)

inline

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map	(	size_type	bucket_count,
		const Hash &	hash,
		const Allocator &	alloc
	)

inline

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map ( const Allocator & alloc )

inlineexplicit

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class InputIt >

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_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

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class InputIt >

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map	(	InputIt	first,
		InputIt	last,
		size_type	bucket_count,
		const Allocator &	alloc
	)

inline

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class InputIt >

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map	(	InputIt	first,
		InputIt	last,
		size_type	bucket_count,
		const Hash &	hash,
		const Allocator &	alloc
	)

inline

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_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

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_map	(	std::initializer_list< value_type >	init,
		size_type	bucket_count,
		const Allocator &	alloc
	)

inline

◆ sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::sparse_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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::at ( const Key & key )

inline

◆ at() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ at() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::at ( const Key & key ) const

inline

◆ at() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ at() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::at ( const K & key )

inline

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

◆ at() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ at() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::at ( const K & key ) const

inline

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

◆ at() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ begin() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::begin ( )

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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::begin ( ) const

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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::clear ( )

inlinenoexcept

◆ 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::count ( const Key & key ) const

inline

◆ count() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::count ( const K & key ) const

inline

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

◆ count() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class Deserializer >

static sparse_map tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::deserialize	(	Deserializer &	deserializer,
		bool	hash_compatible = `false`
	)

inlinestatic

Deserialize a previouly serialized map through the deserializer parameter.

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

template<typename U> U operator()(); where the types 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. 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 sparse_map are not the same as the types used during serialization.

The implementation leaves binary compatibilty (endianness, IEEE 754 for floats, size of int, ...) of the types it deserializes in the hands of the Deserializer function object if compatibilty 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class... Args>

std::pair<iterator, bool> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class... Args>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

bool tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::end ( )

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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::end ( ) const

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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

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

inline

◆ equal_range() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

std::pair<iterator, iterator> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ equal_range() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

std::pair<const_iterator, const_iterator> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::equal_range ( const Key & key ) const

inline

◆ equal_range() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

std::pair<const_iterator, const_iterator> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ equal_range() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<iterator, iterator> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::equal_range ( const K & key )

inline

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

◆ equal_range() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<iterator, iterator> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ equal_range() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<const_iterator, const_iterator> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::equal_range ( const K & key ) const

inline

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

◆ equal_range() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

std::pair<const_iterator, const_iterator> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ erase() [1/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::erase ( iterator pos )

inline

◆ erase() [2/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::erase ( const_iterator pos )

inline

◆ erase() [3/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::erase	(	const_iterator	first,
		const_iterator	last
	)

inline

◆ erase() [4/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::erase ( const key_type & key )

inline

◆ erase() [5/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ erase() [6/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::erase ( const K & key )

inline

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

◆ erase() [7/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ find() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::find ( const Key & key )

inline

◆ find() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ find() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::find ( const Key & key ) const

inline

◆ find() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::find ( const K & key )

inline

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

◆ find() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ find() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::find ( const K & key ) const

inline

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

◆ find() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>

const_iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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), otherwise the behaviour is undefined. Useful to speed-up the lookup if you already have the hash.

◆ get_allocator()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

allocator_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

hasher tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

std::pair<iterator, bool> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class P , typename std::enable_if< std::is_constructible< value_type, P &&>::value >::type * = nullptr>

std::pair<iterator, bool> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert ( P && value )

inline

◆ insert() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

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

inline

◆ insert() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert	(	const_iterator	hint,
		const value_type &	value
	)

inline

◆ insert() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class P , typename std::enable_if< std::is_constructible< value_type, P &&>::value >::type * = nullptr>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert	(	const_iterator	hint,
		P &&	value
	)

inline

◆ insert() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert	(	const_iterator	hint,
		value_type &&	value
	)

inline

◆ insert() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class InputIt >

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert	(	InputIt	first,
		InputIt	last
	)

inline

◆ insert() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert ( std::initializer_list< value_type > ilist )

inline

◆ insert_or_assign() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class M >

std::pair<iterator, bool> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class M >

std::pair<iterator, bool> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert_or_assign	(	key_type &&	k,
		M &&	obj
	)

inline

◆ insert_or_assign() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class M >

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert_or_assign	(	const_iterator	hint,
		const key_type &	k,
		M &&	obj
	)

inline

◆ insert_or_assign() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class M >

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::insert_or_assign	(	const_iterator	hint,
		key_type &&	k,
		M &&	obj
	)

inline

◆ key_eq()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

key_equal tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

float tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

float tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::max_size ( ) const

inlinenoexcept

◆ 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

sparse_map& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

T& tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::rehash ( size_type count )

inline

◆ reserve()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::reserve ( size_type 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class Serializer >

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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:

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

The implementation leaves binary compatibilty (endianness, IEEE 754 for floats, ...) of the types it serializes in the hands of the Serializer function object if compatibilty 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

size_type tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

void tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::swap ( sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity > & 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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class... Args>

std::pair<iterator, bool> tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class... Args>

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

inline

◆ try_emplace() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class... Args>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::try_emplace	(	const_iterator	hint,
		const key_type &	k,
		Args &&...	args
	)

inline

◆ try_emplace() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

template<class... Args>

iterator tsl::sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity >::try_emplace	(	const_iterator	hint,
		key_type &&	k,
		Args &&...	args
	)

inline

Friends And Related Function Documentation

◆ operator!=

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

bool operator!=	(	const sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity > &	lhs,
		const sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity > &	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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

bool operator==	(	const sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity > &	lhs,
		const sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity > &	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>>, class GrowthPolicy = tsl::sh::power_of_two_growth_policy<2>, tsl::sh::exception_safety ExceptionSafety = tsl::sh::exception_safety::basic, tsl::sh::sparsity Sparsity = tsl::sh::sparsity::medium>

void swap	(	sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity > &	lhs,
		sparse_map< Key, T, Hash, KeyEqual, Allocator, GrowthPolicy, ExceptionSafety, Sparsity > &	rhs
	)

friend

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

include/tsl/sparse_map.h

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ difference_type

◆ hasher

◆ iterator

◆ key_equal

◆ key_type

◆ mapped_type

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ sparse_map() [1/11]

◆ sparse_map() [2/11]

◆ sparse_map() [3/11]

◆ sparse_map() [4/11]

◆ sparse_map() [5/11]

◆ sparse_map() [6/11]

◆ sparse_map() [7/11]

◆ sparse_map() [8/11]

◆ sparse_map() [9/11]

◆ sparse_map() [10/11]

◆ sparse_map() [11/11]

Member Function Documentation

◆ at() [1/8]

◆ at() [2/8]

◆ at() [3/8]

◆ at() [4/8]

◆ at() [5/8]

◆ at() [6/8]

◆ at() [7/8]

◆ at() [8/8]

◆ begin() [1/2]

◆ begin() [2/2]

◆ bucket_count()

◆ cbegin()

◆ cend()

◆ clear()

◆ count() [1/4]

◆ count() [2/4]

◆ count() [3/4]

◆ count() [4/4]

◆ deserialize()

◆ emplace()

◆ emplace_hint()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range() [1/8]

◆ equal_range() [2/8]

◆ equal_range() [3/8]

◆ equal_range() [4/8]

◆ equal_range() [5/8]

◆ equal_range() [6/8]

◆ equal_range() [7/8]

◆ equal_range() [8/8]

◆ erase() [1/7]

◆ erase() [2/7]

◆ erase() [3/7]

◆ erase() [4/7]

◆ erase() [5/7]

◆ erase() [6/7]

◆ erase() [7/7]

◆ find() [1/8]

◆ find() [2/8]

◆ find() [3/8]

◆ find() [4/8]

◆ find() [5/8]

◆ find() [6/8]

◆ find() [7/8]

◆ find() [8/8]