tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > Class Template Reference

#include <array_set.h>

Public Types
using	char_type = typename ht::char_type
using	key_size_type = typename ht::key_size_type
using	index_size_type = typename ht::index_size_type
using	size_type = typename ht::size_type
using	hasher = typename ht::hasher
using	key_equal = typename ht::key_equal
using	iterator = typename ht::iterator
using	const_iterator = typename ht::const_iterator

Public Member Functions
	array_set ()
	array_set (size_type bucket_count, const Hash &hash=Hash())
template<class InputIt , typename std::enable_if< is_iterator< InputIt >::value >::type * = nullptr>
	array_set (InputIt first, InputIt last, size_type bucket_count=ht::DEFAULT_INIT_BUCKET_COUNT, const Hash &hash=Hash())
	array_set (std::initializer_list< const CharT *> init, size_type bucket_count=ht::DEFAULT_INIT_BUCKET_COUNT, const Hash &hash=Hash())
array_set &	operator= (std::initializer_list< const CharT *> ilist)
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
size_type	max_key_size () const noexcept
void	shrink_to_fit ()
void	clear () noexcept
std::pair< iterator, bool >	insert (const CharT *key)
std::pair< iterator, bool >	insert (const std::basic_string< CharT > &key)
std::pair< iterator, bool >	insert_ks (const CharT *key, size_type key_size)
template<class InputIt , typename std::enable_if< is_iterator< InputIt >::value >::type * = nullptr>
void	insert (InputIt first, InputIt last)
void	insert (std::initializer_list< const CharT *> ilist)
std::pair< iterator, bool >	emplace (const CharT *key)
std::pair< iterator, bool >	emplace (const std::basic_string< CharT > &key)
std::pair< iterator, bool >	emplace_ks (const CharT *key, size_type key_size)
iterator	erase (const_iterator pos)
iterator	erase (const_iterator first, const_iterator last)
size_type	erase (const CharT *key)
size_type	erase (const std::basic_string< CharT > &key)
size_type	erase_ks (const CharT *key, size_type key_size)
size_type	erase (const CharT *key, std::size_t precalculated_hash)
size_type	erase (const std::basic_string< CharT > &key, std::size_t precalculated_hash)
size_type	erase_ks (const CharT *key, size_type key_size, std::size_t precalculated_hash)
void	swap (array_set &other)
size_type	count (const CharT *key) const
size_type	count (const std::basic_string< CharT > &key) const
size_type	count_ks (const CharT *key, size_type key_size) const
size_type	count (const CharT *key, std::size_t precalculated_hash) const
size_type	count (const std::basic_string< CharT > &key, std::size_t precalculated_hash) const
size_type	count_ks (const CharT *key, size_type key_size, std::size_t precalculated_hash) const
iterator	find (const CharT *key)
const_iterator	find (const CharT *key) const
iterator	find (const std::basic_string< CharT > &key)
const_iterator	find (const std::basic_string< CharT > &key) const
iterator	find_ks (const CharT *key, size_type key_size)
const_iterator	find_ks (const CharT *key, size_type key_size) const
iterator	find (const CharT *key, std::size_t precalculated_hash)
const_iterator	find (const CharT *key, std::size_t precalculated_hash) const
iterator	find (const std::basic_string< CharT > &key, std::size_t precalculated_hash)
const_iterator	find (const std::basic_string< CharT > &key, std::size_t precalculated_hash) const
iterator	find_ks (const CharT *key, size_type key_size, std::size_t precalculated_hash)
const_iterator	find_ks (const CharT *key, size_type key_size, std::size_t precalculated_hash) const
std::pair< iterator, iterator >	equal_range (const CharT *key)
std::pair< const_iterator, const_iterator >	equal_range (const CharT *key) const
std::pair< iterator, iterator >	equal_range (const std::basic_string< CharT > &key)
std::pair< const_iterator, const_iterator >	equal_range (const std::basic_string< CharT > &key) const
std::pair< iterator, iterator >	equal_range_ks (const CharT *key, size_type key_size)
std::pair< const_iterator, const_iterator >	equal_range_ks (const CharT *key, size_type key_size) const
std::pair< iterator, iterator >	equal_range (const CharT *key, std::size_t precalculated_hash)
std::pair< const_iterator, const_iterator >	equal_range (const CharT *key, std::size_t precalculated_hash) const
std::pair< iterator, iterator >	equal_range (const std::basic_string< CharT > &key, std::size_t precalculated_hash)
std::pair< const_iterator, const_iterator >	equal_range (const std::basic_string< CharT > &key, std::size_t precalculated_hash) const
std::pair< iterator, iterator >	equal_range_ks (const CharT *key, size_type key_size, std::size_t precalculated_hash)
std::pair< const_iterator, const_iterator >	equal_range_ks (const CharT *key, size_type key_size, std::size_t precalculated_hash) const
size_type	bucket_count () const
size_type	max_bucket_count () const
float	load_factor () const
float	max_load_factor () const
void	max_load_factor (float ml)
void	rehash (size_type count)
void	reserve (size_type count)
hasher	hash_function () const
key_equal	key_eq () const
iterator	mutable_iterator (const_iterator it) noexcept
template<class Serializer >
void	serialize (Serializer &serializer) const

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

Static Public Attributes
static const size_type	MAX_KEY_SIZE = ht::MAX_KEY_SIZE

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

Detailed Description

template<class CharT, class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>
class tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >

Implementation of a cache-conscious string hash set.

The set stores the strings as const CharT*. If StoreNullTerminator is true, the strings are stored with the a null-terminator (the key() method of the iterators will return a pointer to this null-terminated string). Otherwise the null character is not stored (which allow an economy of 1 byte per string).

The size of a key string is limited to std::numeric_limits<KeySizeT>::max() - 1. That is 65 535 characters by default, but can be raised with the KeySizeT template parameter. See max_key_size() for an easy access to this limit.

The number of elements in the set is limited to std::numeric_limits<IndexSizeT>::max(). That is 4 294 967 296 elements, but can be raised with the IndexSizeT template parameter. See max_size() for an easy access to this limit.

Iterators invalidation:

• clear, operator=: always invalidate the iterators.
• insert, emplace, operator[]: always invalidate the iterators.
• erase: always invalidate the iterators.
• shrink_to_fit: always invalidate the iterators.

Member Typedef Documentation

char_type

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::char_type = typename ht::char_type

const_iterator

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::const_iterator = typename ht::const_iterator

hasher

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::hasher = typename ht::hasher

index_size_type

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::index_size_type = typename ht::index_size_type

iterator

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::iterator = typename ht::iterator

key_equal

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::key_equal = typename ht::key_equal

key_size_type

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::key_size_type = typename ht::key_size_type

size_type

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

using tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::size_type = typename ht::size_type

Constructor & Destructor Documentation

array_set() [1/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::array_set ( )

inline

array_set() [2/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::array_set ( size_type  bucket_count, const Hash &  hash = Hash()  )

inlineexplicit

array_set() [3/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

template<class InputIt , typename std::enable_if< is_iterator< InputIt >::value >::type * = nullptr>

tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::array_set ( InputIt  first, InputIt  last, size_type  bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT, const Hash &  hash = Hash()  )

inline

array_set() [4/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::array_set ( std::initializer_list< const CharT *>  init, size_type  bucket_count = ht::DEFAULT_INIT_BUCKET_COUNT, const Hash &  hash = Hash()  )

inline

Member Function Documentation

begin() [1/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::begin ( )

inlinenoexcept

begin() [2/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::begin ( ) const

inlinenoexcept

bucket_count()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::bucket_count ( ) const

inline

cbegin()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::cbegin ( ) const

inlinenoexcept

cend()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::cend ( ) const

inlinenoexcept

clear()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::clear ( )

inlinenoexcept

count() [1/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count ( const CharT *  key ) const

inline

count() [2/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count ( const std::basic_string< CharT > &  key ) const

inline

count() [3/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count ( const CharT *  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 to the value if you already have the hash.

count() [4/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count ( const std::basic_string< CharT > &  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 to the value if you already have the hash.

count_ks() [1/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count_ks ( const CharT *  key, size_type  key_size  ) const

inline

count_ks() [2/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count_ks ( const CharT *  key, size_type  key_size, 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 to the value if you already have the hash.

deserialize()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

template<class Deserializer >

static array_set tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::deserialize ( Deserializer &  deserializer, bool  hash_compatible = false  )

inlinestatic

Deserialize a previouly serialized set through the deserializer parameter.

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

• template<typename U> U operator()(); where the types std::uint64_t, float and T must be supported for U.
• void operator()(CharT* value_out, std::size_t value_size);

If the deserialized hash set type is hash compatible with the serialized set, the deserialization process can be sped up by setting hash_compatible to true. To be hash compatible, the Hash (take care of the 32-bits vs 64 bits), KeyEqual, GrowthPolicy, StoreNullTerminator, KeySizeT and IndexSizeT must behave the same than the one used on the serialazed set. Otherwise the behaviour is undefined with hash_compatible sets to true, .

The behaviour is undefined if the type CharT of the array_set is not the same as the types used during serialization.

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

emplace() [1/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::emplace ( const CharT *  key )

inline

No difference compared to the insert method. Mainly here for coherence with array_map.

emplace() [2/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::emplace ( const std::basic_string< CharT > &  key )

inline

No difference compared to the insert method. Mainly here for coherence with array_map.

emplace_ks()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::emplace_ks ( const CharT *  key, size_type  key_size  )

inline

No difference compared to the insert method. Mainly here for coherence with array_map.

empty()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

bool tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::empty ( ) const

inlinenoexcept

end() [1/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::end ( )

inlinenoexcept

end() [2/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::end ( ) const

inlinenoexcept

equal_range() [1/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  key )

inline

equal_range() [2/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  key ) const

inline

equal_range() [3/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const std::basic_string< CharT > &  key )

inline

equal_range() [4/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const std::basic_string< CharT > &  key ) const

inline

equal_range() [5/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  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.

equal_range() [6/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  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 to the value if you already have the hash.

equal_range() [7/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const std::basic_string< CharT > &  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.

equal_range() [8/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const std::basic_string< CharT > &  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 to the value if you already have the hash.

equal_range_ks() [1/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range_ks ( const CharT *  key, size_type  key_size  )

inline

equal_range_ks() [2/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range_ks ( const CharT *  key, size_type  key_size  ) const

inline

equal_range_ks() [3/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range_ks ( const CharT *  key, size_type  key_size, 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.

equal_range_ks() [4/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<const_iterator, const_iterator> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range_ks ( const CharT *  key, size_type  key_size, 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 to the value if you already have the hash.

erase() [1/6]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const_iterator  pos )

inline

erase() [2/6]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const_iterator  first, const_iterator  last  )

inline

erase() [3/6]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const CharT *  key )

inline

erase() [4/6]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const std::basic_string< CharT > &  key )

inline

erase() [5/6]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const CharT *  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/6]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const std::basic_string< CharT > &  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_ks() [1/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase_ks ( const CharT *  key, size_type  key_size  )

inline

erase_ks() [2/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase_ks ( const CharT *  key, size_type  key_size, 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.

find() [1/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  key )

inline

find() [2/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  key ) const

inline

find() [3/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const std::basic_string< CharT > &  key )

inline

find() [4/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const std::basic_string< CharT > &  key ) const

inline

find() [5/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  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.

find() [6/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  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 to the value if you already have the hash.

find() [7/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const std::basic_string< CharT > &  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.

find() [8/8]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const std::basic_string< CharT > &  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 to the value if you already have the hash.

find_ks() [1/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find_ks ( const CharT *  key, size_type  key_size  )

inline

find_ks() [2/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find_ks ( const CharT *  key, size_type  key_size  ) const

inline

find_ks() [3/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find_ks ( const CharT *  key, size_type  key_size, 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.

find_ks() [4/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const_iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find_ks ( const CharT *  key, size_type  key_size, 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 to the value if you already have the hash.

hash_function()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

hasher tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::hash_function ( ) const

inline

insert() [1/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::insert ( const CharT *  key )

inline

insert() [2/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::insert ( const std::basic_string< CharT > &  key )

inline

insert() [3/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

template<class InputIt , typename std::enable_if< is_iterator< InputIt >::value >::type * = nullptr>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::insert ( InputIt  first, InputIt  last  )

inline

insert() [4/4]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::insert ( std::initializer_list< const CharT *>  ilist )

inline

insert_ks()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

std::pair<iterator, bool> tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::insert_ks ( const CharT *  key, size_type  key_size  )

inline

key_eq()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

key_equal tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::key_eq ( ) const

inline

load_factor()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

float tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::load_factor ( ) const

inline

max_bucket_count()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::max_bucket_count ( ) const

inline

max_key_size()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::max_key_size ( ) const

inlinenoexcept

max_load_factor() [1/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

float tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::max_load_factor ( ) const

inline

max_load_factor() [2/2]

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::max_load_factor ( float  ml )

inline

max_size()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::max_size ( ) const

inlinenoexcept

mutable_iterator()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

iterator tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::mutable_iterator ( const_iterator  it )

inlinenoexcept

Return the const_iterator it as an iterator.

operator=()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

array_set& tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::operator= ( std::initializer_list< const CharT *>  ilist )

inline

rehash()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::rehash ( size_type  count )

inline

reserve()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::reserve ( size_type  count )

inline

serialize()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

template<class Serializer >

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::serialize ( Serializer &  serializer ) const

inline

Serialize the set through the serializer parameter.

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

• void operator()(const U& value); where the types std::uint64_t and float must be supported for U.
• void operator()(const CharT* value, std::size_t value_size);

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

shrink_to_fit()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::shrink_to_fit ( )

inline

size()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::size ( ) const

inlinenoexcept

swap()

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::swap ( array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  other )

inline

Friends And Related Function Documentation

operator!=

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

bool operator!= ( const array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  lhs, const array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  rhs  )

friend

operator==

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

bool operator== ( const array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  lhs, const array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  rhs  )

friend

swap

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

void swap ( array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  lhs, array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  rhs  )

friend

Member Data Documentation

MAX_KEY_SIZE

template<class CharT , class Hash = tsl::ah::str_hash<CharT>, class KeyEqual = tsl::ah::str_equal<CharT>, bool StoreNullTerminator = true, class KeySizeT = std::uint16_t, class IndexSizeT = std::uint32_t, class GrowthPolicy = tsl::ah::power_of_two_growth_policy<2>>

const size_type tsl::array_set< CharT, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::MAX_KEY_SIZE = ht::MAX_KEY_SIZE

static

---

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

• include/tsl/array_set.h