momo::stdish::unordered_multimap is similar to std::unordered_multimap, 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_multimap.h>

Public Types
typedef TKey	key_type

typedef TMapped	mapped_type

typedef THasher	hasher

typedef TEqualComparer	key_equal

typedef TAllocator	allocator_type

typedef HashMultiMap	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< typename HashMultiMap::Iterator, 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

Public Member Functions
	unordered_multimap ()

	unordered_multimap (const allocator_type &alloc)

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

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

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

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

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

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

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

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

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

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

	unordered_multimap (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_multimap (unordered_multimap &&right)

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

	unordered_multimap (const unordered_multimap &right)

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

	~unordered_multimap ()=default

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

unordered_multimap &	operator= (const unordered_multimap &right)

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

void	swap (unordered_multimap &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

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

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, iterator >	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, ValueArg &&valueArg)

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

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

iterator	emplace ()

iterator	emplace_hint (const_iterator)

template<typename ValueArg >
iterator	emplace (ValueArg &&valueArg)

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

template<typename KeyArg , typename MappedArg >
iterator	emplace (KeyArg &&keyArg, MappedArg &&mappedArg)

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

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

template<typename... KeyArgs, typename... MappedArgs>
iterator	emplace_hint (const_iterator, 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)

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

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

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

bool	operator!= (const unordered_multimap &left, const unordered_multimap &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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>
class momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >

momo::stdish::unordered_multimap is similar to std::unordered_multimap, 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_multimap:

Each of duplicate keys stored only once.
max_load_factor, rehash, reserve, load_factor and all the functions, associated with buckets or nodes, are not implemented.
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.
Functions erase can throw exceptions thrown by key_type and mapped_type move assignment operators.

It is allowed to pass to functions insert and emplace references to items within the container. But in case of the function insert, receiving pair of iterators, it's not allowed to pass iterators pointing to the 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TAllocator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef iterator::ConstIterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::const_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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef const_iterator::Pointer momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef const_iterator::Reference momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef ptrdiff_t momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef THasher momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::hasher

◆ 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef momo::internal::HashDerivedIterator<typename HashMultiMap::Iterator, momo::internal::MapReferenceStd> momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TEqualComparer momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TKey momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::key_type

◆ 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef TMapped momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef HashMultiMap momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::nested_container_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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef iterator::Pointer momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef iterator::Reference momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

typedef size_t momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

Constructor & Destructor Documentation

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::unordered_multimap ( )

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlineexplicit

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlineexplicit

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::unordered_multimap	(	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_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::unordered_multimap ( unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > && right )

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ unordered_multimap() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ ~unordered_multimap()

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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::~unordered_multimap ( )

default

Member Function Documentation

◆ begin() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

◆ begin() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::begin ( )

inlinenoexcept

◆ cbegin()

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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

◆ cend()

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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

◆ 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE bool momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, bool> momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE size_type momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, size_type> momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg , typename MappedArg >

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueArg >

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::emplace_hint ( const_iterator )

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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg , typename MappedArg >

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::emplace_hint	(	const_iterator	,
		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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::emplace_hint	(	const_iterator	,
		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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueArg >

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::emplace_hint	(	const_iterator	,
		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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

◆ end() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

◆ end() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::end ( )

inlinenoexcept

◆ 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE std::pair<iterator, iterator> momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE std::pair<const_iterator, const_iterator> momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<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_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<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_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::erase ( 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

MOMO_FORCEINLINE const_iterator momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, iterator> momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename KeyArg >

MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, const_iterator> momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

allocator_type momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

const nested_container_type& momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

nested_container_type& momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ insert() [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 THashMultiMap = HashMultiMap<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_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::insert	(	const_iterator	,
		ValueArg &&	valueArg
	)

inline

◆ insert() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename Iterator >

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

inline

◆ insert() [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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inline

◆ insert() [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 THashMultiMap = HashMultiMap<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_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::insert ( ValueArg && valueArg )

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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

◆ 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

unordered_multimap& momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::operator= ( const unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > & 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

unordered_multimap& momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

◆ 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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

size_type momo::stdish::unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap >::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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

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

inlinenoexcept

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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

template<typename ValueFilter >

size_type erase_if	(	unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > &	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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

bool operator!=	(	const unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > &	left,
		const unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > &	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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

bool operator==	(	const unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > &	left,
		const unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > &	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 THashMultiMap = HashMultiMap<TKey, TMapped, HashTraitsStd<TKey, THasher, TEqualComparer>, MemManagerStd<TAllocator>>>

void swap	(	unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > &	left,
		unordered_multimap< TKey, TMapped, THasher, TEqualComparer, TAllocator, THashMultiMap > &	right
	)

friend

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

include/momo/stdish/unordered_multimap.h

Public Types

Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ difference_type

◆ hasher

◆ iterator

◆ key_equal

◆ key_type

◆ mapped_type

◆ nested_container_type

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ unordered_multimap() [1/17]

◆ unordered_multimap() [2/17]

◆ unordered_multimap() [3/17]

◆ unordered_multimap() [4/17]

◆ unordered_multimap() [5/17]

◆ unordered_multimap() [6/17]

◆ unordered_multimap() [7/17]

◆ unordered_multimap() [8/17]

◆ unordered_multimap() [9/17]

◆ unordered_multimap() [10/17]

◆ unordered_multimap() [11/17]

◆ unordered_multimap() [12/17]

◆ unordered_multimap() [13/17]

◆ unordered_multimap() [14/17]

◆ unordered_multimap() [15/17]

◆ unordered_multimap() [16/17]

◆ unordered_multimap() [17/17]

◆ ~unordered_multimap()

Member Function Documentation

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ 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/2]

◆ end() [2/2]

◆ equal_range() [1/4]

◆ equal_range() [2/4]

◆ equal_range() [3/4]

◆ equal_range() [4/4]

◆ erase() [1/4]

◆ erase() [2/4]

◆ erase() [3/4]

◆ erase() [4/4]

◆ find() [1/4]

◆ find() [2/4]

◆ find() [3/4]

◆ find() [4/4]

◆ get_allocator()

◆ get_nested_container() [1/2]

◆ get_nested_container() [2/2]

◆ hash_function()

◆ insert() [1/4]

◆ insert() [2/4]

◆ insert() [3/4]

◆ insert() [4/4]