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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>
class tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >

Implementation of a hash map using the hopscotch hashing algorithm.

The Key and the value T must be either nothrow move-constructible, copy-constuctible or both.

The size of the neighborhood (NeighborhoodSize) must be > 0 and <= 62 if StoreHash is false. When StoreHash is true, 32-bits of the hash will be stored alongside the neighborhood limiting the NeighborhoodSize to <= 30. There is no memory usage difference between 'NeighborhoodSize 62; StoreHash false' and 'NeighborhoodSize 30; StoreHash true'.

Storing the hash may improve performance on insert during the rehash process if the hash takes time to compute. It may also improve read performance if the KeyEqual function takes time (or incurs a cache-miss). If used with simple Hash and KeyEqual it may slow things down.

StoreHash can only be set if the GrowthPolicy is set to tsl::power_of_two_growth_policy.

GrowthPolicy defines how the map grows and consequently how a hash value is mapped to a bucket. By default the map uses tsl::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. You may define your own growth policy, check tsl::power_of_two_growth_policy for the interface.

If the destructors of Key or T throw an exception, 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 if a displacement is needed to resolve a collision (which mean that most of the time, insert will invalidate the iterators). Or if there is a rehash.
erase: iterator on the erased element is the only one which become invalid.

Definition at line 79 of file hopscotch_map.h.

#include <hopscotch_map.h>

Data Structures
class	KeySelect

class	ValueSelect

Public Types
using	key_type = typename ht::key_type

using	mapped_type = T

using	value_type = typename ht::value_type

using	size_type = typename ht::size_type

using	difference_type = typename ht::difference_type

using	hasher = typename ht::hasher

using	key_equal = typename ht::key_equal

using	allocator_type = typename ht::allocator_type

using	reference = typename ht::reference

using	const_reference = typename ht::const_reference

using	pointer = typename ht::pointer

using	const_pointer = typename ht::const_pointer

using	iterator = typename ht::iterator

using	const_iterator = typename ht::const_iterator

Public Member Functions
	hopscotch_map (size_type bucket_count, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())

	hopscotch_map (size_type bucket_count, const Allocator &alloc)

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

	hopscotch_map (const Allocator &alloc)

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

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

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

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

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

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

size_type	overflow_size () const noexcept

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

using	overflow_container_type = std::list< std::pair< Key, T >, Allocator >

using	ht = detail_hopscotch_hash::hopscotch_hash< std::pair< Key, T >, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy, overflow_container_type >

Private Attributes
ht	m_ht

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

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

void	swap (hopscotch_map &lhs, hopscotch_map &rhs)

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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 126 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 132 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 130 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 128 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 123 of file hopscotch_map.h.

◆ has_is_transparent

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<typename U >

using tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>

private

Definition at line 82 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 124 of file hopscotch_map.h.

◆ ht

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

using tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::ht = detail_hopscotch_hash::hopscotch_hash<std::pair<Key, T>, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy, overflow_container_type>

private

Definition at line 112 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 131 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 125 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 119 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 120 of file hopscotch_map.h.

◆ overflow_container_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

using tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::overflow_container_type = std::list<std::pair<Key, T>, Allocator>

private

Definition at line 111 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 129 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 127 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 122 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

Definition at line 121 of file hopscotch_map.h.

Constructor & Destructor Documentation

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hopscotch_map ( )

inline

Definition at line 139 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hopscotch_map	(	size_type	bucket_count,
		const Hash &	hash = `Hash()`,
		const KeyEqual &	equal = `KeyEqual()`,
		const Allocator &	alloc = `Allocator()`
	)

inlineexplicit

Definition at line 142 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hopscotch_map	(	size_type	bucket_count,
		const Allocator &	alloc
	)

inline

Definition at line 150 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 155 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hopscotch_map ( const Allocator & alloc )

inlineexplicit

Definition at line 161 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class InputIt >

tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hopscotch_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 165 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class InputIt >

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

inline

Definition at line 175 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class InputIt >

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

inline

Definition at line 182 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hopscotch_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 189 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 198 of file hopscotch_map.h.

◆ hopscotch_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 205 of file hopscotch_map.h.

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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

T & tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 428 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

const T & tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 444 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 437 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 450 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 406 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 415 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 412 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 420 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inlinenoexcept

Definition at line 230 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inlinenoexcept

Definition at line 229 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

size_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bucket_count ( ) const

inline

Definition at line 601 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

const_iterator tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::cbegin ( ) const

inlinenoexcept

Definition at line 231 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

const_iterator tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::cend ( ) const

inlinenoexcept

Definition at line 235 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

void tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::clear ( )

inlinenoexcept

Definition at line 248 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

size_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 476 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 485 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 461 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 467 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class... Args>

std::pair< iterator, bool > tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 323 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class... Args>

iterator tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 337 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

bool tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::empty ( ) const

inlinenoexcept

Definition at line 241 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inlinenoexcept

Definition at line 234 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inlinenoexcept

Definition at line 233 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

std::pair< iterator, iterator > tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 567 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

std::pair< const_iterator, const_iterator > tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 585 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 577 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 591 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 543 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 553 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 549 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 558 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

size_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 385 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 394 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 370 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 376 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 369 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 368 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 367 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

iterator tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 512 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

const_iterator tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, 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 527 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 521 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

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

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

Definition at line 536 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 490 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 498 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 496 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

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

Definition at line 503 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

allocator_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::get_allocator ( ) const

inline

Definition at line 223 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

hasher tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hash_function ( ) const

inline

Definition at line 619 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 253 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 267 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

Definition at line 272 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 276 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class InputIt >

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

inline

Definition at line 282 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

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

inline

Definition at line 258 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 286 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 262 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class M >

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

inline

Definition at line 294 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class M >

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

inline

Definition at line 304 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class M >

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

inline

Definition at line 309 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class M >

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

inline

Definition at line 299 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

key_equal tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::key_eq ( ) const

inline

Definition at line 620 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

float tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::load_factor ( ) const

inline

Definition at line 608 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

size_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_bucket_count ( ) const

inline

Definition at line 602 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

float tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_load_factor ( ) const

inline

Definition at line 609 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

void tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_load_factor ( float ml )

inline

Definition at line 610 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

size_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_size ( ) const

inlinenoexcept

Definition at line 243 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

iterator tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::mutable_iterator ( const_iterator pos )

inline

Convert a const_iterator to an iterator.

Definition at line 629 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 214 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

inline

Definition at line 455 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

T & tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::operator[] ( Key && key )

inline

Definition at line 456 of file hopscotch_map.h.

◆ overflow_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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

size_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::overflow_size ( ) const

inlinenoexcept

Definition at line 633 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

void tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::rehash ( size_type count )

inline

Definition at line 612 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

void tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::reserve ( size_type count )

inline

Definition at line 613 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

size_type tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::size ( ) const

inlinenoexcept

Definition at line 242 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

void tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::swap ( hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & other )

inline

Definition at line 401 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class... Args>

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

inline

Definition at line 345 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class... Args>

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

inline

Definition at line 355 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class... Args>

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

inline

Definition at line 360 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

template<class... Args>

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

inline

Definition at line 350 of file hopscotch_map.h.

Friends And Related Symbol Documentation

◆ operator!=

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

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

friend

Definition at line 650 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

bool operator==	(	const hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > &	lhs,
		const hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > &	rhs
	)

friend

Definition at line 635 of file hopscotch_map.h.

◆ 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>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

void swap	(	hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > &	lhs,
		hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > &	rhs
	)

friend

Definition at line 654 of file hopscotch_map.h.

Field Documentation

◆ m_ht

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::power_of_two_growth_policy>

ht tsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::m_ht

private

Definition at line 661 of file hopscotch_map.h.

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

openfpm_data/src/hash_map/hopscotch_map.h

Detailed Description

Data Structures

Public Types

Public Member Functions

Private Types

Private Attributes

Friends

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ difference_type

◆ has_is_transparent

◆ hasher

◆ ht

◆ iterator

◆ key_equal

◆ key_type

◆ mapped_type

◆ overflow_container_type

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ hopscotch_map() [1/11]

◆ hopscotch_map() [2/11]

◆ hopscotch_map() [3/11]

◆ hopscotch_map() [4/11]

◆ hopscotch_map() [5/11]

◆ hopscotch_map() [6/11]

◆ hopscotch_map() [7/11]

◆ hopscotch_map() [8/11]

◆ hopscotch_map() [9/11]

◆ hopscotch_map() [10/11]

◆ hopscotch_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]

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