#include <robin_set.h>

Classes
class	KeySelect

Public Types
using	allocator_type = typename ht::allocator_type

using	const_iterator = typename ht::const_iterator

using	const_pointer = typename ht::const_pointer

using	const_reference = typename ht::const_reference

using	difference_type = typename ht::difference_type

using	hasher = typename ht::hasher

using	iterator = typename ht::iterator

using	key_equal = typename ht::key_equal

using	key_type = typename ht::key_type

using	pointer = typename ht::pointer

using	reference = typename ht::reference

using	size_type = typename ht::size_type

using	value_type = typename ht::value_type

Public Member Functions
const_iterator	begin () const noexcept

iterator	begin () noexcept

size_type	bucket_count () const

const_iterator	cbegin () const noexcept

const_iterator	cend () const noexcept

void	clear () noexcept

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

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

bool	contains (const Key &key) const

bool	contains (const Key &key, std::size_t precalculated_hash) const

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

size_type	count (const Key &key) const

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

template<class... Args>
std::pair< iterator, bool >	emplace (Args &&... args)

template<class... Args>
iterator	emplace_hint (const_iterator hint, Args &&... args)

bool	empty () const noexcept

const_iterator	end () const noexcept

iterator	end () noexcept

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< 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< 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, std::size_t precalculated_hash) const

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

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

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

size_type	erase (const key_type &key)

size_type	erase (const key_type &key, std::size_t precalculated_hash)

iterator	erase (const_iterator first, const_iterator last)

iterator	erase (const_iterator pos)

iterator	erase (iterator pos)

void	erase_fast (iterator pos)

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>
const_iterator	find (const K &key) const

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, std::size_t precalculated_hash) const

iterator	find (const Key &key)

const_iterator	find (const Key &key) const

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

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

allocator_type	get_allocator () const

hasher	hash_function () const

std::pair< iterator, bool >	insert (const value_type &value)

iterator	insert (const_iterator hint, const value_type &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)

std::pair< iterator, bool >	insert (value_type &&value)

key_equal	key_eq () const

float	load_factor () const

size_type	max_bucket_count () const

float	max_load_factor () const

void	max_load_factor (float ml)

size_type	max_size () const noexcept

float	min_load_factor () const

void	min_load_factor (float ml)

iterator	mutable_iterator (const_iterator pos)

robin_set &	operator= (std::initializer_list< value_type > ilist)

void	rehash (size_type count_)

void	reserve (size_type count_)

	robin_set ()

	robin_set (const Allocator &alloc)

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

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

template<class InputIt >
	robin_set (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())

	robin_set (size_type bucket_count, const Allocator &alloc)

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

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

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

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

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

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

size_type	size () const noexcept

void	swap (robin_set &other)

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

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

using	ht = detail_robin_hash::robin_hash< Key, KeySelect, void, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >

Private Attributes
ht	m_ht

Friends
bool	operator!= (const robin_set &lhs, const robin_set &rhs)

bool	operator== (const robin_set &lhs, const robin_set &rhs)

void	swap (robin_set &lhs, robin_set &rhs)

Detailed Description

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

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

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

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

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

Key must be swappable.

Key must be copy and/or move constructible.

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

Iterators invalidation:

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

Definition at line 90 of file robin_set.h.

Member Typedef Documentation

◆ allocator_type

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

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

Definition at line 114 of file robin_set.h.

◆ const_iterator

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

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

Definition at line 120 of file robin_set.h.

◆ const_pointer

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

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

Definition at line 118 of file robin_set.h.

◆ const_reference

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

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

Definition at line 116 of file robin_set.h.

◆ difference_type

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

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

Definition at line 111 of file robin_set.h.

◆ has_is_transparent

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

template<typename U >

using tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::has_is_transparent = tsl::detail_robin_hash::has_is_transparent<U>

private

Definition at line 93 of file robin_set.h.

◆ hasher

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

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

Definition at line 112 of file robin_set.h.

◆ ht

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

using tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::ht = detail_robin_hash::robin_hash<Key, KeySelect, void, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy>

private

Definition at line 105 of file robin_set.h.

◆ iterator

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

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

Definition at line 119 of file robin_set.h.

◆ key_equal

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

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

Definition at line 113 of file robin_set.h.

◆ key_type

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

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

Definition at line 108 of file robin_set.h.

◆ pointer

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

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

Definition at line 117 of file robin_set.h.

◆ reference

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

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

Definition at line 115 of file robin_set.h.

◆ size_type

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

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

Definition at line 110 of file robin_set.h.

◆ value_type

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

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

Definition at line 109 of file robin_set.h.

Constructor & Destructor Documentation

◆ robin_set() [1/11]

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

tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_set ( )

inline

Definition at line 125 of file robin_set.h.

◆ robin_set() [2/11]

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

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

inlineexplicit

Definition at line 127 of file robin_set.h.

◆ robin_set() [3/11]

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

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

inline

Definition at line 132 of file robin_set.h.

◆ robin_set() [4/11]

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

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

inline

Definition at line 135 of file robin_set.h.

◆ robin_set() [5/11]

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

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

inlineexplicit

Definition at line 138 of file robin_set.h.

◆ robin_set() [6/11]

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

template<class InputIt >

tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_set	(	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 142 of file robin_set.h.

◆ robin_set() [7/11]

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

template<class InputIt >

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

inline

Definition at line 151 of file robin_set.h.

◆ robin_set() [8/11]

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

template<class InputIt >

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

inline

Definition at line 156 of file robin_set.h.

◆ robin_set() [9/11]

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

tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_set	(	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 160 of file robin_set.h.

◆ robin_set() [10/11]

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

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

inline

Definition at line 166 of file robin_set.h.

◆ robin_set() [11/11]

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

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

inline

Definition at line 171 of file robin_set.h.

Member Function Documentation

◆ begin() [1/2]

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

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

inlinenoexcept

Definition at line 191 of file robin_set.h.

◆ begin() [2/2]

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

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

inlinenoexcept

Definition at line 190 of file robin_set.h.

◆ bucket_count()

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

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

inline

Definition at line 535 of file robin_set.h.

◆ cbegin()

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

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

inlinenoexcept

Definition at line 192 of file robin_set.h.

◆ cend()

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

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

inlinenoexcept

Definition at line 196 of file robin_set.h.

◆ clear()

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

void tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::clear ( )

inlinenoexcept

Definition at line 208 of file robin_set.h.

◆ contains() [1/4]

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

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

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

inline

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

Definition at line 440 of file robin_set.h.

◆ contains() [2/4]

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

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

bool tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::contains	(	const K &	key,
		std::size_t	precalculated_hash
	)		const

inline

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

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

Definition at line 454 of file robin_set.h.

◆ contains() [3/4]

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

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

inline

Definition at line 421 of file robin_set.h.

◆ contains() [4/4]

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

bool tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::contains	(	const Key &	key,
		std::size_t	precalculated_hash
	)		const

inline

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

Definition at line 428 of file robin_set.h.

◆ count() [1/4]

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

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

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

inline

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

Definition at line 333 of file robin_set.h.

◆ count() [2/4]

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

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

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

inline

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

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

Definition at line 347 of file robin_set.h.

◆ count() [3/4]

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

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

inline

Definition at line 314 of file robin_set.h.

◆ count() [4/4]

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

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

inline

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

Definition at line 321 of file robin_set.h.

◆ deserialize()

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

template<class Deserializer >

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

inlinestatic

Deserialize a previously serialized set through the deserializer parameter.

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

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

If the deserialized hash set type is hash compatible with the serialized set, 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 set and the StoreHash must have the same value. The std::size_t must also be of the same size as the one on the platform used to serialize the set. If these criteria are not met, the behaviour is undefined with hash_compatible sets to true.

The behaviour is undefined if the type Key of the robin_set is not the same as the type used during serialization.

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

Definition at line 638 of file robin_set.h.

◆ emplace()

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

template<class... Args>

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

inline

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

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

Definition at line 243 of file robin_set.h.

◆ emplace_hint()

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

template<class... Args>

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

inline

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

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

Definition at line 255 of file robin_set.h.

◆ empty()

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

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

inlinenoexcept

Definition at line 201 of file robin_set.h.

◆ end() [1/2]

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

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

inlinenoexcept

Definition at line 195 of file robin_set.h.

◆ end() [2/2]

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

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

inlinenoexcept

Definition at line 194 of file robin_set.h.

◆ equal_range() [1/8]

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

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

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

inline

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

Definition at line 492 of file robin_set.h.

◆ equal_range() [2/8]

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

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

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

inline

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

Definition at line 517 of file robin_set.h.

◆ equal_range() [3/8]

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

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

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

inline

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

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

Definition at line 506 of file robin_set.h.

◆ equal_range() [4/8]

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

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

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

inline

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

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

Definition at line 527 of file robin_set.h.

◆ equal_range() [5/8]

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

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

inline

Definition at line 458 of file robin_set.h.

◆ equal_range() [6/8]

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

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

inline

Definition at line 472 of file robin_set.h.

◆ equal_range() [7/8]

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

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

inline

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

Definition at line 467 of file robin_set.h.

◆ equal_range() [8/8]

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

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

inline

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

Definition at line 479 of file robin_set.h.

◆ erase() [1/7]

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

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

size_type tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase ( const K & key )

inline

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

Definition at line 291 of file robin_set.h.

◆ erase() [2/7]

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

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

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

inline

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

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

Definition at line 305 of file robin_set.h.

◆ erase() [3/7]

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

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

inline

Definition at line 264 of file robin_set.h.

◆ erase() [4/7]

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

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

inline

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

Definition at line 279 of file robin_set.h.

◆ erase() [5/7]

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

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

inline

Definition at line 261 of file robin_set.h.

◆ erase() [6/7]

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

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

inline

Definition at line 260 of file robin_set.h.

◆ erase() [7/7]

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

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

inline

Definition at line 259 of file robin_set.h.

◆ erase_fast()

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

void tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::erase_fast ( iterator pos )

inline

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

Definition at line 272 of file robin_set.h.

◆ find() [1/8]

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

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

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

inline

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

Definition at line 379 of file robin_set.h.

◆ find() [2/8]

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

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

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

inline

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

Definition at line 403 of file robin_set.h.

◆ find() [3/8]

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

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

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

inline

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

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

Definition at line 393 of file robin_set.h.

◆ find() [4/8]

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

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

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

inline

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

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

Definition at line 417 of file robin_set.h.

◆ find() [5/8]

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

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

inline

Definition at line 351 of file robin_set.h.

◆ find() [6/8]

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

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

inline

Definition at line 362 of file robin_set.h.

◆ find() [7/8]

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

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

inline

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

Definition at line 358 of file robin_set.h.

◆ find() [8/8]

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

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

inline

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

Definition at line 367 of file robin_set.h.

◆ get_allocator()

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

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

inline

Definition at line 185 of file robin_set.h.

◆ hash_function()

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

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

inline

Definition at line 564 of file robin_set.h.

◆ insert() [1/6]

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

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

inline

Definition at line 210 of file robin_set.h.

◆ insert() [2/6]

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

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

inline

Definition at line 218 of file robin_set.h.

◆ insert() [3/6]

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

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

inline

Definition at line 222 of file robin_set.h.

◆ insert() [4/6]

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

template<class InputIt >

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

inline

Definition at line 227 of file robin_set.h.

◆ insert() [5/6]

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

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

inline

Definition at line 231 of file robin_set.h.

◆ insert() [6/6]

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

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

inline

Definition at line 214 of file robin_set.h.

◆ key_eq()

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

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

inline

Definition at line 565 of file robin_set.h.

◆ load_factor()

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

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

inline

Definition at line 541 of file robin_set.h.

◆ max_bucket_count()

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

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

inline

Definition at line 536 of file robin_set.h.

◆ max_load_factor() [1/2]

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

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

inline

Definition at line 544 of file robin_set.h.

◆ max_load_factor() [2/2]

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

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

inline

Definition at line 556 of file robin_set.h.

◆ max_size()

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

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

inlinenoexcept

Definition at line 203 of file robin_set.h.

◆ min_load_factor() [1/2]

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

float tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::min_load_factor ( ) const

inline

Definition at line 543 of file robin_set.h.

◆ min_load_factor() [2/2]

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

void tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::min_load_factor ( float ml )

inline

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

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

Definition at line 555 of file robin_set.h.

◆ mutable_iterator()

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

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

inline

Convert a const_iterator to an iterator.

Definition at line 574 of file robin_set.h.

◆ operator=()

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

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

inline

Definition at line 176 of file robin_set.h.

◆ rehash()

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

void tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::rehash ( size_type count_ )

inline

Definition at line 558 of file robin_set.h.

◆ reserve()

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

void tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::reserve ( size_type count_ )

inline

Definition at line 559 of file robin_set.h.

◆ serialize()

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

template<class Serializer >

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

inline

Serialize the set through the serializer parameter.

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

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

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

Definition at line 607 of file robin_set.h.

◆ size()

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

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

inlinenoexcept

Definition at line 202 of file robin_set.h.

◆ swap()

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

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

inline

Definition at line 309 of file robin_set.h.

Friends And Related Function Documentation

◆ operator!=

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

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

friend

Definition at line 646 of file robin_set.h.

◆ operator==

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

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

friend

Definition at line 578 of file robin_set.h.

◆ swap

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

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

friend

Definition at line 650 of file robin_set.h.

Member Data Documentation

◆ m_ht

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

ht tsl::robin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::m_ht

private

Definition at line 653 of file robin_set.h.

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

robin_set.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Attributes

Friends

Detailed Description

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

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ difference_type

◆ has_is_transparent

◆ hasher

◆ ht

◆ iterator

◆ key_equal

◆ key_type

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ robin_set() [1/11]

◆ robin_set() [2/11]

◆ robin_set() [3/11]

◆ robin_set() [4/11]

◆ robin_set() [5/11]

◆ robin_set() [6/11]

◆ robin_set() [7/11]

◆ robin_set() [8/11]

◆ robin_set() [9/11]

◆ robin_set() [10/11]

◆ robin_set() [11/11]

Member Function Documentation

◆ begin() [1/2]

◆ begin() [2/2]

◆ bucket_count()

◆ cbegin()

◆ cend()

◆ clear()

◆ contains() [1/4]

◆ contains() [2/4]

◆ contains() [3/4]

◆ contains() [4/4]

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

◆ erase_fast()

◆ find() [1/8]

◆ find() [2/8]

◆ find() [3/8]

◆ find() [4/8]

◆ find() [5/8]

◆ find() [6/8]

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