#include <bn_unordered_map.h>
template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bn::iunordered_map class

Base class of bn::unordered_map.

Template parameters
Key Key type.
Value Value type.
KeyHash Functor used to calculate the hash of a given key.
KeyEqual Functor used for all key comparisons.

Can be used as a reference type for all bn::unordered_map containers containing a specific type.

Unlike std::unordered_map, it doesn't offer pointer stability when moving or erasing elements.

Derived classes

template<typename Key, typename Value, int MaxSize, typename KeyHash, typename KeyEqual>
class unordered_map
std::unordered_map like container with a fixed size buffer.

Public types

class const_iterator
Const iterator.
class iterator
Non const iterator.
using key_type = Key
Key type alias.
using mapped_type = Value
Value type alias.
using value_type = pair<const key_type, mapped_type>
(Key, Value) pair type alias.
using size_type = int
Size type alias.
using difference_type = int
Difference type alias.
using hash_type = unsigned
Hash type alias.
using hasher = KeyHash
Hash functor alias.
using key_equal = KeyEqual
Equality functor alias.
using reference = value_type&
(Key, Value) pair reference alias.
using const_reference = const value_type&
(Key, Value) pair const reference alias.
using pointer = value_type*
(Key, Value) pair pointer alias.
using const_pointer = const value_type*
(Key, Value) pair const pointer alias.
using reverse_iterator = bn::reverse_iterator<iterator>
Reverse iterator alias.
using const_reverse_iterator = bn::reverse_iterator<const_iterator>
Const reverse iterator alias.

Constructors, destructors, conversion operators

~iunordered_map() defaulted noexcept
Destructor.
~iunordered_map()
Destructor.

Public functions

auto operator=(const iunordered_map& other) -> iunordered_map&
Copy assignment operator.
auto operator=(iunordered_map&& other) -> iunordered_map& noexcept
Move assignment operator.
auto size() const -> size_type
Returns the current size.
auto max_size() const -> size_type
Returns the maximum possible size.
auto available() const -> size_type
Returns the remaining capacity.
auto empty() const -> bool
Indicates if it doesn't contain any element.
auto full() const -> bool
Indicates if it can't contain any more elements.
auto begin() const -> const_iterator
Returns a const iterator to the beginning of the iunordered_map.
auto begin() -> iterator
Returns an iterator to the beginning of the iunordered_map.
auto end() const -> const_iterator
Returns a const iterator to the end of the iunordered_map.
auto end() -> iterator
Returns an iterator to the end of the iunordered_map.
auto cbegin() const -> const_iterator
Returns a const iterator to the beginning of the iunordered_map.
auto cend() const -> const_iterator
Returns a const iterator to the end of the iunordered_map.
auto rbegin() const -> const_reverse_iterator
Returns a const reverse iterator to the end of the iunordered_map.
auto rbegin() -> reverse_iterator
Returns a reverse iterator to the end of the iunordered_map.
auto rend() const -> const_reverse_iterator
Returns a const reverse iterator to the beginning of the iunordered_map.
auto rend() -> reverse_iterator
Returns a reverse iterator to the beginning of the iunordered_map.
auto crbegin() const -> const_reverse_iterator
Returns a const reverse iterator to the end of the iunordered_map.
auto crend() const -> const_reverse_iterator
Returns a const reverse iterator to the beginning of the iunordered_map.
auto contains(const key_type& key) const -> bool
Indicates if the specified key is contained in this iunordered_map.
auto contains_hash(hash_type key_hash, const key_type& key) const -> bool
Indicates if the specified key is contained in this iunordered_map.
auto count(const key_type& key) const -> size_type
Counts the number of keys stored in this iunordered_map are equal to the given one.
auto count_hash(hash_type key_hash, const key_type& key) const -> size_type
Counts the number of keys stored in this iunordered_map are equal to the given one.
auto find(const key_type& key) const -> const_iterator
Searches for a given key.
auto find(const key_type& key) -> iterator
Searches for a given key.
auto find_hash(hash_type key_hash, const key_type& key) const -> const_iterator
Searches for a given key.
auto find_hash(hash_type key_hash, const key_type& key) -> iterator
Searches for a given key.
auto at(const key_type& key) const -> const mapped_type&
Searches for a given key.
auto at(const key_type& key) -> mapped_type&
Searches for a given key.
auto at_hash(hash_type key_hash, const key_type& key) const -> const mapped_type&
Searches for a given key.
auto at_hash(hash_type key_hash, const key_type& key) -> mapped_type&
Searches for a given key.
auto insert(const value_type& value) -> iterator
Inserts a copy of the given (Key, Value) pair.
auto insert(value_type&& value) -> iterator
Inserts a moved (Key, Value) pair.
auto insert(const key_type& key, const mapped_type& mapped_value) -> iterator
Inserts a copy of the given (Key, Value) pair.
auto insert(const key_type& key, mapped_type&& mapped_value) -> iterator
Inserts a moved (Key, Value) pair.
auto insert_hash(hash_type key_hash, const value_type& value) -> iterator
Inserts a copy of the given (Key, Value) pair.
auto insert_hash(hash_type key_hash, value_type&& value) -> iterator
Inserts a moved (Key, Value) pair.
auto insert_hash(hash_type key_hash, const key_type& key, const mapped_type& mapped_value) -> iterator
Inserts a copy of the given (Key, Value) pair.
auto insert_hash(hash_type key_hash, const key_type& key, mapped_type&& mapped_value) -> iterator
Inserts a moved (Key, Value) pair.
auto insert_or_assign(const value_type& value) -> iterator
Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.
auto insert_or_assign(value_type&& value) -> iterator
Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.
auto insert_or_assign(const key_type& key, const mapped_type& mapped_value) -> iterator
Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.
auto insert_or_assign(const key_type& key, mapped_type&& mapped_value) -> iterator
Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.
auto insert_or_assign_hash(hash_type key_hash, const value_type& value) -> iterator
Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.
auto insert_or_assign_hash(hash_type key_hash, value_type&& value) -> iterator
Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.
auto insert_or_assign_hash(hash_type key_hash, const key_type& key, const mapped_type& mapped_value) -> iterator
Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.
auto insert_or_assign_hash(hash_type key_hash, const key_type& key, mapped_type&& mapped_value) -> iterator
Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.
template<typename... Args>
auto try_emplace(const key_type& key, Args && ... args) -> iterator
Inserts in-place a (Key, Value) pair if the given key does not exist.
template<typename... Args>
auto try_emplace_hash(hash_type key_hash, const key_type& key, Args && ... args) -> iterator
Inserts in-place a (Key, Value) pair if the given key does not exist.
auto erase(const const_iterator& position) -> iterator
Erases an element.
auto erase(const key_type& key) -> bool
Erases an element.
auto erase_hash(hash_type key_hash, const key_type& key) -> bool
Erases an element.
template<class Pred>
auto erase_if(const Pred& pred) -> size_type
Erases all elements that satisfy the specified predicate.
void merge(iunordered_map&& other) noexcept
Moves all elements of the given iunordered_map into this one, leaving the first one empty.
void clear()
Removes all elements.
void clear()
Removes all elements.
auto operator[](const key_type& key) -> mapped_type&
Returns a reference to the value that is mapped to the given key, performing an insertion if such key does not already exist.
auto operator()(const key_type& key) -> mapped_type&
Returns a reference to the value that is mapped to the given key, performing an insertion if such key does not already exist.
auto operator()(hash_type key_hash, const key_type& key) -> mapped_type&
Returns a reference to the value that is mapped to the given key, performing an insertion if such key does not already exist.
void swap(iunordered_map& other)
Exchanges the contents of this iunordered_map with those of the other one.
auto operator!=(const iunordered_map& a, const iunordered_map& b) -> bool f
Not equal operator.

Friends

void swap(iunordered_map& a, iunordered_map& b)
Exchanges the contents of a iunordered_map with those of another one.
auto operator==(const iunordered_map& a, const iunordered_map& b) -> bool
Equal operator.
auto operator<(const iunordered_map& a, const iunordered_map& b) -> bool
Less than operator.
auto operator>(const iunordered_map& a, const iunordered_map& b) -> bool
Greater than operator.
auto operator<=(const iunordered_map& a, const iunordered_map& b) -> bool
Less than or equal operator.
auto operator>=(const iunordered_map& a, const iunordered_map& b) -> bool
Greater than or equal operator.

Function documentation

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iunordered_map& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::operator=(const iunordered_map& other)

Copy assignment operator.

Parameters
other iunordered_map to copy.
Returns Reference to this.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iunordered_map& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::operator=(iunordered_map&& other) noexcept

Move assignment operator.

Parameters
other iunordered_map to move.
Returns Reference to this.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::contains(const key_type& key) const

Indicates if the specified key is contained in this iunordered_map.

Parameters
key Key to search for.
Returns true if the specified key is contained in this iunordered_map, otherwise false.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::contains_hash(hash_type key_hash, const key_type& key) const

Indicates if the specified key is contained in this iunordered_map.

Parameters
key_hash Hash of the given key to search for.
key Key to search for.
Returns true if the specified key is contained in this iunordered_map, otherwise false.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
size_type bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::count(const key_type& key) const

Counts the number of keys stored in this iunordered_map are equal to the given one.

Parameters
key Key to search for.
Returns 1 if the specified key is contained in this iunordered_map, otherwise 0.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
size_type bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::count_hash(hash_type key_hash, const key_type& key) const

Counts the number of keys stored in this iunordered_map are equal to the given one.

Parameters
key_hash Hash of the given key to search for.
key Key to search for.
Returns 1 if the specified key is contained in this iunordered_map, otherwise 0.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
const_iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::find(const key_type& key) const

Searches for a given key.

Parameters
key Key to search for.
Returns Const iterator to the (Key, Value) pair if it exists, otherwise end().

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::find(const key_type& key)

Searches for a given key.

Parameters
key Key to search for.
Returns Iterator to the (Key, Value) pair if it exists, otherwise end().

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
const_iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::find_hash(hash_type key_hash, const key_type& key) const

Searches for a given key.

Parameters
key_hash Hash of the given key to search for.
key Key to search for.
Returns Const iterator to the (Key, Value) pair if it exists, otherwise end().

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::find_hash(hash_type key_hash, const key_type& key)

Searches for a given key.

Parameters
key_hash Hash of the given key to search for.
key Key to search for.
Returns Iterator to the (Key, Value) pair if it exists, otherwise end().

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
const mapped_type& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::at(const key_type& key) const

Searches for a given key.

Parameters
key Key to search for.
Returns Const reference to the value stored with the specified key.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
mapped_type& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::at(const key_type& key)

Searches for a given key.

Parameters
key Key to search for.
Returns Reference to the value stored with the specified key.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
const mapped_type& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::at_hash(hash_type key_hash, const key_type& key) const

Searches for a given key.

Parameters
key_hash Hash of the given key to search for.
key Key to search for.
Returns Const reference to the value stored with the specified key.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
mapped_type& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::at_hash(hash_type key_hash, const key_type& key)

Searches for a given key.

Parameters
key_hash Hash of the given key to search for.
key Key to search for.
Returns Reference to the value stored with the specified key.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert(const value_type& value)

Inserts a copy of the given (Key, Value) pair.

Parameters
value (Key, Value) pair to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert(value_type&& value)

Inserts a moved (Key, Value) pair.

Parameters
value (Key, Value) pair to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert(const key_type& key, const mapped_type& mapped_value)

Inserts a copy of the given (Key, Value) pair.

Parameters
key Key to insert.
mapped_value Value to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert(const key_type& key, mapped_type&& mapped_value)

Inserts a moved (Key, Value) pair.

Parameters
key Key to insert.
mapped_value Value to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_hash(hash_type key_hash, const value_type& value)

Inserts a copy of the given (Key, Value) pair.

Parameters
key_hash Hash of the key to insert.
value (Key, Value) pair to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_hash(hash_type key_hash, value_type&& value)

Inserts a moved (Key, Value) pair.

Parameters
key_hash Hash of the key to insert.
value (Key, Value) pair to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_hash(hash_type key_hash, const key_type& key, const mapped_type& mapped_value)

Inserts a copy of the given (Key, Value) pair.

Parameters
key_hash Hash of the key to insert.
key Key to insert.
mapped_value Value to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_hash(hash_type key_hash, const key_type& key, mapped_type&& mapped_value)

Inserts a moved (Key, Value) pair.

Parameters
key_hash Hash of the key to insert.
key Key to insert.
mapped_value Value to insert.
Returns Iterator pointing to the inserted (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign(const value_type& value)

Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
value (Key, Value) pair to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign(value_type&& value)

Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
value (Key, Value) pair to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign(const key_type& key, const mapped_type& mapped_value)

Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
key Key to insert or assign.
mapped_value Value to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign(const key_type& key, mapped_type&& mapped_value)

Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
key Key to insert or assign.
mapped_value Value to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign_hash(hash_type key_hash, const value_type& value)

Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
key_hash Hash of the key to insert or assign.
value (Key, Value) pair to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign_hash(hash_type key_hash, value_type&& value)

Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
key_hash Hash of the key to insert or assign.
value (Key, Value) pair to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign_hash(hash_type key_hash, const key_type& key, const mapped_type& mapped_value)

Inserts a copy of the given (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
key_hash Hash of the key to insert or assign.
key Key to insert or assign.
mapped_value Value to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::insert_or_assign_hash(hash_type key_hash, const key_type& key, mapped_type&& mapped_value)

Inserts a moved (Key, Value) pair or replaces the value with the given one if the key is found.

Parameters
key_hash Hash of the key to insert or assign.
key Key to insert or assign.
mapped_value Value to insert or assign.
Returns Iterator pointing to the inserted or assigned (Key, Value) pair.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual> template<typename... Args>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::try_emplace(const key_type& key, Args && ... args)

Inserts in-place a (Key, Value) pair if the given key does not exist.

Parameters
key Key to insert.
args Parameters of the value to insert.
Returns Iterator pointing to the inserted (Key, Value) pair if the key does not exist, otherwise end().

template<typename Key, typename Value, typename KeyHash, typename KeyEqual> template<typename... Args>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::try_emplace_hash(hash_type key_hash, const key_type& key, Args && ... args)

Inserts in-place a (Key, Value) pair if the given key does not exist.

Parameters
key_hash Hash of the key to insert.
key Key to insert.
args Parameters of the value to insert.
Returns Iterator pointing to the inserted (Key, Value) pair if the key does not exist, otherwise end().

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
iterator bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::erase(const const_iterator& position)

Erases an element.

Parameters
position Iterator to the element to erase.
Returns Iterator following the erased element.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::erase(const key_type& key)

Erases an element.

Parameters
key Key to erase.
Returns true if the elements was erased, otherwise false.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::erase_hash(hash_type key_hash, const key_type& key)

Erases an element.

Parameters
key_hash Hash of the key to erase.
key Key to erase.
Returns true if the elements was erased, otherwise false.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual> template<class Pred>
size_type bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::erase_if(const Pred& pred)

Erases all elements that satisfy the specified predicate.

Parameters
pred Unary predicate which returns ​true if the element should be erased.
Returns Number of erased elements.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
void bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::merge(iunordered_map&& other) noexcept

Moves all elements of the given iunordered_map into this one, leaving the first one empty.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
mapped_type& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::operator[](const key_type& key)

Returns a reference to the value that is mapped to the given key, performing an insertion if such key does not already exist.

Parameters
key Key to search for.
Returns Reference to the value that is mapped to the given key.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
mapped_type& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::operator()(const key_type& key)

Returns a reference to the value that is mapped to the given key, performing an insertion if such key does not already exist.

Parameters
key Key to search for.
Returns Reference to the value that is mapped to the given key.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
mapped_type& bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::operator()(hash_type key_hash, const key_type& key)

Returns a reference to the value that is mapped to the given key, performing an insertion if such key does not already exist.

Parameters
key_hash Hash of the key to search for.
key Key to search for.
Returns Reference to the value that is mapped to the given key.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
void bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::swap(iunordered_map& other)

Exchanges the contents of this iunordered_map with those of the other one.

Parameters
other iunordered_map to exchange the contents with.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool f bn::iunordered_map<Key, Value, KeyHash, KeyEqual>::operator!=(const iunordered_map& a, const iunordered_map& b)

Not equal operator.

Parameters
a First iunordered_map to compare.
b Second iunordered_map to compare.
Returns true if the first iunordered_map is not equal to the second one, otherwise false.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
void swap(iunordered_map& a, iunordered_map& b)

Exchanges the contents of a iunordered_map with those of another one.

Parameters
a First iunordered_map to exchange the contents with.
b Second iunordered_map to exchange the contents with.

Unlike std::unordered_map, it doesn't offer pointer stability.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool operator==(const iunordered_map& a, const iunordered_map& b)

Equal operator.

Parameters
a First iunordered_map to compare.
b Second iunordered_map to compare.
Returns true if the first iunordered_map is equal to the second one, otherwise false.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool operator<(const iunordered_map& a, const iunordered_map& b)

Less than operator.

Parameters
a First iunordered_map to compare.
b Second iunordered_map to compare.
Returns true if the first iunordered_map is lexicographically less than the second one, otherwise false.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool operator>(const iunordered_map& a, const iunordered_map& b)

Greater than operator.

Parameters
a First iunordered_map to compare.
b Second iunordered_map to compare.
Returns true if the first iunordered_map is lexicographically greater than the second one, otherwise false.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool operator<=(const iunordered_map& a, const iunordered_map& b)

Less than or equal operator.

Parameters
a First iunordered_map to compare.
b Second iunordered_map to compare.
Returns true if the first iunordered_map is lexicographically less than or equal to the second one, otherwise false.

template<typename Key, typename Value, typename KeyHash, typename KeyEqual>
bool operator>=(const iunordered_map& a, const iunordered_map& b)

Greater than or equal operator.

Parameters
a First iunordered_map to compare.
b Second iunordered_map to compare.
Returns true if the first iunordered_map is lexicographically greater than or equal to the second one, otherwise false.