Implementation of std::unordered_map. Plus de détails...

#include <arcane/utils/HashTableMap2.h>

Graphe d'héritage de Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >:

Graphe de collaboration de Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >:

Classes
class	const_iterator

class	iterator

Types publics
using	htype = HashTableMap2< KeyT, ValueT, HashT, EqT >

using	value_type = std::pair< KeyT, ValueT >

using	key_type = KeyT

using	mapped_type = ValueT

using	hasher = HashT

using	key_equal = EqT

Types publics hérités de Arcane::impl::HashTableMap2Base
using	size_type = uint32_t

Fonctions membres publiques
void	init (size_type bucket, float mlf=EMH_DEFAULT_LOAD_FACTOR)

	HashTableMap2 (size_type bucket=2, float mlf=EMH_DEFAULT_LOAD_FACTOR)

	HashTableMap2 (const HashTableMap2 &rhs)

	HashTableMap2 (HashTableMap2 &&rhs) noexcept

	HashTableMap2 (std::initializer_list< value_type > ilist)

template<class InputIt >
	HashTableMap2 (InputIt first, InputIt last, size_type bucket_count=4)

HashTableMap2 &	operator= (const HashTableMap2 &rhs)

HashTableMap2 &	operator= (HashTableMap2 &&rhs) noexcept

template<typename Con >
bool	operator== (const Con &rhs) const

template<typename Con >
bool	operator!= (const Con &rhs) const

void	clone (const HashTableMap2 &rhs)

void	swap (HashTableMap2 &rhs)

iterator	first () const

iterator	last () const

value_type &	front ()

const value_type &	front () const

value_type &	back ()

const value_type &	back () const

void	pop_front ()

void	pop_back ()

iterator	begin ()

const_iterator	cbegin () const

const_iterator	begin () const

iterator	end ()

const_iterator	cend () const

const_iterator	end () const

const value_type *	values () const

const Index *	index () const

size_type	size () const

bool	empty () const

size_type	bucket_count () const

double	load_factor () const
	Returns average number of elements per bucket.

HashT &	hash_function () const

EqT &	key_eq () const

void	max_load_factor (double mlf)

constexpr double	max_load_factor () const

constexpr size_type	max_size () const

constexpr size_type	max_bucket_count () const

template<typename K = KeyT>
iterator	find (const K &key) noexcept

template<typename K = KeyT>
const_iterator	find (const K &key) const noexcept

template<typename K = KeyT>
ValueT &	at (const K &key)

template<typename K = KeyT>
const ValueT &	at (const K &key) const

const ValueT &	index (const uint32_t index) const

ValueT &	index (const uint32_t index)

template<typename K = KeyT>
bool	contains (const K &key) const noexcept

template<typename K = KeyT>
size_type	count (const K &key) const noexcept

template<typename K = KeyT>
std::pair< iterator, iterator >	equal_range (const K &key)

void	merge (HashTableMap2 &rhs)

std::pair< iterator, bool >	add (const KeyT &key, const ValueT &value)

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

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

void	insert (std::initializer_list< value_type > ilist)

template<typename Iter >
void	insert (Iter first, Iter last)

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

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

template<class... Args>
std::pair< iterator, bool >	try_emplace (const KeyT &k, Args &&... args)

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

template<class... Args>
size_type	emplace_unique (Args &&... args)

std::pair< iterator, bool >	insert_or_assign (const KeyT &key, ValueT &&val)

std::pair< iterator, bool >	insert_or_assign (KeyT &&key, ValueT &&val)

ValueT	set_get (const KeyT &key, const ValueT &val)
	Return the old value or ValueT() if it didn't exist.

ValueT &	operator[] (const KeyT &key) noexcept
	Like std::map<KeyT, ValueT>::operator[].

ValueT &	operator[] (KeyT &&key) noexcept

size_type	erase (const KeyT &key) noexcept

iterator	erase (const const_iterator &cit) noexcept

iterator	erase (const_iterator first, const_iterator last) noexcept

template<typename Pred >
size_type	erase_if (Pred pred)

void	clear () noexcept
	Remove all elements, keeping full capacity.

void	shrink_to_fit (const float min_factor=EMH_DEFAULT_LOAD_FACTOR/4)

bool	reserve (uint64_t num_elems, bool force)
	Make room for this many elements.

bool	reserve (size_type required_buckets) noexcept

void	rehash (uint64_t required_buckets)

Fonctions membres publiques statiques
static constexpr bool	is_triviall_destructable ()

static constexpr bool	is_copy_trivially ()

Attributs publics statiques
static constexpr size_type	INACTIVE = 0xFFFFFFFF

static constexpr size_type	END = 0xFFFFFFFF

Fonctions membres privées
void	clearkv ()

void	rebuild (size_type num_buckets) noexcept

void	pack_zero (ValueT zero)

bool	try_get (const KeyT &key, ValueT &val) const noexcept
	Returns the matching ValueT or nullptr if k isn't found.

ValueT *	try_get (const KeyT &key) noexcept
	Returns the matching ValueT or nullptr if k isn't found.

ValueT *	try_get (const KeyT &key) const noexcept
	Const version of the above.

bool	try_set (const KeyT &key, const ValueT &val) noexcept
	set value if key exist

bool	try_set (const KeyT &key, ValueT &&val) noexcept
	set value if key exist

ValueT	get_or_return_default (const KeyT &key) const noexcept
	Convenience function.

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

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

template<typename K , typename V >
std::pair< iterator, bool >	_doInsert (K &&key, V &&val) noexcept

template<typename K , typename V >
std::pair< iterator, bool >	do_assign (K &&key, V &&val) noexcept

template<typename K , typename V >
size_type	insert_unique (K &&key, V &&val)

size_type	insert_unique (value_type &&value)

size_type	insert_unique (const value_type &value)

bool	check_expand_need ()

size_type	slot_to_bucket (const size_type slot) const noexcept

void	erase_slot (const size_type sbucket, const size_type main_bucket) noexcept

size_type	erase_bucket (const size_type bucket, const size_type main_bucket) noexcept

size_type	find_slot_bucket (const size_type slot, size_type &main_bucket) const

size_type	find_filled_bucket (const KeyT &key, uint64_t key_hash) const noexcept

template<typename K = KeyT>
size_type	find_filled_slot (const K &key) const noexcept

size_type	kickout_bucket (const size_type kmain, const size_type bucket) noexcept

template<typename K = KeyT>
size_type	_findOrAllocate (const K &key, uint64_t key_hash) noexcept

size_type	_findUniqueBucket (uint64_t key_hash) noexcept

size_type	_findEmptyBucket (const size_type bucket_from, uint32_t csize) noexcept

size_type	find_last_bucket (size_type main_bucket) const

size_type	find_prev_bucket (const size_type main_bucket, const size_type bucket) const

size_type	hash_bucket (const KeyT &key) const noexcept

size_type	hash_main (const size_type bucket) const noexcept

template<typename UType , typename std::enable_if< std::is_integral< UType >::value, uint32_t >::type = 0>
uint64_t	hash_key (const UType key) const

template<typename UType , typename std::enable_if< std::is_same< UType, std::string >::value, uint32_t >::type = 0>
uint64_t	hash_key (const UType &key) const

template<typename UType , typename std::enable_if<!std::is_integral< UType >::value &&!std::is_same< UType, std::string >::value, uint32_t >::type = 0>
uint64_t	hash_key (const UType &key) const

value_type *	_allocBucket (size_type num_buckets)

void	_freeBuckets ()

Fonctions membres privées statiques
static void	prefetch_heap_block (char *ctrl)

Attributs privés
value_type *	m_pairs = nullptr

HashT	m_hasher

EqT	m_eq

Int64	m_pairs_allocated_size = 0

Attributs privés statiques
static constexpr double	EMH_DEFAULT_LOAD_FACTOR = 0.80f

static constexpr double	EMH_MIN_LOAD_FACTOR = 0.25f

static constexpr uint32_t	EMH_CACHE_LINE_SIZE = 64

Membres hérités additionnels
Fonctions membres protégées hérités de Arcane::impl::HashTableMap2Base
void	_allocIndex (size_type num_buckets)

void	_freeIndex ()

void	_doSwap (HashTableMap2Base &rhs)

void	_doClone (const HashTableMap2Base &rhs)

Attributs protégés hérités de Arcane::impl::HashTableMap2Base
Index *	m_index = nullptr

uint32_t	m_mlf = 0

size_type	m_mask = 0

size_type	m_num_buckets = 0

size_type	m_num_filled = 0

size_type	m_last = 0

size_type	m_etail = 0

IMemoryAllocator *	m_memory_allocator = _defaultAllocator()

Attributs protégés statiques hérités de Arcane::impl::HashTableMap2Base
static constexpr size_type	EAD = 2

Description détaillée

template<typename KeyT, typename ValueT, typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>
class Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >

Implementation of std::unordered_map.

Avertissement: This class is experimental and internal to Arcane.

Définition à la ligne 165 du fichier HashTableMap2.h.

Documentation des définitions de type membres

◆ hasher

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

using Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::hasher = HashT

Définition à la ligne 178 du fichier HashTableMap2.h.

◆ htype

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

using Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::htype = HashTableMap2<KeyT, ValueT, HashT, EqT>

Définition à la ligne 174 du fichier HashTableMap2.h.

◆ key_equal

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

using Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::key_equal = EqT

Définition à la ligne 179 du fichier HashTableMap2.h.

◆ key_type

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

using Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::key_type = KeyT

Définition à la ligne 176 du fichier HashTableMap2.h.

◆ mapped_type

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

using Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::mapped_type = ValueT

Définition à la ligne 177 du fichier HashTableMap2.h.

◆ value_type

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

using Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::value_type = std::pair<KeyT, ValueT>

Définition à la ligne 175 du fichier HashTableMap2.h.

Documentation des constructeurs et destructeur

◆ HashTableMap2() [1/5]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::HashTableMap2	(	size_type	bucket = `2`,
		float	mlf = `EMH_DEFAULT_LOAD_FACTOR`
	)

inline

Définition à la ligne 321 du fichier HashTableMap2.h.

◆ HashTableMap2() [2/5]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::HashTableMap2 ( const HashTableMap2< KeyT, ValueT, HashT, EqT > & rhs )

inline

Définition à la ligne 326 du fichier HashTableMap2.h.

◆ HashTableMap2() [3/5]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::HashTableMap2 ( HashTableMap2< KeyT, ValueT, HashT, EqT > && rhs )

inlinenoexcept

Définition à la ligne 340 du fichier HashTableMap2.h.

◆ HashTableMap2() [4/5]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::HashTableMap2 ( std::initializer_list< value_type > ilist )

inline

Définition à la ligne 346 du fichier HashTableMap2.h.

◆ HashTableMap2() [5/5]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<class InputIt >

Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::HashTableMap2	(	InputIt	first,
		InputIt	last,
		size_type	bucket_count = `4`
	)

inline

Définition à la ligne 354 du fichier HashTableMap2.h.

◆ ~HashTableMap2()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::~HashTableMap2 ( )

inlinenoexcept

Définition à la ligne 417 du fichier HashTableMap2.h.

Documentation des fonctions membres

◆ _allocBucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

value_type * Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_allocBucket ( size_type num_buckets )

inlineprivate

Définition à la ligne 1471 du fichier HashTableMap2.h.

◆ _doInsert() [1/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_doInsert ( const value_type & value )

inlineprivatenoexcept

Définition à la ligne 1028 du fichier HashTableMap2.h.

◆ _doInsert() [2/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K , typename V >

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_doInsert	(	K &&	key,
		V &&	val
	)

inlineprivatenoexcept

Définition à la ligne 1055 du fichier HashTableMap2.h.

◆ _doInsert() [3/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_doInsert ( value_type && value )

inlineprivatenoexcept

Définition à la ligne 1041 du fichier HashTableMap2.h.

◆ _findEmptyBucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_findEmptyBucket	(	const size_type	bucket_from,
		uint32_t	csize
	)

inlineprivatenoexcept

Définition à la ligne 1360 du fichier HashTableMap2.h.

◆ _findOrAllocate()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_findOrAllocate	(	const K &	key,
		uint64_t	key_hash
	)

inlineprivatenoexcept

Définition à la ligne 1285 du fichier HashTableMap2.h.

◆ _findUniqueBucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_findUniqueBucket ( uint64_t key_hash )

inlineprivatenoexcept

Définition à la ligne 1328 du fichier HashTableMap2.h.

◆ _freeBuckets()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::_freeBuckets ( )

inlineprivate

Définition à la ligne 1478 du fichier HashTableMap2.h.

◆ add()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::add	(	const KeyT &	key,
		const ValueT &	value
	)

inline

Définition à la ligne 651 du fichier HashTableMap2.h.

◆ at() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

ValueT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::at ( const K & key )

inline

Définition à la ligne 585 du fichier HashTableMap2.h.

◆ at() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

const ValueT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::at ( const K & key ) const

inline

Définition à la ligne 593 du fichier HashTableMap2.h.

◆ back() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

value_type & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::back ( )

inline

Définition à la ligne 468 du fichier HashTableMap2.h.

◆ back() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const value_type & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::back ( ) const

inline

Définition à la ligne 472 du fichier HashTableMap2.h.

◆ begin() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::begin ( )

inline

Définition à la ligne 486 du fichier HashTableMap2.h.

◆ begin() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const_iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::begin ( ) const

inline

Définition à la ligne 494 du fichier HashTableMap2.h.

◆ bucket_count()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::bucket_count ( ) const

inline

Définition à la ligne 529 du fichier HashTableMap2.h.

◆ cbegin()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const_iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::cbegin ( ) const

inline

Définition à la ligne 490 du fichier HashTableMap2.h.

◆ cend()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const_iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::cend ( ) const

inline

Définition à la ligne 503 du fichier HashTableMap2.h.

◆ check_expand_need()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::check_expand_need ( )

inlineprivate

Définition à la ligne 1107 du fichier HashTableMap2.h.

◆ clear()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::clear ( )

inlinenoexcept

Remove all elements, keeping full capacity.

Définition à la ligne 850 du fichier HashTableMap2.h.

◆ clearkv()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::clearkv ( )

inlineprivate

Définition à la ligne 937 du fichier HashTableMap2.h.

◆ clone()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::clone ( const HashTableMap2< KeyT, ValueT, HashT, EqT > & rhs )

inline

Définition à la ligne 424 du fichier HashTableMap2.h.

◆ contains()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::contains ( const K & key ) const

inlinenoexcept

Définition à la ligne 611 du fichier HashTableMap2.h.

◆ count()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::count ( const K & key ) const

inlinenoexcept

Définition à la ligne 617 du fichier HashTableMap2.h.

◆ do_assign()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K , typename V >

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::do_assign	(	K &&	key,
		V &&	val
	)

inlineprivatenoexcept

Définition à la ligne 1069 du fichier HashTableMap2.h.

◆ emplace()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<class... Args>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::emplace ( Args &&... args )

inlinenoexcept

Définition à la ligne 684 du fichier HashTableMap2.h.

◆ emplace_hint()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<class... Args>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::emplace_hint	(	const_iterator	hint,
		Args &&...	args
	)

inline

Définition à la ligne 692 du fichier HashTableMap2.h.

◆ emplace_unique()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<class... Args>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::emplace_unique ( Args &&... args )

inline

Définition à la ligne 714 du fichier HashTableMap2.h.

◆ empty()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::empty ( ) const

inline

Définition à la ligne 525 du fichier HashTableMap2.h.

◆ end() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::end ( )

inline

Définition à la ligne 499 du fichier HashTableMap2.h.

◆ end() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const_iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::end ( ) const

inline

Définition à la ligne 507 du fichier HashTableMap2.h.

◆ equal_range()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

std::pair< iterator, iterator > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::equal_range ( const K & key )

inline

Définition à la ligne 623 du fichier HashTableMap2.h.

◆ erase() [1/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::erase ( const const_iterator & cit )

inlinenoexcept

Définition à la ligne 789 du fichier HashTableMap2.h.

◆ erase() [2/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::erase ( const KeyT & key )

inlinenoexcept

Erase an element from the hash table. return 0 if element was not found

Définition à la ligne 776 du fichier HashTableMap2.h.

◆ erase() [3/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::erase	(	const_iterator	first,
		const_iterator	last
	)

inlinenoexcept

Définition à la ligne 799 du fichier HashTableMap2.h.

◆ erase_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::erase_bucket	(	const size_type	bucket,
		const size_type	main_bucket
	)

inlineprivatenoexcept

Définition à la ligne 1153 du fichier HashTableMap2.h.

◆ erase_if()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename Pred >

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::erase_if ( Pred pred )

inline

Définition à la ligne 819 du fichier HashTableMap2.h.

◆ erase_slot()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::erase_slot	(	const size_type	sbucket,
		const size_type	main_bucket
	)

inlineprivatenoexcept

Définition à la ligne 1132 du fichier HashTableMap2.h.

◆ find() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

const_iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::find ( const K & key ) const

inlinenoexcept

Définition à la ligne 579 du fichier HashTableMap2.h.

◆ find() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::find ( const K & key )

inlinenoexcept

Définition à la ligne 573 du fichier HashTableMap2.h.

◆ find_filled_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::find_filled_bucket	(	const KeyT &	key,
		uint64_t	key_hash
	)		const

inlineprivatenoexcept

Définition à la ligne 1191 du fichier HashTableMap2.h.

◆ find_filled_slot()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K = KeyT>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::find_filled_slot ( const K & key ) const

inlineprivatenoexcept

Définition à la ligne 1225 du fichier HashTableMap2.h.

◆ find_last_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::find_last_bucket ( size_type main_bucket ) const

inlineprivate

Définition à la ligne 1403 du fichier HashTableMap2.h.

◆ find_prev_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::find_prev_bucket	(	const size_type	main_bucket,
		const size_type	bucket
	)		const

inlineprivate

Définition à la ligne 1417 du fichier HashTableMap2.h.

◆ find_slot_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::find_slot_bucket	(	const size_type	slot,
		size_type &	main_bucket
	)		const

inlineprivate

Définition à la ligne 1173 du fichier HashTableMap2.h.

◆ first()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::first ( ) const

inline

Définition à la ligne 451 du fichier HashTableMap2.h.

◆ front() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

value_type & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::front ( )

inline

Définition à la ligne 460 du fichier HashTableMap2.h.

◆ front() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const value_type & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::front ( ) const

inline

Définition à la ligne 464 du fichier HashTableMap2.h.

◆ get_or_return_default()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

ValueT Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::get_or_return_default ( const KeyT & key ) const

inlineprivatenoexcept

Convenience function.

Définition à la ligne 1021 du fichier HashTableMap2.h.

◆ hash_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::hash_bucket ( const KeyT & key ) const

inlineprivatenoexcept

Définition à la ligne 1431 du fichier HashTableMap2.h.

◆ hash_function()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

HashT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::hash_function ( ) const

inline

Définition à la ligne 540 du fichier HashTableMap2.h.

◆ hash_key() [1/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename UType , typename std::enable_if< std::is_same< UType, std::string >::value, uint32_t >::type = 0>

uint64_t Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::hash_key ( const UType & key ) const

inlineprivate

Définition à la ligne 1451 du fichier HashTableMap2.h.

◆ hash_key() [2/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename UType , typename std::enable_if<!std::is_integral< UType >::value &&!std::is_same< UType, std::string >::value, uint32_t >::type = 0>

uint64_t Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::hash_key ( const UType & key ) const

inlineprivate

Définition à la ligne 1457 du fichier HashTableMap2.h.

◆ hash_key() [3/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename UType , typename std::enable_if< std::is_integral< UType >::value, uint32_t >::type = 0>

uint64_t Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::hash_key ( const UType key ) const

inlineprivate

Définition à la ligne 1445 du fichier HashTableMap2.h.

◆ hash_main()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::hash_main ( const size_type bucket ) const

inlineprivatenoexcept

Définition à la ligne 1436 du fichier HashTableMap2.h.

◆ index() [1/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const Index * Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::index ( ) const

inline

Définition à la ligne 516 du fichier HashTableMap2.h.

◆ index() [2/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

ValueT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::index ( const uint32_t index )

inline

Définition à la ligne 605 du fichier HashTableMap2.h.

◆ index() [3/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const ValueT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::index ( const uint32_t index ) const

inline

Définition à la ligne 600 du fichier HashTableMap2.h.

◆ init()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::init	(	size_type	bucket,
		float	mlf = `EMH_DEFAULT_LOAD_FACTOR`
	)

inline

Définition à la ligne 310 du fichier HashTableMap2.h.

◆ insert() [1/4]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert ( const value_type & p )

inline

Définition à la ligne 656 du fichier HashTableMap2.h.

◆ insert() [2/4]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename Iter >

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert	(	Iter	first,
		Iter	last
	)

inline

Définition à la ligne 676 du fichier HashTableMap2.h.

◆ insert() [3/4]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert ( std::initializer_list< value_type > ilist )

inline

Définition à la ligne 668 du fichier HashTableMap2.h.

◆ insert() [4/4]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert ( value_type && p )

inline

Définition à la ligne 662 du fichier HashTableMap2.h.

◆ insert_or_assign() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert_or_assign	(	const KeyT &	key,
		ValueT &&	val
	)

inline

Définition à la ligne 719 du fichier HashTableMap2.h.

◆ insert_or_assign() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert_or_assign	(	KeyT &&	key,
		ValueT &&	val
	)

inline

Définition à la ligne 723 du fichier HashTableMap2.h.

◆ insert_unique() [1/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert_unique ( const value_type & value )

inlineprivate

Définition à la ligne 1101 du fichier HashTableMap2.h.

◆ insert_unique() [2/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename K , typename V >

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert_unique	(	K &&	key,
		V &&	val
	)

inlineprivate

Définition à la ligne 1087 du fichier HashTableMap2.h.

◆ insert_unique() [3/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::insert_unique ( value_type && value )

inlineprivate

Définition à la ligne 1096 du fichier HashTableMap2.h.

◆ is_copy_trivially()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

static constexpr bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::is_copy_trivially ( )

inlinestaticconstexpr

Définition à la ligne 840 du fichier HashTableMap2.h.

◆ is_triviall_destructable()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

static constexpr bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::is_triviall_destructable ( )

inlinestaticconstexpr

Définition à la ligne 831 du fichier HashTableMap2.h.

◆ key_eq()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

EqT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::key_eq ( ) const

inline

Définition à la ligne 544 du fichier HashTableMap2.h.

◆ kickout_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::kickout_bucket	(	const size_type	kmain,
		const size_type	bucket
	)

inlineprivatenoexcept

Définition à la ligne 1262 du fichier HashTableMap2.h.

◆ last()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

iterator Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::last ( ) const

inline

Définition à la ligne 455 du fichier HashTableMap2.h.

◆ load_factor()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

double Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::load_factor ( ) const

inline

Returns average number of elements per bucket.

Définition à la ligne 535 du fichier HashTableMap2.h.

◆ max_bucket_count()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::max_bucket_count ( ) const

inlineconstexpr

Définition à la ligne 566 du fichier HashTableMap2.h.

◆ max_load_factor() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr double Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::max_load_factor ( ) const

inlineconstexpr

Définition à la ligne 558 du fichier HashTableMap2.h.

◆ max_load_factor() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::max_load_factor ( double mlf )

inline

Définition à la ligne 549 du fichier HashTableMap2.h.

◆ max_size()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::max_size ( ) const

inlineconstexpr

Définition à la ligne 562 du fichier HashTableMap2.h.

◆ merge()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::merge ( HashTableMap2< KeyT, ValueT, HashT, EqT > & rhs )

inline

Définition à la ligne 632 du fichier HashTableMap2.h.

◆ operator!=()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename Con >

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::operator!= ( const Con & rhs ) const

inline

Définition à la ligne 412 du fichier HashTableMap2.h.

◆ operator=() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

HashTableMap2 & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::operator= ( const HashTableMap2< KeyT, ValueT, HashT, EqT > & rhs )

inline

Définition à la ligne 361 du fichier HashTableMap2.h.

◆ operator=() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

HashTableMap2 & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::operator= ( HashTableMap2< KeyT, ValueT, HashT, EqT > && rhs )

inlinenoexcept

Définition à la ligne 388 du fichier HashTableMap2.h.

◆ operator==()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<typename Con >

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::operator== ( const Con & rhs ) const

inline

Définition à la ligne 398 du fichier HashTableMap2.h.

◆ operator[]() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

ValueT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::operator[] ( const KeyT & key )

inlinenoexcept

Like std::map<KeyT, ValueT>::operator[].

Définition à la ligne 747 du fichier HashTableMap2.h.

◆ operator[]() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

ValueT & Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::operator[] ( KeyT && key )

inlinenoexcept

Définition à la ligne 761 du fichier HashTableMap2.h.

◆ pack_zero()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::pack_zero ( ValueT zero )

inlineprivate

Définition à la ligne 968 du fichier HashTableMap2.h.

◆ pop_back()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::pop_back ( )

inline

Définition à la ligne 481 du fichier HashTableMap2.h.

◆ pop_front()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::pop_front ( )

inline

Définition à la ligne 477 du fichier HashTableMap2.h.

◆ prefetch_heap_block()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

static void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::prefetch_heap_block ( char * ctrl )

inlinestaticprivate

Définition à la ligne 1112 du fichier HashTableMap2.h.

◆ rebuild()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::rebuild ( size_type num_buckets )

inlineprivatenoexcept

Définition à la ligne 945 du fichier HashTableMap2.h.

◆ rehash()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::rehash ( uint64_t required_buckets )

inline

Définition à la ligne 905 du fichier HashTableMap2.h.

◆ reserve() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::reserve ( size_type required_buckets )

inlinenoexcept

Définition à la ligne 882 du fichier HashTableMap2.h.

◆ reserve() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::reserve	(	uint64_t	num_elems,
		bool	force
	)

inline

Make room for this many elements.

Définition à la ligne 870 du fichier HashTableMap2.h.

◆ set_get()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

ValueT Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::set_get	(	const KeyT &	key,
		const ValueT &	val
	)

inline

Return the old value or ValueT() if it didn't exist.

Définition à la ligne 729 du fichier HashTableMap2.h.

◆ shrink_to_fit()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::shrink_to_fit ( const float min_factor = EMH_DEFAULT_LOAD_FACTOR / 4 )

inline

Définition à la ligne 862 du fichier HashTableMap2.h.

◆ size()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::size ( ) const

inline

Définition à la ligne 521 du fichier HashTableMap2.h.

◆ slot_to_bucket()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::slot_to_bucket ( const size_type slot ) const

inlineprivatenoexcept

Définition à la ligne 1125 du fichier HashTableMap2.h.

◆ swap()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

void Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::swap ( HashTableMap2< KeyT, ValueT, HashT, EqT > & rhs )

inline

Définition à la ligne 442 du fichier HashTableMap2.h.

◆ try_emplace() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<class... Args>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::try_emplace	(	const KeyT &	k,
		Args &&...	args
	)

inline

Définition à la ligne 700 du fichier HashTableMap2.h.

◆ try_emplace() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

template<class... Args>

std::pair< iterator, bool > Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::try_emplace	(	KeyT &&	k,
		Args &&...	args
	)

inline

Définition à la ligne 707 du fichier HashTableMap2.h.

◆ try_get() [1/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

ValueT * Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::try_get ( const KeyT & key ) const

inlineprivatenoexcept

Const version of the above.

Définition à la ligne 992 du fichier HashTableMap2.h.

◆ try_get() [2/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

ValueT * Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::try_get ( const KeyT & key )

inlineprivatenoexcept

Returns the matching ValueT or nullptr if k isn't found.

Définition à la ligne 985 du fichier HashTableMap2.h.

◆ try_get() [3/3]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::try_get	(	const KeyT &	key,
		ValueT &	val
	)		const

inlineprivatenoexcept

Returns the matching ValueT or nullptr if k isn't found.

Définition à la ligne 974 du fichier HashTableMap2.h.

◆ try_set() [1/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::try_set	(	const KeyT &	key,
		const ValueT &	val
	)

inlineprivatenoexcept

set value if key exist

Définition à la ligne 999 du fichier HashTableMap2.h.

◆ try_set() [2/2]

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

bool Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::try_set	(	const KeyT &	key,
		ValueT &&	val
	)

inlineprivatenoexcept

set value if key exist

Définition à la ligne 1010 du fichier HashTableMap2.h.

◆ values()

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

const value_type * Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::values ( ) const

inline

Définition à la ligne 512 du fichier HashTableMap2.h.

Documentation des données membres

◆ EMH_CACHE_LINE_SIZE

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr uint32_t Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::EMH_CACHE_LINE_SIZE = 64

staticconstexprprivate

Définition à la ligne 170 du fichier HashTableMap2.h.

◆ EMH_DEFAULT_LOAD_FACTOR

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr double Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::EMH_DEFAULT_LOAD_FACTOR = 0.80f

staticconstexprprivate

Définition à la ligne 168 du fichier HashTableMap2.h.

◆ EMH_MIN_LOAD_FACTOR

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr double Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::EMH_MIN_LOAD_FACTOR = 0.25f

staticconstexprprivate

Définition à la ligne 169 du fichier HashTableMap2.h.

◆ END

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::END = 0xFFFFFFFF

staticconstexpr

Définition à la ligne 182 du fichier HashTableMap2.h.

◆ INACTIVE

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

constexpr size_type Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::INACTIVE = 0xFFFFFFFF

staticconstexpr

Définition à la ligne 181 du fichier HashTableMap2.h.

◆ m_eq

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

EqT Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::m_eq

private

Définition à la ligne 1466 du fichier HashTableMap2.h.

◆ m_hasher

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

HashT Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::m_hasher

private

Définition à la ligne 1465 du fichier HashTableMap2.h.

◆ m_pairs

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

value_type* Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::m_pairs = nullptr

private

Définition à la ligne 1464 du fichier HashTableMap2.h.

◆ m_pairs_allocated_size

template<typename KeyT , typename ValueT , typename HashT = std::hash<KeyT>, typename EqT = std::equal_to<KeyT>>

Int64 Arcane::impl::HashTableMap2< KeyT, ValueT, HashT, EqT >::m_pairs_allocated_size = 0

private

Définition à la ligne 1467 du fichier HashTableMap2.h.

La documentation de cette classe a été générée à partir du fichier suivant :

HashTableMap2.h

Classes

Types publics

Fonctions membres publiques

Fonctions membres publiques statiques

Attributs publics statiques

Fonctions membres privées

Fonctions membres privées statiques

Attributs privés

Attributs privés statiques

Membres hérités additionnels

Description détaillée

Documentation des définitions de type membres

◆ hasher

◆ htype

◆ key_equal

◆ key_type

◆ mapped_type

◆ value_type

Documentation des constructeurs et destructeur

◆ HashTableMap2() [1/5]

◆ HashTableMap2() [2/5]

◆ HashTableMap2() [3/5]

◆ HashTableMap2() [4/5]

◆ HashTableMap2() [5/5]

◆ ~HashTableMap2()

Documentation des fonctions membres

◆ _allocBucket()

◆ _doInsert() [1/3]

◆ _doInsert() [2/3]

◆ _doInsert() [3/3]

◆ _findEmptyBucket()

◆ _findOrAllocate()

◆ _findUniqueBucket()

◆ _freeBuckets()

◆ add()

◆ at() [1/2]

◆ at() [2/2]

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ bucket_count()

◆ cbegin()

◆ cend()

◆ check_expand_need()

◆ clear()

◆ clearkv()

◆ clone()

◆ contains()

◆ count()

◆ do_assign()

◆ emplace()

◆ emplace_hint()

◆ emplace_unique()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range()

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ erase_bucket()

◆ erase_if()

◆ erase_slot()

◆ find() [1/2]

◆ find() [2/2]

◆ find_filled_bucket()

◆ find_filled_slot()

◆ find_last_bucket()

◆ find_prev_bucket()

◆ find_slot_bucket()

◆ first()

◆ front() [1/2]

◆ front() [2/2]

◆ get_or_return_default()

◆ hash_bucket()

◆ hash_function()

◆ hash_key() [1/3]

◆ hash_key() [2/3]

◆ hash_key() [3/3]