tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > Class Template Reference

#include <array_hash.h>

Inherits tsl::detail_array_hash::value_container< T >, Hash, and GrowthPolicy.

Classes
class	array_hash_iterator

Public Types
using	char_type = CharT
using	key_size_type = KeySizeT
using	index_size_type = IndexSizeT
using	size_type = std::size_t
using	hasher = Hash
using	key_equal = KeyEqual
using	iterator = array_hash_iterator< false >
using	const_iterator = array_hash_iterator< true >

Public Member Functions
	array_hash (size_type bucket_count, const Hash &hash, float max_load_factor)
	array_hash (const array_hash &other)
	array_hash (array_hash &&other) noexcept(std::is_nothrow_move_constructible< value_container< T >>::value &&std::is_nothrow_move_constructible< Hash >::value &&std::is_nothrow_move_constructible< GrowthPolicy >::value &&std::is_nothrow_move_constructible< std::vector< array_bucket >>::value)
array_hash &	operator= (const array_hash &other)
array_hash &	operator= (array_hash &&other)
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
template<class... ValueArgs>
std::pair< iterator, bool >	emplace (const CharT *key, size_type key_size, ValueArgs &&... value_args)
template<class M >
std::pair< iterator, bool >	insert_or_assign (const CharT *key, size_type key_size, M &&obj)
iterator	erase (const_iterator pos)
iterator	erase (const_iterator first, const_iterator last)
size_type	erase (const CharT *key, size_type key_size)
size_type	erase (const CharT *key, size_type key_size, std::size_t hash)
void	swap (array_hash &other)
template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>
U &	at (const CharT *key, size_type key_size)
template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>
const U &	at (const CharT *key, size_type key_size) const
template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>
U &	at (const CharT *key, size_type key_size, std::size_t hash)
template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>
const U &	at (const CharT *key, size_type key_size, std::size_t hash) const
template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>
U &	access_operator (const CharT *key, size_type key_size)
size_type	count (const CharT *key, size_type key_size) const
size_type	count (const CharT *key, size_type key_size, std::size_t hash) const
iterator	find (const CharT *key, size_type key_size)
const_iterator	find (const CharT *key, size_type key_size) const
iterator	find (const CharT *key, size_type key_size, std::size_t hash)
const_iterator	find (const CharT *key, size_type key_size, std::size_t hash) const
std::pair< iterator, iterator >	equal_range (const CharT *key, size_type key_size)
std::pair< const_iterator, const_iterator >	equal_range (const CharT *key, size_type key_size) const
std::pair< iterator, iterator >	equal_range (const CharT *key, size_type key_size, std::size_t hash)
std::pair< const_iterator, const_iterator >	equal_range (const CharT *key, size_type key_size, std::size_t 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
template<class Deserializer >
void	deserialize (Deserializer &deserializer, bool hash_compatible)

Static Public Attributes
static const size_type	DEFAULT_INIT_BUCKET_COUNT = 16
static constexpr float	DEFAULT_MAX_LOAD_FACTOR = 2.0f
static const size_type	MAX_KEY_SIZE = array_bucket::MAX_KEY_SIZE

Detailed Description

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>
class tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >

If there is no value in the array_hash (in the case of a set for example), T should be void.

The size of a key string is limited to std::numeric_limits<KeySizeT>::max() - 1.

The number of elements in the map is limited to std::numeric_limits<IndexSizeT>::max().

Member Typedef Documentation

char_type

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::char_type = CharT

const_iterator

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::const_iterator = array_hash_iterator<true>

hasher

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::hasher = Hash

index_size_type

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::index_size_type = IndexSizeT

iterator

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::iterator = array_hash_iterator<false>

key_equal

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::key_equal = KeyEqual

key_size_type

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::key_size_type = KeySizeT

size_type

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

using tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::size_type = std::size_t

Constructor & Destructor Documentation

array_hash() [1/3]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::array_hash ( size_type  bucket_count, const Hash &  hash, float  max_load_factor  )

inline

array_hash() [2/3]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::array_hash ( const array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  other )

inline

array_hash() [3/3]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::array_hash ( array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &&  other )

inlinenoexcept

Member Function Documentation

access_operator()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>

U& tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::access_operator ( const CharT *  key, size_type  key_size  )

inline

at() [1/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>

U& tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::at ( const CharT *  key, size_type  key_size  )

inline

at() [2/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>

const U& tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::at ( const CharT *  key, size_type  key_size  ) const

inline

at() [3/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>

U& tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::at ( const CharT *  key, size_type  key_size, std::size_t  hash  )

inline

at() [4/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class U = T, typename std::enable_if< has_mapped_type< U >::value >::type * = nullptr>

const U& tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::at ( const CharT *  key, size_type  key_size, std::size_t  hash  ) const

inline

begin() [1/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

begin() [2/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

bucket_count()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

cbegin()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

cend()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

clear()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

count() [1/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

size_type tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count ( const CharT *  key, size_type  key_size  ) const

inline

count() [2/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

size_type tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::count ( const CharT *  key, size_type  key_size, std::size_t  hash  ) const

inline

deserialize()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class Deserializer >

void tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::deserialize ( Deserializer &  deserializer, bool  hash_compatible  )

inline

emplace()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class... ValueArgs>

std::pair<iterator, bool> tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::emplace ( const CharT *  key, size_type  key_size, ValueArgs &&...  value_args  )

inline

empty()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

end() [1/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

end() [2/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

equal_range() [1/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

std::pair<iterator, iterator> tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  key, size_type  key_size  )

inline

equal_range() [2/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

std::pair<const_iterator, const_iterator> tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  key, size_type  key_size  ) const

inline

equal_range() [3/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

std::pair<iterator, iterator> tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  key, size_type  key_size, std::size_t  hash  )

inline

equal_range() [4/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

std::pair<const_iterator, const_iterator> tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::equal_range ( const CharT *  key, size_type  key_size, std::size_t  hash  ) const

inline

erase() [1/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

erase() [2/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

When erasing an element from a bucket with erase_from_bucket, it invalidates all the iterators in the array bucket of the element (m_array_bucket_iterator) but not the iterators of the buckets itself (m_buckets_iterator).

So first erase all the values between first and last which are not part of the bucket of last, and then erase carefully the values in last's bucket.

erase() [3/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

size_type tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const CharT *  key, size_type  key_size  )

inline

erase() [4/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

size_type tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::erase ( const CharT *  key, size_type  key_size, std::size_t  hash  )

inline

find() [1/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

iterator tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  key, size_type  key_size  )

inline

find() [2/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

const_iterator tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  key, size_type  key_size  ) const

inline

find() [3/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

iterator tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  key, size_type  key_size, std::size_t  hash  )

inline

find() [4/4]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

const_iterator tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::find ( const CharT *  key, size_type  key_size, std::size_t  hash  ) const

inline

hash_function()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

insert_or_assign()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class M >

std::pair<iterator, bool> tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::insert_or_assign ( const CharT *  key, size_type  key_size, M &&  obj  )

inline

key_eq()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

load_factor()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

max_bucket_count()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

max_key_size()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

max_load_factor() [1/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

max_load_factor() [2/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

max_size()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

mutable_iterator()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

operator=() [1/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

array_hash& tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::operator= ( const array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &  other )

inline

operator=() [2/2]

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

array_hash& tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::operator= ( array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy > &&  other )

inline

rehash()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

reserve()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

serialize()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

template<class Serializer >

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

inline

shrink_to_fit()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

size()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inlinenoexcept

swap()

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

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

inline

Member Data Documentation

DEFAULT_INIT_BUCKET_COUNT

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

const size_type tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::DEFAULT_INIT_BUCKET_COUNT = 16

static

DEFAULT_MAX_LOAD_FACTOR

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

constexpr float tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::DEFAULT_MAX_LOAD_FACTOR = 2.0f

static

MAX_KEY_SIZE

template<class CharT, class T, class Hash, class KeyEqual, bool StoreNullTerminator, class KeySizeT, class IndexSizeT, class GrowthPolicy>

const size_type tsl::detail_array_hash::array_hash< CharT, T, Hash, KeyEqual, StoreNullTerminator, KeySizeT, IndexSizeT, GrowthPolicy >::MAX_KEY_SIZE = array_bucket::MAX_KEY_SIZE

static

---

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

• include/tsl/array_hash.h