IOSS 2.0
Loading...
Searching...
No Matches
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > Class Template Reference

#include <bhopscotch_map.h>

Collaboration diagram for tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >:
[legend]

Classes

class  KeySelect
 
class  ValueSelect
 

Public Types

using key_type = typename ht::key_type
 
using mapped_type = T
 
using value_type = typename ht::value_type
 
using size_type = typename ht::size_type
 
using difference_type = typename ht::difference_type
 
using hasher = typename ht::hasher
 
using key_equal = typename ht::key_equal
 
using 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_map ()
 
 bhopscotch_map (size_type bucket_count, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator(), const Compare &comp=Compare())
 
 bhopscotch_map (size_type bucket_count, const Allocator &alloc)
 
 bhopscotch_map (size_type bucket_count, const Hash &hash, const Allocator &alloc)
 
 bhopscotch_map (const Allocator &alloc)
 
template<class InputIt >
 bhopscotch_map (InputIt first, InputIt last, size_type bucket_count=ht::DEFAULT_INIT_BUCKETS_SIZE, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
 
template<class InputIt >
 bhopscotch_map (InputIt first, InputIt last, size_type bucket_count, const Allocator &alloc)
 
template<class InputIt >
 bhopscotch_map (InputIt first, InputIt last, size_type bucket_count, const Hash &hash, const Allocator &alloc)
 
 bhopscotch_map (std::initializer_list< value_type > init, size_type bucket_count=ht::DEFAULT_INIT_BUCKETS_SIZE, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
 
 bhopscotch_map (std::initializer_list< value_type > init, size_type bucket_count, const Allocator &alloc)
 
 bhopscotch_map (std::initializer_list< value_type > init, size_type bucket_count, const Hash &hash, const Allocator &alloc)
 
bhopscotch_mapoperator= (std::initializer_list< value_type > ilist)
 
allocator_type get_allocator () const
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
const_iterator cbegin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
const_iterator cend () const noexcept
 
bool empty () const noexcept
 
size_type size () const noexcept
 
size_type max_size () const noexcept
 
void clear () noexcept
 
std::pair< iterator, bool > insert (const value_type &value)
 
template<class P , typename std::enable_if< std::is_constructible< value_type, P && >::value >::type * = nullptr>
std::pair< iterator, bool > insert (P &&value)
 
std::pair< iterator, bool > insert (value_type &&value)
 
iterator insert (const_iterator hint, const value_type &value)
 
template<class P , typename std::enable_if< std::is_constructible< value_type, P && >::value >::type * = nullptr>
iterator insert (const_iterator hint, P &&value)
 
iterator insert (const_iterator hint, value_type &&value)
 
template<class InputIt >
void insert (InputIt first, InputIt last)
 
void insert (std::initializer_list< value_type > ilist)
 
template<class M >
std::pair< iterator, bool > insert_or_assign (const key_type &k, M &&obj)
 
template<class M >
std::pair< iterator, bool > insert_or_assign (key_type &&k, M &&obj)
 
template<class M >
iterator insert_or_assign (const_iterator hint, const key_type &k, M &&obj)
 
template<class M >
iterator insert_or_assign (const_iterator hint, key_type &&k, M &&obj)
 
template<class... Args>
std::pair< iterator, bool > emplace (Args &&...args)
 
template<class... Args>
iterator emplace_hint (const_iterator hint, Args &&...args)
 
template<class... Args>
std::pair< iterator, bool > try_emplace (const key_type &k, Args &&...args)
 
template<class... Args>
std::pair< iterator, bool > try_emplace (key_type &&k, Args &&...args)
 
template<class... Args>
iterator try_emplace (const_iterator hint, const key_type &k, Args &&...args)
 
template<class... Args>
iterator try_emplace (const_iterator hint, key_type &&k, Args &&...args)
 
iterator erase (iterator pos)
 
iterator erase (const_iterator pos)
 
iterator erase (const_iterator first, const_iterator last)
 
size_type erase (const key_type &key)
 
size_type erase (const key_type &key, std::size_t precalculated_hash)
 
template<class K , class KE = KeyEqual, 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_map &other)
 
T & at (const Key &key)
 
T & at (const Key &key, std::size_t precalculated_hash)
 
const T & at (const Key &key) const
 
const T & at (const Key &key, std::size_t precalculated_hash) const
 
template<class K , class KE = KeyEqual, class CP = Compare, typename std::enable_if< has_is_transparent< KE >::value &&has_is_transparent< CP >::value >::type * = nullptr>
T & at (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>
T & at (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 T & at (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 T & at (const K &key, std::size_t precalculated_hash) const
 
T & operator[] (const Key &key)
 
T & operator[] (Key &&key)
 
size_type count (const Key &key) const
 
size_type count (const Key &key, std::size_t precalculated_hash) const
 
template<class K , class KE = KeyEqual, 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
 
bool contains (const Key &key) const
 
bool contains (const Key &key, std::size_t precalculated_hash) const
 
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
bool contains (const K &key) const
 
template<class K , class KE = KeyEqual, typename std::enable_if< has_is_transparent< KE >::value >::type * = nullptr>
bool contains (const K &key, std::size_t precalculated_hash) const
 
std::pair< iterator, iteratorequal_range (const Key &key)
 
std::pair< iterator, iteratorequal_range (const Key &key, std::size_t precalculated_hash)
 
std::pair< const_iterator, const_iteratorequal_range (const Key &key) const
 
std::pair< const_iterator, const_iteratorequal_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, iteratorequal_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, iteratorequal_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_iteratorequal_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_iteratorequal_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
 

Private Types

template<typename U >
using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>
 
using overflow_container_type = std::map<Key, T, Compare, Allocator>
 
using ht
 

Private Attributes

ht m_ht
 

Friends

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

Detailed Description

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

Similar to tsl::hopscotch_map 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 map 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 map 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).

Member Typedef Documentation

◆ allocator_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::allocator_type = typename ht::allocator_type

◆ const_iterator

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::const_iterator = typename ht::const_iterator

◆ const_pointer

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::const_pointer = typename ht::const_pointer

◆ const_reference

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::const_reference = typename ht::const_reference

◆ difference_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::difference_type = typename ht::difference_type

◆ has_is_transparent

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<typename U >
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>
private

◆ hasher

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hasher = typename ht::hasher

◆ ht

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::ht
private
Initial value:
detail_hopscotch_hash::hopscotch_hash<std::pair<const Key, T>, KeySelect, ValueSelect, Hash,
KeyEqual, Allocator, NeighborhoodSize, StoreHash,
GrowthPolicy, overflow_container_type>
std::map< Key, T, Compare, Allocator > overflow_container_type
Definition bhopscotch_map.h:95

◆ iterator

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::iterator = typename ht::iterator

◆ key_compare

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

◆ key_equal

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::key_equal = typename ht::key_equal

◆ key_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::key_type = typename ht::key_type

◆ mapped_type

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

◆ overflow_container_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::overflow_container_type = std::map<Key, T, Compare, Allocator>
private

◆ pointer

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::pointer = typename ht::pointer

◆ reference

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::reference = typename ht::reference

◆ size_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::size_type = typename ht::size_type

◆ value_type

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
using tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::value_type = typename ht::value_type

Constructor & Destructor Documentation

◆ bhopscotch_map() [1/11]

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

◆ bhopscotch_map() [2/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( size_type bucket_count,
const Hash & hash = Hash(),
const KeyEqual & equal = KeyEqual(),
const Allocator & alloc = Allocator(),
const Compare & comp = Compare() )
inlineexplicit

◆ bhopscotch_map() [3/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( size_type bucket_count,
const Allocator & alloc )
inline

◆ bhopscotch_map() [4/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( size_type bucket_count,
const Hash & hash,
const Allocator & alloc )
inline

◆ bhopscotch_map() [5/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( const Allocator & alloc)
inlineexplicit

◆ bhopscotch_map() [6/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class InputIt >
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( InputIt first,
InputIt last,
size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
const Hash & hash = Hash(),
const KeyEqual & equal = KeyEqual(),
const Allocator & alloc = Allocator() )
inline

◆ bhopscotch_map() [7/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class InputIt >
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( InputIt first,
InputIt last,
size_type bucket_count,
const Allocator & alloc )
inline

◆ bhopscotch_map() [8/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class InputIt >
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( InputIt first,
InputIt last,
size_type bucket_count,
const Hash & hash,
const Allocator & alloc )
inline

◆ bhopscotch_map() [9/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( std::initializer_list< value_type > init,
size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
const Hash & hash = Hash(),
const KeyEqual & equal = KeyEqual(),
const Allocator & alloc = Allocator() )
inline

◆ bhopscotch_map() [10/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( std::initializer_list< value_type > init,
size_type bucket_count,
const Allocator & alloc )
inline

◆ bhopscotch_map() [11/11]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bhopscotch_map ( std::initializer_list< value_type > init,
size_type bucket_count,
const Hash & hash,
const Allocator & alloc )
inline

Member Function Documentation

◆ at() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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>
T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( 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.

◆ at() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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 T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( const K & key) const
inline

◆ at() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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>
T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( const K & 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.

◆ at() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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 T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( const K & key,
std::size_t precalculated_hash ) const
inline

◆ at() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( const Key & key)
inline

◆ at() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( const Key & key) const
inline

◆ at() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( const Key & key,
std::size_t precalculated_hash )
inline

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

◆ at() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::at ( const Key & key,
std::size_t precalculated_hash ) const
inline

◆ begin() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const_iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::begin ( ) const
inlinenoexcept

◆ begin() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::begin ( )
inlinenoexcept

◆ bucket_count()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::bucket_count ( ) const
inline

◆ cbegin()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const_iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::cbegin ( ) const
inlinenoexcept

◆ cend()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const_iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::cend ( ) const
inlinenoexcept

◆ clear()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
void tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::clear ( )
inlinenoexcept

◆ contains() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::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::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, 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.

◆ contains() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::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::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::contains ( const K & 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.

◆ contains() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
bool tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::contains ( const Key & key) const
inline

◆ contains() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
bool tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, 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.

◆ count() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, 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() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::count ( const K & 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.

◆ count() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::count ( const Key & key) const
inline

◆ count() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, 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). Useful to speed-up the lookup if you already have the hash.

◆ emplace()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, 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 T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class... Args>
iterator tsl::bhopscotch_map< Key, T, 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 T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
bool tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::empty ( ) const
inlinenoexcept

◆ end() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const_iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::end ( ) const
inlinenoexcept

◆ end() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::end ( )
inlinenoexcept

◆ equal_range() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, 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() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::equal_range ( const K & key) const
inline

◆ equal_range() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::equal_range ( const K & 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.

◆ equal_range() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::equal_range ( const K & key,
std::size_t precalculated_hash ) const
inline

◆ equal_range() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
std::pair< iterator, iterator > tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::equal_range ( const Key & key)
inline

◆ equal_range() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::equal_range ( const Key & key) const
inline

◆ equal_range() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
std::pair< iterator, iterator > tsl::bhopscotch_map< Key, T, 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). Useful to speed-up the lookup if you already have the hash.

◆ equal_range() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::equal_range ( const Key & key,
std::size_t precalculated_hash ) const
inline

◆ erase() [1/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, 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() [2/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::erase ( const K & 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.

◆ erase() [3/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::erase ( const key_type & key)
inline

◆ erase() [4/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, 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). Useful to speed-up the lookup to the value if you already have the hash.

◆ erase() [5/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::erase ( const_iterator first,
const_iterator last )
inline

◆ erase() [6/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::erase ( const_iterator pos)
inline

◆ erase() [7/7]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::erase ( iterator pos)
inline

◆ find() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, 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() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::find ( const K & key) const
inline

◆ find() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::find ( const K & 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.

◆ find() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::find ( const K & key,
std::size_t precalculated_hash ) const
inline

◆ find() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::find ( const Key & key)
inline

◆ find() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const_iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::find ( const Key & key) const
inline

◆ find() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, 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). Useful to speed-up the lookup if you already have the hash.

◆ find() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
const_iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::find ( const Key & key,
std::size_t precalculated_hash ) const
inline

◆ get_allocator()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
allocator_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::get_allocator ( ) const
inline

◆ hash_function()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
hasher tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::hash_function ( ) const
inline

◆ insert() [1/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
std::pair< iterator, bool > tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( const value_type & value)
inline

◆ insert() [2/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( const_iterator hint,
const value_type & value )
inline

◆ insert() [3/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class P , typename std::enable_if< std::is_constructible< value_type, P && >::value >::type * = nullptr>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( const_iterator hint,
P && value )
inline

◆ insert() [4/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( const_iterator hint,
value_type && value )
inline

◆ insert() [5/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class InputIt >
void tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( InputIt first,
InputIt last )
inline

◆ insert() [6/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class P , typename std::enable_if< std::is_constructible< value_type, P && >::value >::type * = nullptr>
std::pair< iterator, bool > tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( P && value)
inline

◆ insert() [7/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
void tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( std::initializer_list< value_type > ilist)
inline

◆ insert() [8/8]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
std::pair< iterator, bool > tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert ( value_type && value)
inline

◆ insert_or_assign() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class M >
std::pair< iterator, bool > tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert_or_assign ( const key_type & k,
M && obj )
inline

◆ insert_or_assign() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class M >
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert_or_assign ( const_iterator hint,
const key_type & k,
M && obj )
inline

◆ insert_or_assign() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class M >
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert_or_assign ( const_iterator hint,
key_type && k,
M && obj )
inline

◆ insert_or_assign() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class M >
std::pair< iterator, bool > tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::insert_or_assign ( key_type && k,
M && obj )
inline

◆ key_comp()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
key_compare tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::key_comp ( ) const
inline

◆ key_eq()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
key_equal tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::key_eq ( ) const
inline

◆ load_factor()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
float tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::load_factor ( ) const
inline

◆ max_bucket_count()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_bucket_count ( ) const
inline

◆ max_load_factor() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
float tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_load_factor ( ) const
inline

◆ max_load_factor() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
void tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_load_factor ( float ml)
inline

◆ max_size()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::max_size ( ) const
inlinenoexcept

◆ mutable_iterator()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
iterator tsl::bhopscotch_map< Key, T, 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 T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
bhopscotch_map & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::operator= ( std::initializer_list< value_type > ilist)
inline

◆ operator[]() [1/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::operator[] ( const Key & key)
inline

◆ operator[]() [2/2]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
T & tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::operator[] ( Key && key)
inline

◆ overflow_size()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::overflow_size ( ) const
inlinenoexcept

◆ rehash()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
void tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::rehash ( size_type count_)
inline

◆ reserve()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
void tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::reserve ( size_type count_)
inline

◆ size()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
size_type tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::size ( ) const
inlinenoexcept

◆ swap()

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
void tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::swap ( bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & other)
inline

◆ try_emplace() [1/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::try_emplace ( const key_type & k,
Args &&... args )
inline

◆ try_emplace() [2/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class... Args>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::try_emplace ( const_iterator hint,
const key_type & k,
Args &&... args )
inline

◆ try_emplace() [3/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
template<class... Args>
iterator tsl::bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::try_emplace ( const_iterator hint,
key_type && k,
Args &&... args )
inline

◆ try_emplace() [4/4]

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, 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_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::try_emplace ( key_type && k,
Args &&... args )
inline

Friends And Related Symbol Documentation

◆ operator!=

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
bool operator!= ( const bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & lhs,
const bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & rhs )
friend

◆ operator==

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
bool operator== ( const bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & lhs,
const bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & rhs )
friend

◆ swap

template<class Key , class T , class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>, unsigned int NeighborhoodSize = 62, bool StoreHash = false, class GrowthPolicy = tsl::hh::power_of_two_growth_policy<2>>
void swap ( bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & lhs,
bhopscotch_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > & rhs )
friend

Member Data Documentation

◆ m_ht

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

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