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

#include <arcane/utils/HashTableMap2.h>

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

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 166 du fichier HashTableMap2.h.