momo::stdish::unordered_map is similar to std::unordered_map, but much more efficient in memory usage. The implementation is based on hash table with buckets in the form of small arrays. More...

#include <unordered_map.h>

Public Types
typedef TKey	key_type

typedef TMapped	mapped_type

typedef THasher	hasher

typedef TEqualComparer	key_equal

typedef TAllocator	allocator_type

typedef HashMap	nested_container_type

typedef size_t	size_type

typedef ptrdiff_t	difference_type

typedef std::pair< const key_type, mapped_type >	value_type

typedef momo::internal::HashDerivedIterator< HashMapIterator, momo::internal::MapReferenceStd >	iterator

typedef iterator::ConstIterator	const_iterator

typedef iterator::Reference	reference

typedef const_iterator::Reference	const_reference

typedef iterator::Pointer	pointer

typedef const_iterator::Pointer	const_pointer

typedef internal::map_node_handle< typename HashMap::ExtractedPair >	node_type

typedef internal::insert_return_type< iterator, node_type >	insert_return_type

typedef momo::internal::HashDerivedIterator< typename HashMap::BucketBounds::Iterator, momo::internal::MapReferenceStd >	local_iterator

typedef local_iterator::ConstIterator	const_local_iterator

Public Member Functions
	unordered_map ()

	unordered_map (const allocator_type &alloc)

	unordered_map (size_type bucketCount, const allocator_type &alloc=allocator_type())

	unordered_map (size_type bucketCount, const hasher &hashFunc, const allocator_type &alloc=allocator_type())

	unordered_map (size_type bucketCount, const hasher &hashFunc, const key_equal &equalComp, const allocator_type &alloc=allocator_type())

template<typename Iterator >
	unordered_map (Iterator first, Iterator last)

template<typename Iterator >
	unordered_map (Iterator first, Iterator last, size_type bucketCount, const allocator_type &alloc=allocator_type())

template<typename Iterator >
	unordered_map (Iterator first, Iterator last, size_type bucketCount, const hasher &hashFunc, const allocator_type &alloc=allocator_type())

template<typename Iterator >
	unordered_map (Iterator first, Iterator last, size_type bucketCount, const hasher &hashFunc, const key_equal &equalComp, const allocator_type &alloc=allocator_type())

	unordered_map (std::initializer_list< momo::internal::Identity< value_type >> values)

	unordered_map (std::initializer_list< momo::internal::Identity< value_type >> values, size_type bucketCount, const allocator_type &alloc=allocator_type())

	unordered_map (std::initializer_list< momo::internal::Identity< value_type >> values, size_type bucketCount, const hasher &hashFunc, const allocator_type &alloc=allocator_type())

	unordered_map (std::initializer_list< momo::internal::Identity< value_type >> values, size_type bucketCount, const hasher &hashFunc, const key_equal &equalComp, const allocator_type &alloc=allocator_type())

	unordered_map (unordered_map &&right)

	unordered_map (unordered_map &&right, const momo::internal::Identity< allocator_type > &alloc)

	unordered_map (const unordered_map &right)

	unordered_map (const unordered_map &right, const momo::internal::Identity< allocator_type > &alloc)

	~unordered_map ()=default

unordered_map &	operator= (unordered_map &&right) noexcept(momo::internal::ContainerAssignerStd::IsNothrowMoveAssignable< unordered_map >::value)

unordered_map &	operator= (const unordered_map &right)

unordered_map &	operator= (std::initializer_list< value_type > values)

void	swap (unordered_map &right) noexcept

const nested_container_type &	get_nested_container () const noexcept

nested_container_type &	get_nested_container () noexcept

const_iterator	begin () const noexcept

iterator	begin () noexcept

const_iterator	end () const noexcept

iterator	end () noexcept

const_iterator	cbegin () const noexcept

const_iterator	cend () const noexcept

float	max_load_factor () const noexcept

void	max_load_factor (float maxLoadFactor)

hasher	hash_function () const

key_equal	key_eq () const

allocator_type	get_allocator () const noexcept

size_type	max_size () const noexcept

size_type	size () const noexcept

MOMO_NODISCARD bool	empty () const noexcept

void	clear () noexcept

void	rehash (size_type bucketCount)

void	reserve (size_type count)

MOMO_FORCEINLINE const_iterator	find (const key_type &key) const

MOMO_FORCEINLINE iterator	find (const key_type &key)

template<typename KeyArg >
MOMO_FORCEINLINE momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, const_iterator >	find (const KeyArg &key) const

template<typename KeyArg >
MOMO_FORCEINLINE momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, iterator >	find (const KeyArg &key)

MOMO_FORCEINLINE size_type	count (const key_type &key) const

template<typename KeyArg >
MOMO_FORCEINLINE momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, size_type >	count (const KeyArg &key) const

MOMO_FORCEINLINE bool	contains (const key_type &key) const

template<typename KeyArg >
MOMO_FORCEINLINE momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, bool >	contains (const KeyArg &key) const

MOMO_FORCEINLINE std::pair< const_iterator, const_iterator >	equal_range (const key_type &key) const

MOMO_FORCEINLINE std::pair< iterator, iterator >	equal_range (const key_type &key)

template<typename KeyArg >
MOMO_FORCEINLINE momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, std::pair< const_iterator, const_iterator > >	equal_range (const KeyArg &key) const

template<typename KeyArg >
MOMO_FORCEINLINE momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, std::pair< iterator, iterator > >	equal_range (const KeyArg &key)

template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf< std::is_constructible< value_type, ValueArg && >::value, std::pair< iterator, bool > >	insert (ValueArg &&valueArg)

template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf< std::is_constructible< value_type, ValueArg && >::value, iterator >	insert (const_iterator hint, ValueArg &&valueArg)

insert_return_type	insert (node_type &&node)

iterator	insert (const_iterator hint, node_type &&node)

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

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

std::pair< iterator, bool >	emplace ()

iterator	emplace_hint (const_iterator hint)

template<typename ValueArg >
std::pair< iterator, bool >	emplace (ValueArg &&valueArg)

template<typename ValueArg >
iterator	emplace_hint (const_iterator hint, ValueArg &&valueArg)

template<typename KeyArg , typename MappedArg >
std::pair< iterator, bool >	emplace (KeyArg &&keyArg, MappedArg &&mappedArg)

template<typename KeyArg , typename MappedArg >
iterator	emplace_hint (const_iterator hint, KeyArg &&keyArg, MappedArg &&mappedArg)

template<typename... KeyArgs, typename... MappedArgs>
std::pair< iterator, bool >	emplace (std::piecewise_construct_t, std::tuple< KeyArgs... > keyArgs, std::tuple< MappedArgs... > mappedArgs)

template<typename... KeyArgs, typename... MappedArgs>
iterator	emplace_hint (const_iterator hint, std::piecewise_construct_t, std::tuple< KeyArgs... > keyArgs, std::tuple< MappedArgs... > mappedArgs)

iterator	erase (const_iterator where)

iterator	erase (iterator where)

iterator	erase (const_iterator first, const_iterator last)

size_type	erase (const key_type &key)

MOMO_FORCEINLINE HashMap::ValueReferenceRKey	operator[] (key_type &&key)

MOMO_FORCEINLINE HashMap::ValueReferenceCKey	operator[] (const key_type &key)

MOMO_FORCEINLINE const mapped_type &	at (const key_type &key) const

MOMO_FORCEINLINE mapped_type &	at (const key_type &key)

template<typename... MappedArgs>
std::pair< iterator, bool >	try_emplace (key_type &&key, MappedArgs &&... mappedArgs)

template<typename... MappedArgs>
iterator	try_emplace (const_iterator hint, key_type &&key, MappedArgs &&... mappedArgs)

template<typename... MappedArgs>
std::pair< iterator, bool >	try_emplace (const key_type &key, MappedArgs &&... mappedArgs)

template<typename... MappedArgs>
iterator	try_emplace (const_iterator hint, const key_type &key, MappedArgs &&... mappedArgs)

template<typename MappedArg >
std::pair< iterator, bool >	insert_or_assign (key_type &&key, MappedArg &&mappedArg)

template<typename MappedArg >
iterator	insert_or_assign (const_iterator hint, key_type &&key, MappedArg &&mappedArg)

template<typename MappedArg >
std::pair< iterator, bool >	insert_or_assign (const key_type &key, MappedArg &&mappedArg)

template<typename MappedArg >
iterator	insert_or_assign (const_iterator hint, const key_type &key, MappedArg &&mappedArg)

node_type	extract (const_iterator where)

node_type	extract (const key_type &key)

template<typename Map >
void	merge (Map &&map)

size_type	max_bucket_count () const noexcept

size_type	bucket_count () const noexcept

size_type	bucket_size (size_type bucketIndex) const

local_iterator	begin (size_type bucketIndex)

const_local_iterator	begin (size_type bucketIndex) const

local_iterator	end (size_type bucketIndex)

const_local_iterator	end (size_type bucketIndex) const

const_local_iterator	cbegin (size_type bucketIndex) const

const_local_iterator	cend (size_type bucketIndex) const

size_type	bucket (const key_type &key) const

float	load_factor () const noexcept

Friends
void	swap (unordered_map &left, unordered_map &right) noexcept

template<typename ValueFilter >
size_type	erase_if (unordered_map &cont, const ValueFilter &valueFilter)

bool	operator== (const unordered_map &left, const unordered_map &right)

bool	operator!= (const unordered_map &left, const unordered_map &right)

Detailed Description

template<typename TKey, typename TMapped, typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>
class momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >

momo::stdish::unordered_map is similar to std::unordered_map, but much more efficient in memory usage. The implementation is based on hash table with buckets in the form of small arrays.

Deviations from the std::unordered_map:

Container items must be movable (preferably without exceptions) or copyable, similar to items of std::vector.
After each addition or removal of the item all iterators and references to items become invalid and should not be used.
Type reference is not the same as value_type&, so for (auto& p : map) is illegal, but for (auto p : map) or for (const auto& p : map) or for (auto&& p : map) is allowed.
Functions clear, begin, cbegin and iterator increment take O(bucket_count) time in worst case.
If ObjectManager<key_type>::isNothrowAnywayAssignable is false or ObjectManager<mapped_type>::isNothrowAnywayAssignable is false, functions erase can throw exceptions.
Functions merge, extract and insert(node_type&&) move items.

It is allowed to pass to functions insert and emplace references to items within the container.

Member Typedef Documentation

◆ allocator_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TAllocator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::allocator_type

◆ const_iterator

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef iterator::ConstIterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::const_iterator

◆ const_local_iterator

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef local_iterator::ConstIterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::const_local_iterator

◆ const_pointer

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef const_iterator::Pointer momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::const_pointer

◆ const_reference

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef const_iterator::Reference momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::const_reference

◆ difference_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef ptrdiff_t momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::difference_type

◆ hasher

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef THasher momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::hasher

◆ insert_return_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef internal::insert_return_type<iterator, node_type> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert_return_type

◆ iterator

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef momo::internal::HashDerivedIterator<HashMapIterator, momo::internal::MapReferenceStd> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::iterator

◆ key_equal

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TEqualComparer momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::key_equal

◆ key_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TKey momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::key_type

◆ local_iterator

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef momo::internal::HashDerivedIterator<typename HashMap::BucketBounds::Iterator, momo::internal::MapReferenceStd> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::local_iterator

◆ mapped_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TMapped momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::mapped_type

◆ nested_container_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef HashMap momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::nested_container_type

◆ node_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef internal::map_node_handle<typename HashMap::ExtractedPair> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::node_type

◆ pointer

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef iterator::Pointer momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::pointer

◆ reference

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef iterator::Reference momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::reference

◆ size_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef size_t momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::size_type

◆ value_type

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef std::pair<const key_type, mapped_type> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::value_type

Constructor & Destructor Documentation

◆ unordered_map() [1/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map ( )

inline

◆ unordered_map() [2/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map ( const allocator_type & alloc )

inlineexplicit

◆ unordered_map() [3/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	size_type	bucketCount,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineexplicit

◆ unordered_map() [4/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	size_type	bucketCount,
		const hasher &	hashFunc,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [5/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	size_type	bucketCount,
		const hasher &	hashFunc,
		const key_equal &	equalComp,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [6/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	Iterator	first,
		Iterator	last
	)

inline

◆ unordered_map() [7/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	Iterator	first,
		Iterator	last,
		size_type	bucketCount,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [8/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	Iterator	first,
		Iterator	last,
		size_type	bucketCount,
		const hasher &	hashFunc,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [9/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	Iterator	first,
		Iterator	last,
		size_type	bucketCount,
		const hasher &	hashFunc,
		const key_equal &	equalComp,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [10/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map ( std::initializer_list< momo::internal::Identity< value_type >> values )

inline

◆ unordered_map() [11/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	std::initializer_list< momo::internal::Identity< value_type >>	values,
		size_type	bucketCount,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [12/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	std::initializer_list< momo::internal::Identity< value_type >>	values,
		size_type	bucketCount,
		const hasher &	hashFunc,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [13/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	std::initializer_list< momo::internal::Identity< value_type >>	values,
		size_type	bucketCount,
		const hasher &	hashFunc,
		const key_equal &	equalComp,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

◆ unordered_map() [14/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map ( unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > && right )

inline

◆ unordered_map() [15/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &&	right,
		const momo::internal::Identity< allocator_type > &	alloc
	)

inline

◆ unordered_map() [16/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map ( const unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > & right )

inline

◆ unordered_map() [17/17]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::unordered_map	(	const unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	right,
		const momo::internal::Identity< allocator_type > &	alloc
	)

inline

◆ ~unordered_map()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::~unordered_map ( )

default

Member Function Documentation

◆ at() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE mapped_type& momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::at ( const key_type & key )

inline

◆ at() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE const mapped_type& momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::at ( const key_type & key ) const

inline

◆ begin() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::begin ( ) const

inlinenoexcept

◆ begin() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::begin ( )

inlinenoexcept

◆ begin() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

local_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::begin ( size_type bucketIndex )

inline

◆ begin() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_local_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::begin ( size_type bucketIndex ) const

inline

◆ bucket()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::bucket ( const key_type & key ) const

inline

◆ bucket_count()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::bucket_count ( ) const

inlinenoexcept

◆ bucket_size()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::bucket_size ( size_type bucketIndex ) const

inline

◆ cbegin() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::cbegin ( ) const

inlinenoexcept

◆ cbegin() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_local_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::cbegin ( size_type bucketIndex ) const

inline

◆ cend() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::cend ( ) const

inlinenoexcept

◆ cend() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_local_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::cend ( size_type bucketIndex ) const

inline

◆ clear()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::clear ( )

inlinenoexcept

◆ contains() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE bool momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::contains ( const key_type & key ) const

inline

◆ contains() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::contains ( const KeyArg & key ) const

inline

◆ count() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::count ( const key_type & key ) const

inline

◆ count() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, size_type> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::count ( const KeyArg & key ) const

inline

◆ emplace() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace ( )

inline

◆ emplace() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg , typename MappedArg >

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace	(	KeyArg &&	keyArg,
		MappedArg &&	mappedArg
	)

inline

◆ emplace() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename... KeyArgs, typename... MappedArgs>

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace	(	std::piecewise_construct_t	,
		std::tuple< KeyArgs... >	keyArgs,
		std::tuple< MappedArgs... >	mappedArgs
	)

inline

◆ emplace() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueArg >

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace ( ValueArg && valueArg )

inline

◆ emplace_hint() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace_hint ( const_iterator hint )

inline

◆ emplace_hint() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg , typename MappedArg >

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace_hint	(	const_iterator	hint,
		KeyArg &&	keyArg,
		MappedArg &&	mappedArg
	)

inline

◆ emplace_hint() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename... KeyArgs, typename... MappedArgs>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace_hint	(	const_iterator	hint,
		std::piecewise_construct_t	,
		std::tuple< KeyArgs... >	keyArgs,
		std::tuple< MappedArgs... >	mappedArgs
	)

inline

◆ emplace_hint() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueArg >

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::emplace_hint	(	const_iterator	hint,
		ValueArg &&	valueArg
	)

inline

◆ empty()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_NODISCARD bool momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::empty ( ) const

inlinenoexcept

◆ end() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::end ( ) const

inlinenoexcept

◆ end() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::end ( )

inlinenoexcept

◆ end() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

local_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::end ( size_type bucketIndex )

inline

◆ end() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const_local_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::end ( size_type bucketIndex ) const

inline

◆ equal_range() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE std::pair<iterator, iterator> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::equal_range ( const key_type & key )

inline

◆ equal_range() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE std::pair<const_iterator, const_iterator> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::equal_range ( const key_type & key ) const

inline

◆ equal_range() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, std::pair<iterator, iterator> > momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::equal_range ( const KeyArg & key )

inline

◆ equal_range() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, std::pair<const_iterator, const_iterator> > momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::equal_range ( const KeyArg & key ) const

inline

◆ erase() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::erase ( const key_type & key )

inline

◆ erase() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::erase	(	const_iterator	first,
		const_iterator	last
	)

inline

◆ erase() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::erase ( const_iterator where )

inline

◆ erase() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::erase ( iterator where )

inline

◆ extract() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

node_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::extract ( const key_type & key )

inline

◆ extract() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

node_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::extract ( const_iterator where )

inline

◆ find() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::find ( const key_type & key )

inline

◆ find() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE const_iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::find ( const key_type & key ) const

inline

◆ find() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, iterator> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::find ( const KeyArg & key )

inline

◆ find() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, const_iterator> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::find ( const KeyArg & key ) const

inline

◆ get_allocator()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

allocator_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::get_allocator ( ) const

inlinenoexcept

◆ get_nested_container() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const nested_container_type& momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::get_nested_container ( ) const

inlinenoexcept

◆ get_nested_container() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

nested_container_type& momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::get_nested_container ( )

inlinenoexcept

◆ hash_function()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

hasher momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::hash_function ( ) const

inline

◆ insert() [1/6]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert	(	const_iterator	hint,
		node_type &&	node
	)

inline

◆ insert() [2/6]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueArg = std::pair<key_type, mapped_type>>

momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value, iterator> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert	(	const_iterator	hint,
		ValueArg &&	valueArg
	)

inline

◆ insert() [3/6]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert	(	Iterator	first,
		Iterator	last
	)

inline

◆ insert() [4/6]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

insert_return_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert ( node_type && node )

inline

◆ insert() [5/6]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert ( std::initializer_list< value_type > values )

inline

◆ insert() [6/6]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueArg = std::pair<key_type, mapped_type>>

momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value, std::pair<iterator, bool> > momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert ( ValueArg && valueArg )

inline

◆ insert_or_assign() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename MappedArg >

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert_or_assign	(	const key_type &	key,
		MappedArg &&	mappedArg
	)

inline

◆ insert_or_assign() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename MappedArg >

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert_or_assign	(	const_iterator	hint,
		const key_type &	key,
		MappedArg &&	mappedArg
	)

inline

◆ insert_or_assign() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename MappedArg >

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert_or_assign	(	const_iterator	hint,
		key_type &&	key,
		MappedArg &&	mappedArg
	)

inline

◆ insert_or_assign() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename MappedArg >

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::insert_or_assign	(	key_type &&	key,
		MappedArg &&	mappedArg
	)

inline

◆ key_eq()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

key_equal momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::key_eq ( ) const

inline

◆ load_factor()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

float momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::load_factor ( ) const

inlinenoexcept

◆ max_bucket_count()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::max_bucket_count ( ) const

inlinenoexcept

◆ max_load_factor() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

float momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::max_load_factor ( ) const

inlinenoexcept

◆ max_load_factor() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::max_load_factor ( float maxLoadFactor )

inline

◆ max_size()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::max_size ( ) const

inlinenoexcept

◆ merge()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Map >

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::merge ( Map && map )

inline

◆ operator=() [1/3]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

unordered_map& momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::operator= ( const unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > & right )

inline

◆ operator=() [2/3]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

unordered_map& momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::operator= ( std::initializer_list< value_type > values )

inline

◆ operator=() [3/3]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

unordered_map& momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::operator= ( unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > && right )

inlinenoexcept

◆ operator[]() [1/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE HashMap::ValueReferenceCKey momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::operator[] ( const key_type & key )

inline

◆ operator[]() [2/2]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE HashMap::ValueReferenceRKey momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::operator[] ( key_type && key )

inline

◆ rehash()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::rehash ( size_type bucketCount )

inline

◆ reserve()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::reserve ( size_type count )

inline

◆ size()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::size ( ) const

inlinenoexcept

◆ swap()

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::swap ( unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > & right )

inlinenoexcept

◆ try_emplace() [1/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename... MappedArgs>

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::try_emplace	(	const key_type &	key,
		MappedArgs &&...	mappedArgs
	)

inline

◆ try_emplace() [2/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename... MappedArgs>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::try_emplace	(	const_iterator	hint,
		const key_type &	key,
		MappedArgs &&...	mappedArgs
	)

inline

◆ try_emplace() [3/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename... MappedArgs>

iterator momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::try_emplace	(	const_iterator	hint,
		key_type &&	key,
		MappedArgs &&...	mappedArgs
	)

inline

◆ try_emplace() [4/4]

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename... MappedArgs>

std::pair<iterator, bool> momo::stdish::unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap >::try_emplace	(	key_type &&	key,
		MappedArgs &&...	mappedArgs
	)

inline

Friends And Related Function Documentation

◆ erase_if

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueFilter >

size_type erase_if	(	unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	cont,
		const ValueFilter &	valueFilter
	)

friend

◆ operator!=

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

bool operator!=	(	const unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	left,
		const unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	right
	)

friend

◆ operator==

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

bool operator==	(	const unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	left,
		const unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	right
	)

friend

◆ swap

template<typename TKey , typename TMapped , typename THasher = HashCoder<TKey>, typename TEqualComparer = std::equal_to<TKey>, typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>, typename THashMap = HashMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void swap	(	unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	left,
		unordered_map< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMap > &	right
	)

friend

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

include/momo/stdish/unordered_map.h

Public Types

Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_local_iterator

◆ const_pointer

◆ const_reference

◆ difference_type

◆ hasher

◆ insert_return_type

◆ iterator

◆ key_equal

◆ key_type

◆ local_iterator

◆ mapped_type

◆ nested_container_type

◆ node_type

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ unordered_map() [1/17]

◆ unordered_map() [2/17]

◆ unordered_map() [3/17]

◆ unordered_map() [4/17]

◆ unordered_map() [5/17]

◆ unordered_map() [6/17]

◆ unordered_map() [7/17]

◆ unordered_map() [8/17]

◆ unordered_map() [9/17]

◆ unordered_map() [10/17]

◆ unordered_map() [11/17]

◆ unordered_map() [12/17]

◆ unordered_map() [13/17]

◆ unordered_map() [14/17]

◆ unordered_map() [15/17]

◆ unordered_map() [16/17]

◆ unordered_map() [17/17]

◆ ~unordered_map()

Member Function Documentation

◆ at() [1/2]

◆ at() [2/2]

◆ begin() [1/4]

◆ begin() [2/4]

◆ begin() [3/4]

◆ begin() [4/4]

◆ bucket()

◆ bucket_count()

◆ bucket_size()

◆ cbegin() [1/2]

◆ cbegin() [2/2]

◆ cend() [1/2]

◆ cend() [2/2]

◆ clear()

◆ contains() [1/2]

◆ contains() [2/2]

◆ count() [1/2]

◆ count() [2/2]

◆ emplace() [1/4]

◆ emplace() [2/4]

◆ emplace() [3/4]

◆ emplace() [4/4]

◆ emplace_hint() [1/4]

◆ emplace_hint() [2/4]

◆ emplace_hint() [3/4]

◆ emplace_hint() [4/4]

◆ empty()

◆ end() [1/4]

◆ end() [2/4]

◆ end() [3/4]

◆ end() [4/4]

◆ equal_range() [1/4]

◆ equal_range() [2/4]

◆ equal_range() [3/4]

◆ equal_range() [4/4]

◆ erase() [1/4]