tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > Class Template Reference

More...

#include <bhopscotch_set.h>

Public Types
using	key_type = typename ht::key_type
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	key_compare = Compare
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
	bhopscotch_set ()
	bhopscotch_set (size_type bucket_count, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator(), const Compare &comp=Compare())
	bhopscotch_set (size_type bucket_count, const Allocator &alloc)
	bhopscotch_set (size_type bucket_count, const Hash &hash, const Allocator &alloc)
	bhopscotch_set (const Allocator &alloc)
template<class InputIt >
	bhopscotch_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())
template<class InputIt >
	bhopscotch_set (InputIt first, InputIt last, size_type bucket_count, const Allocator &alloc)
template<class InputIt >
	bhopscotch_set (InputIt first, InputIt last, size_type bucket_count, const Hash &hash, const Allocator &alloc)
	bhopscotch_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())
	bhopscotch_set (std::initializer_list< value_type > init, size_type bucket_count, const Allocator &alloc)
	bhopscotch_set (std::initializer_list< value_type > init, size_type bucket_count, const Hash &hash, const Allocator &alloc)
bhopscotch_set &	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)
std::pair< iterator, bool >	insert (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)
template<class... Args>
std::pair< iterator, bool >	emplace (Args &&... args)
template<class... Args>
iterator	emplace_hint (const_iterator hint, 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, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
size_type	erase (const K &key)
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
size_type	erase (const K &key, std::size_t precalculated_hash)
void	swap (bhopscotch_set &other)
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, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
size_type	count (const K &key) const
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::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, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
iterator	find (const K &key)
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
iterator	find (const K &key, std::size_t precalculated_hash)
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
const_iterator	find (const K &key) const
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::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, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
std::pair< iterator, iterator >	equal_range (const K &key)
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
std::pair< iterator, iterator >	equal_range (const K &key, std::size_t precalculated_hash)
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
std::pair< const_iterator, const_iterator >	equal_range (const K &key) const
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::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
key_compare	key_comp () const
iterator	mutable_iterator (const_iterator pos)
size_type	overflow_size () const noexcept

Friends
bool	operator== (const bhopscotch_set &lhs, const bhopscotch_set &rhs)
bool	operator!= (const bhopscotch_set &lhs, const bhopscotch_set &rhs)
void	swap (bhopscotch_set &lhs, bhopscotch_set &rhs)

Detailed Description

template<class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<Key>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
class tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >

Similar to tsl::hopscotch_set but instead of using a list for overflowing elements it uses a binary search tree. It thus needs an additional template parameter Compare. Compare should be arithmetically coherent with KeyEqual.

The binary search tree allows the set to have a worst-case scenario of O(log n) for search and delete, even if the hash function maps all the elements to the same bucket. For insert, the amortized worst case is O(log n), but the worst case is O(n) in case of rehash.

This makes the set resistant to DoS attacks (but doesn't preclude you to have a good hash function, as an element in the bucket array is faster to retrieve than in the tree).

Implementation of a hash set using the hopscotch hashing algorithm.

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

If the destructor of Key throws 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.

Member Typedef Documentation

allocator_type

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

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

const_iterator

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

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

const_pointer

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

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

const_reference

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

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

difference_type

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

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

hasher

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

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

iterator

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

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

key_compare

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

using tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::key_compare = Compare

key_equal

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

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

key_type

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

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

pointer

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

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

reference

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

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

size_type

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

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

value_type

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

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

Constructor & Destructor Documentation

bhopscotch_set() [1/11]

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

tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_set ( )

inline

bhopscotch_set() [2/11]

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

tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_set ( size_type  bucket_count, const Hash &  hash = Hash(), const KeyEqual &  equal = KeyEqual(), const Allocator &  alloc = Allocator(), const Compare &  comp = Compare()  )

inlineexplicit

bhopscotch_set() [3/11]

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

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

inline

bhopscotch_set() [4/11]

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

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

inline

bhopscotch_set() [5/11]

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

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

inlineexplicit

bhopscotch_set() [6/11]

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

template<class InputIt >

tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_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

bhopscotch_set() [7/11]

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

template<class InputIt >

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

inline

bhopscotch_set() [8/11]

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

template<class InputIt >

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

inline

bhopscotch_set() [9/11]

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

tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_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

bhopscotch_set() [10/11]

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

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

inline

bhopscotch_set() [11/11]

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

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

inline

Member Function Documentation

begin() [1/2]

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

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

inlinenoexcept

begin() [2/2]

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

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

inlinenoexcept

bucket_count()

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

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

inline

cbegin()

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

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

inlinenoexcept

cend()

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

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

inlinenoexcept

clear()

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

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

inlinenoexcept

count() [1/4]

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

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

inline

count() [2/4]

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

size_type tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

count() [3/4]

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

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

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

inline

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

count() [4/4]

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

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

size_type tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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 and Compare::is_transparent exist. 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.

emplace()

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

template<class... Args>

std::pair<iterator, bool> tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

emplace_hint()

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

template<class... Args>

iterator tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

empty()

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

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

inlinenoexcept

end() [1/2]

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

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

inlinenoexcept

end() [2/2]

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

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

inlinenoexcept

equal_range() [1/8]

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

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

inline

equal_range() [2/8]

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

std::pair<iterator, iterator> tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

equal_range() [3/8]

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

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

inline

equal_range() [4/8]

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

std::pair<const_iterator, const_iterator> tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

equal_range() [5/8]

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

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

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

inline

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

equal_range() [6/8]

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

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

std::pair<iterator, iterator> tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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 and Compare::is_transparent exist. 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.

equal_range() [7/8]

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

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

std::pair<const_iterator, const_iterator> tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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 and Compare::is_transparent exist. If so, K must be hashable and comparable to Key.

equal_range() [8/8]

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

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

std::pair<const_iterator, const_iterator> tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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 and Compare::is_transparent exist. 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.

erase() [1/7]

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

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

inline

erase() [2/7]

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

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

inline

erase() [3/7]

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

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

inline

erase() [4/7]

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

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

inline

erase() [5/7]

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

size_type tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

erase() [6/7]

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

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

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

inline

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

erase() [7/7]

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

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

size_type tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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 and Compare::is_transparent exist. 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.

find() [1/8]

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

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

inline

find() [2/8]

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

iterator tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

find() [3/8]

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

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

inline

find() [4/8]

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

const_iterator tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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.

find() [5/8]

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

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

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

inline

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

find() [6/8]

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

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

iterator tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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 and Compare::is_transparent exist. 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.

find() [7/8]

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

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

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

inline

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

find() [8/8]

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

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

const_iterator tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, 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 and Compare::is_transparent exist. 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.

get_allocator()

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

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

inline

hash_function()

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

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

inline

insert() [1/6]

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

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

inline

insert() [2/6]

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

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

inline

insert() [3/6]

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

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

inline

insert() [4/6]

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

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

inline

insert() [5/6]

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

template<class InputIt >

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

inline

insert() [6/6]

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

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

inline

key_comp()

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

key_compare tsl::bhopscotch_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::key_comp ( ) const

inline

key_eq()

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

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

inline

load_factor()

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

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

inline

max_bucket_count()

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

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

inline

max_load_factor() [1/2]

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

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

inline

max_load_factor() [2/2]

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

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

inline

max_size()

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

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

inlinenoexcept

mutable_iterator()

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

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

inline

Convert a const_iterator to an iterator.

operator=()

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

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

inline

overflow_size()

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

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

inlinenoexcept

rehash()

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

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

inline

reserve()

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

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

inline

size()

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

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

inlinenoexcept

swap()

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

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

inline

Friends And Related Function Documentation

operator!=

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

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

friend

operator==

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

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

friend

swap

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

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

friend

---

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

• include/tsl/bhopscotch_set.h