sfl::static_unordered_map

Table of Contents

Summary
Template Parameters
Public Member Types
Public Data Members
- static_capacity
- static_bucket_count
Public Member Functions
- (constructor)
- (destructor)
- operator=
- hash_function
- key_eq
- begin, cbegin
- end, cend
- empty
- full
- size
- max_size
- capacity
- available
- clear
- emplace
- emplace_hint
- insert
- insert_range
- insert_or_assign
- try_emplace
- erase
- swap
- equal_range
- find
- count
- contains
- at
- operator[]
- begin, cbegin (bucket interface)
- end, cend (bucket interface)
- bucket_count
- max_bucket_count
- bucket_size
- bucket
- load_factor
- max_load_factor
Non-member Functions
- operator==
- operator!=
- swap
- erase_if

Summary

Defined in header sfl/static_unordered_map.hpp:

namespace sfl
{
    template < typename Key,
               typename T,
               std::size_t StaticCapacity,
               std::size_t StaticBucketCount = /* see description below */,
               typename Hash = std::hash<Key>,
               typename KeyEqual = std::equal_to<Key> >
    class static_unordered_map;
}

sfl::static_unordered_map is an associative container similar to std::unordered_map, but with a fixed maximum capacity defined at compile time and backed entirely by statically alocated storage. This container does not perform any dynamic memory allocation. The number of elements cannot be greater than StaticCapacity. Attempting to insert more elements results in undefined behavior.

The underlying storage is implemented as a hash table with separate chaining.

The complexity of search, insert, and erase operations is O(1) on average.

References and pointers to elements are stable: insert and erase operations do not invalidate them unless the referenced element is erased.

Iterators to elements are forward iterators, and they meet the requirements of LegacyForwardIterator.

sfl::static_unordered_map meets the requirements of Container and UnorderedAssociativeContainer.

This container is convenient for bare-metal embedded software development.

Template Parameters

```
typename Key
```
Key type.
```
typename T
```
Value type.
```
std::size_t StaticCapacity
```
Size of the internal statically allocated array used for elements, i.e. the maximal number of elements that this container can contain.
```
std::size_t StaticBucketCount
```
Size of the internal statically allocated array used for buckets.

Default value of this parameter is StaticCapacity rounded up to the nearest power of two.
```
typename Hash
```
Hash function for keys.
```
typename KeyEqual
```
Comparison function for keys.

Public Member Types

Member Type	Definition
`key_type`	`Key`
`mapped_type`	`T`
`value_type`	`std::pair<const Key, T>`
`size_type`	Unsigned integer type
`difference_type`	Signed integer type
`hasher`	`Hash`
`key_equal`	`KeyEqual`
`reference`	`value_type&`
`const_reference`	`const value_type&`
`pointer`	`value_type*`
`const_pointer`	`const value_type*`
`iterator`	LegacyForwardIterator to `value_type`
`const_iterator`	LegacyForwardIterator to `const value_type`
`local_iterator`	LegacyForwardIterator to `value_type`. This iterator can be used to iterate through a single bucket but not across buckets.
`const_local_iterator`	LegacyForwardIterator to `const value_type`. This iterator can be used to iterate through a single bucket but not across buckets

Public Data Members

static_capacity

static constexpr size_type static_capacity = StaticCapacity;

static_bucket_count

static constexpr size_type static_bucket_count = StaticBucketCount;

Public Member Functions

(constructor)

```
static_unordered_map();
```

static_unordered_map(const Hash& hash);

static_unordered_map(const Hash& hash, const KeyEqual& equal);

Effects: Constructs an empty container.

Complexity: Constant.

template <typename InputIt>
static_unordered_map(InputIt first, InputIt last);

template <typename InputIt>
static_unordered_map(InputIt first, InputIt last, const Hash& hash);

```
template <typename InputIt>
static_unordered_map(InputIt first, InputIt last, const Hash& hash, const KeyEqual& equal);
```
Preconditions: std::distance(first, last) <= capacity()

Effects: Constructs the container with the contents of the range [first, last).

If multiple elements in the range have keys that compare equivalent, then the first element is inserted.

Note: These overloads participate in overload resolution only if InputIt satisfies requirements of LegacyInputIterator.

static_unordered_map(std::initializer_list<value_type> ilist);

static_unordered_map(std::initializer_list<value_type> ilist, const Hash& hash);

```
static_unordered_map(std::initializer_list<value_type> ilist, const Hash& hash, const KeyEqual& equal);
```
Preconditions: ilist.size() <= capacity()

Effects: Constructs the container with the contents of the initializer list ilist.

If multiple elements in the range have keys that compare equivalent, then the first element is inserted.
```
static_unordered_map(const static_unordered_map& other);
```
Effects: Copy constructor. Constructs the container with the copy of the contents of other.
```
static_unordered_map(static_unordered_map&& other);
```
Effects: Move constructor. Constructs the container with the contents of other using move semantics.

other is not guaranteed to be empty after the move.

other is in a valid but unspecified state after the move.

template <typename Range>
static_unordered_map(sfl::from_range_t, Range&& range);

template <typename Range>
static_unordered_map(sfl::from_range_t, Range&& range, const Hash& hash);

```
template <typename Range>
static_unordered_map(sfl::from_range_t, Range&& range, const Hash& hash, const KeyEqual& equal);
```
Effects: Constructs the container with the contents of range.

If multiple elements in the range have keys that compare equivalent, then the first element is inserted.

Note: These overloads are available in C++11. If compiled with C++20 or later, proper C++20 range concepts are used.

(destructor)

```
~static_unordered_map();
```
Effects: Destructs the container. The destructors of the elements are called and the used storage is deallocated.

Complexity: Linear in size().

operator=

```
static_unordered_map& operator=(const static_unordered_map& other);
```
Effects: Copy assignment operator. Replaces the contents with a copy of the contents of other.

Returns: *this().
```
static_unordered_map& operator=(static_unordered_map&& other);
```
Effects: Move assignment operator. Replaces the contents with those of other using move semantics.

other is not guaranteed to be empty after the move.

other is in a valid but unspecified state after the move.

Returns: *this().
```
static_unordered_map& operator=(std::initializer_list<value_type> ilist);
```
Preconditions: ilist.size() <= capacity()

Effects: Replaces the contents with those identified by initializer list ilist.

Returns: *this().

hash_function

```
hasher hash_function() const;
```
Effects: Returns the function object that hashes the keys.

Complexity: Constant.

key_eq

```
key_equal key_eq() const;
```
Effects: Returns a function object that compares keys for equality.

Complexity: Constant.

begin, cbegin

```
iterator begin() noexcept;
```
```
const_iterator begin() const noexcept;
```
```
const_iterator cbegin() const noexcept;
```
Effects: Returns an iterator to the first element of the container. If the container is empty, the returned iterator will be equal to end().

Complexity: Constant.

end, cend

```
iterator end() noexcept;
```
```
const_iterator end() const noexcept;
```
```
const_iterator cend() const noexcept;
```
Effects: Returns an iterator to the element following the last element of the container. This element acts as a placeholder; attempting to access it results in undefined behavior.

Complexity: Constant.

empty

```
bool empty() const noexcept;
```
Effects: Returns true if the container has no elements, i.e. whether begin() == end().

Complexity: Constant.

full

```
bool full() const noexcept;
```
Effects: Returns true if the container is full, i.e. whether size() == capacity().

Complexity: Constant.

size

```
size_type size() const noexcept;
```
Effects: Returns the number of elements in the container, i.e. std::distance(begin(), end()).

Complexity: Constant.

max_size

```
static constexpr size_type max_size() const noexcept;
```
Effects: Returns the maximum number of elements the container is able to hold, i.e. StaticCapacity.

Complexity: Constant.

capacity

```
static constexpr size_type capacity() const noexcept;
```
Effects: Returns the maximum number of elements the container is able to hold, i.e. StaticCapacity.

Complexity: Constant.

available

```
size_type available() const noexcept;
```
Effects: Returns the number of elements that can be inserted into the container, i.e. capacity() - size().

Complexity: Constant.

clear

```
void clear() noexcept;
```
Effects: Erases all elements from the container. After this call, size() returns zero.

Complexity: Linear in size().

emplace

```
template <typename... Args>
std::pair<iterator, bool> emplace(Args&&... args);
```
Preconditions: !full()

Effects: Inserts new element into the container if the container doesn't already contain an element with an equivalent key.

New element is constructed as value_type(std::forward<Args>(args)...).

The element may be constructed even if there already is an element with the key in the container, in which case the newly constructed element will be destroyed immediately.

Returns: The iterator component points to the inserted element or to the already existing element. The bool component is true if insertion happened and false if it did not.

emplace_hint

```
template <typename... Args>
iterator emplace_hint(const_iterator hint, Args&&... args);
```
Preconditions: !full()

Effects: Inserts new element into the container if the container doesn't already contain an element with an equivalent key.

New element is constructed as value_type(std::forward<Args>(args)...).

The element may be constructed even if there already is an element with the key in the container, in which case the newly constructed element will be destroyed immediately.

Iterator hint is used as a suggestion where to start to search insert position.

Returns: Iterator to the inserted element or to the already existing element.

insert

```
std::pair<iterator, bool> insert(const value_type& value);
```
Preconditions: !full()

Effects: Inserts copy of value if the container doesn't already contain an element with an equivalent key.

Returns: The iterator component points to the inserted element or to the already existing element. The bool component is true if insertion happened and false if it did not.
```
std::pair<iterator, bool> insert(value_type&& value);
```
Preconditions: !full()

Effects: Inserts value using move semantics if the container doesn't already contain an element with an equivalent key.

Returns: The iterator component points to the inserted element or to the already existing element. The bool component is true if insertion happened and false if it did not.
```
template <typename P>
std::pair<iterator, bool> insert(P&& value);
```
Preconditions: !full()

Effects: Inserts new element into the container if the container doesn't already contain an element with an equivalent key.

New element is constructed as value_type(std::forward<P>(value)).

Note: This overload participates in overload resolution only if std::is_constructible<value_type, P&&>::value is true.

Returns: The iterator component points to the inserted element or to the already existing element. The bool component is true if insertion happened and false if it did not.
```
iterator insert(const_iterator hint, const value_type& value);
```
Preconditions: !full()

Effects: Inserts copy of value if the container doesn't already contain an element with an equivalent key.

Iterator hint is used as a suggestion where to start to search insert position.

Returns: Iterator to the inserted element or to the already existing element.
```
iterator insert(const_iterator hint, value_type&& value);
```
Preconditions: !full()

Effects: Inserts value using move semantics if the container doesn't already contain an element with an equivalent key.

Iterator hint is used as a suggestion where to start to search insert position.

Returns: Iterator to the inserted element or to the already existing element.
```
template <typename P>
iterator insert(const_iterator hint, P&& value);
```
Preconditions: !full()

Effects: Inserts new element into the container if the container doesn't already contain an element with an equivalent key.

New element is constructed as value_type(std::forward<P>(value)).

Iterator hint is used as a suggestion where to start to search insert position.

Note: This overload participates in overload resolution only if std::is_constructible<value_type, P&&>::value is true.

Returns: Iterator to the inserted element or to the already existing element.
```
template <typename InputIt>
void insert(InputIt first, InputIt last);
```
Preconditions: std::distance(first, last) <= available()

Effects: Inserts elements from range [first, last) if the container doesn't already contain an element with an equivalent key.

If multiple elements in the range have keys that compare equivalent, then the first element is inserted.

The call to this function is equivalent to:
```
while (first != last)
{
    insert(*first);
    ++first;
}
```
Note: This overload participates in overload resolution only if InputIt satisfies requirements of LegacyInputIterator.
```
void insert(std::initializer_list<value_type> ilist);
```
Preconditions: ilist.size() <= available()

Effects: Inserts elements from initializer list ilist if the container doesn't already contain an element with an equivalent key.

If multiple elements in the range have keys that compare equivalent, then the first element is inserted.

The call to this function is equivalent to insert(ilist.begin(), ilist.end()).

insert_range

```
template <typename Range>
void insert_range(Range&& range);
```
Effects: Inserts elements from range if the container doesn't already contain an element with an equivalent key.

If multiple elements in the range have keys that compare equivalent, then the first element is inserted.

Note: This function is available in C++11. If compiled with C++20 or later, proper C++20 range concepts are used.

insert_or_assign

template <typename M>
std::pair<iterator, bool> insert_or_assign(const Key& key, M&& obj);

template <typename M>
std::pair<iterator, bool> insert_or_assign(Key&& key, M&& obj);

```
template <typename K, typename M>
std::pair<iterator, bool> insert_or_assign(K&& key, M&& obj);
```
Preconditions: !full()

Effects: If a key equivalent to key already exists in the container, assigns std::forward<M>(obj) to the mapped type corresponding to the key key. If the key does not exist, inserts the new element.
- Overload (1): New element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(key),
            std::forward_as_tuple(std::forward<M>(obj)) )
```
  Note: This overload participates in overload resolution only if std::is_assignable_v<mapped_type&, M&&> is true.
- Overload (2): New element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::move(key)),
            std::forward_as_tuple(std::forward<M>(obj)) )
```
  Note: This overload participates in overload resolution only if std::is_assignable_v<mapped_type&, M&&> is true.
- Overload (3): New element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::forward<K>(key)),
            std::forward_as_tuple(std::forward<M>(obj)) )
```
  Note: This overload participates in overload resolution only if all following conditions are satisfied:
  1. Both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.
  2. std::is_assignable_v<mapped_type&, M&&> is true.
Returns: The iterator component points to the inserted element or to the updated element. The bool component is true if insertion took place and false if assignment took place.

template <typename M>
iterator insert_or_assign(const_iterator hint, const Key& key, M&& obj);

template <typename M>
iterator insert_or_assign(const_iterator hint, Key&& key, M&& obj);

```
template <typename K, typename M>
iterator insert_or_assign(const_iterator hint, K&& key, M&& obj);
```
Preconditions: !full()

Effects: If a key equivalent to key already exists in the container, assigns std::forward<M>(obj) to the mapped type corresponding to the key key. If the key does not exist, inserts the new element.

Iterator hint is used as a suggestion where to start to search insert position.
- Overload (4): New element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(key),
            std::forward_as_tuple(std::forward<M>(obj)) )
```
  Note: This overload participates in overload resolution only if std::is_assignable_v<mapped_type&, M&&> is true.
- Overload (5): New element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::move(key)),
            std::forward_as_tuple(std::forward<M>(obj)) )
```
  Note: This overload participates in overload resolution only if std::is_assignable_v<mapped_type&, M&&> is true.
- Overload (6): New element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::forward<K>(key)),
            std::forward_as_tuple(std::forward<M>(obj)) )
```
  Note: This overload participates in overload resolution only if all following conditions are satisfied:
  1. Both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.
  2. std::is_assignable_v<mapped_type&, M&&> is true.
Returns: Iterator to the element that was inserted or updated.

try_emplace

template <typename... Args>
std::pair<iterator, bool> try_emplace(const Key& key, Args&&... args);

template <typename... Args>
std::pair<iterator, bool> try_emplace(Key&& key, Args&&... args);

```
template <typename K, typename... Args>
std::pair<iterator, bool> try_emplace(K&& key, Args&&... args);
```
Preconditions: !full()

Effects: If a key equivalent to key already exists in the container, does nothing. Otherwise, inserts a new element into the container.
- Overload (1): Behaves like emplace except that the element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(key),
            std::forward_as_tuple(std::forward<Args>(args)...) )
```
- Overload (2): Behaves like emplace except that the element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::move(key)),
            std::forward_as_tuple(std::forward<Args>(args)...) )
```
- Overload (3): Behaves like emplace except that the element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::forward<K>(key)),
            std::forward_as_tuple(std::forward<Args>(args)...) )
```
  Note: This overload participates in overload resolution only if all following conditions are satisfied:
  1. Both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.
  2. std::is_convertible_v<K&&, iterator> is false.
  3. std::is_convertible_v<K&&, const_iterator> is false.
Returns: The iterator component points to the inserted element or to the already existing element. The bool component is true if insertion happened and false if it did not.

template <typename... Args>
iterator try_emplace(const_iterator hint, const Key& key, Args&&... args);

template <typename... Args>
iterator try_emplace(const_iterator hint, Key&& key, Args&&... args);

```
template <typename K, typename... Args>
iterator try_emplace(const_iterator hint, K&& key, Args&&... args);
```
Preconditions: !full()

Effects: If a key equivalent to key already exists in the container, does nothing. Otherwise, inserts a new element into the container.

Iterator hint is used as a suggestion where to start to search insert position.
- Overload (4): Behaves like emplace_hint except that the element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(key),
            std::forward_as_tuple(std::forward<Args>(args)...) )
```
- Overload (5): Behaves like emplace_hint except that the element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::move(key)),
            std::forward_as_tuple(std::forward<Args>(args)...) )
```
- Overload (6): Behaves like emplace_hint except that the element is constructed as
```
value_type( std::piecewise_construct,
            std::forward_as_tuple(std::forward<K>(key)),
            std::forward_as_tuple(std::forward<Args>(args)...) )
```
  Note: This overload participates in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.
Returns: Iterator to the inserted element or to the already existing element.

erase

```
iterator erase(iterator pos);
```
```
iterator erase(const_iterator pos);
```
Effects: Removes the element at pos.

Returns: Iterator following the last removed element.
```
iterator erase(const_iterator first, const_iterator last);
```
Effects: Removes the elements in the range [first, last).

Returns: Iterator following the last removed element.
```
size_type erase(const Key& key);
```
```
template <typename K>
size_type erase(K&& x);
```
Effects: Removes the element (if one exists) with the key equivalent to key or x.

Note: Overload (5) participates in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.

Returns: Number of elements removed (0 or 1).

swap

```
void swap(static_unordered_map& other);
```
Effects: Exchanges the contents of the container with those of other.

equal_range

std::pair<iterator, iterator> equal_range(const Key& key);

std::pair<const_iterator, const_iterator> equal_range(const Key& key) const;

template <typename K>
std::pair<iterator, iterator> equal_range(const K& x);

```
template <typename K>
std::pair<const_iterator, const_iterator> equal_range(const K& x) const;
```
Effects: Returns a range containing all elements with key that compares equivalent to key or x.
- The first iterator in pair points to the first element of range. It is equal to end() if no such element is found.
- The second iterator in pair points to the one-past-last element of range. It is equal to end() is no such element is found.
Note: Overloads (3) and (4) participate in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows these functions to be called without constructing an instance of Key.

Complexity: Average case linear in number of elements with key that compares equivalent to key or x. Worst case linear in size().

find

```
iterator find(const Key& key);
```

const_iterator find(const Key& key) const;

template <typename K>
iterator find(const K& x);

```
template <typename K>
const_iterator find(const K& x) const;
```
Effects: Returns an iterator pointing to the element with key equivalent to key or x. Returns end() if no such element is found.

Note: Overloads (3) and (4) participate in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows these functions to be called without constructing an instance of Key.

Complexity: Constant on average. Worst case linear in size().

count

```
size_type count(const Key& key) const;
```
```
template <typename K>
size_type count(const K& x) const;
```
Effects: Returns the number of elements with key equivalent to key or x, which is either 1 or 0 since this container does not allow duplicates.

Note: Overload (2) participates in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.

Complexity: Constant on average. Worst case linear in size().

contains

```
bool contains(const Key& key) const;
```
```
template <typename K>
bool contains(const K& x) const;
```
Effects: Returns true if the container contains an element with key equivalent to key or x, otherwise returns false.

Note: Overload (2) participates in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.

Complexity: Constant on average. Worst case linear in size().

at

```
T& at(const Key& key);
```
```
const T& at(const Key& key) const;
```

template <typename K>
T& at(const K& x);

```
template <typename K>
const T& at(const K& x) const;
```
Effects: Returns a reference to the mapped value of the element with key equivalent to key or x. If no such element exists, an exception of type std::out_of_range is thrown.

Note: Overloads (3) and (4) participate in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows these functions to be called without constructing an instance of Key.

Complexity: Constant on average. Worst case linear in size().

Exceptions: std::out_of_range if the container does not have an element with the specified key.

operator[]

```
T& operator[](const Key& key);
```
```
T& operator[](Key&& key);
```
```
template <typename K>
T& operator[](K&& x);
```
Preconditions: !full()

Effects: Returns a reference to the value that is mapped to a key equivalent to key or x, performing an insertion if such key does not already exist.
- Overload (1) is equivalent to return try_emplace(key).first->second;
- Overload (2) is equivalent to return try_emplace(std::move(key)).first->second;
- Overload (3) is equivalent to return try_emplace(std::forward<K>(x)).first->second;
Note: Overload (3) participates in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.

Complexity: Constant on average. Worst case linear in size().

begin, cbegin (bucket interface)

local_iterator begin(size_type n) noexcept;

const_local_iterator begin(size_type n) const noexcept;

```
const_local_iterator cbegin(size_type n) const noexcept;
```
Effects: Returns an iterator to the first element of the bucket with index n.

Complexity: Constant.

end, cend (bucket interface)

local_iterator end(size_type n) noexcept;

const_local_iterator end(size_type n) const noexcept;

```
const_local_iterator cend(size_type n) const noexcept;
```
Effects: Returns an iterator to the element following the last element of the bucket with index n. This element acts as a placeholder; attempting to access it results in undefined behavior.

Complexity: Constant.

bucket_count

```
size_type bucket_count() const;
```
Effects: Returns the number of buckets in the container, i.e. returns StaticBucketCount.

Complexity: Constant.

max_bucket_count

```
size_type max_bucket_count() const;
```
Effects: Returns the maximum number of buckets the container is able to hold due to system or library implementation limitations, i.e. returns StaticBucketCount.

Complexity: Constant.

bucket_size

```
size_type bucket_size(size_type n) const;
```
Effects: Returns the number of elements in the bucket with index n.

Complexity: Linear in the size of the bucket n.

bucket

size_type bucket(const Key& key) const;

```
template <typename K>
size_type bucket(const K& x) const;
```
Effects: Returns the index of the bucket for key equivalent to key or x.

Note: Overload (2) participates in overload resolution only if both Hash::is_transparent and KeyEqual::is_transparent exist and are valid types. This allows the function to be called without constructing an instance of Key.

Complexity: Constant.

load_factor

```
float load_factor() const;
```
Effects: Returns the average number of elements per bucket, that is, size() divided by bucket_count().

Complexity: Constant.

max_load_factor

```
float max_load_factor() const;
```
Effects: Returns current maximum load factor, i.e. StaticCapacity divided by StaticBucketCount.

Complexity: Constant.

Non-member Functions

operator==

template <typename K, typename T, std::size_t N, std::size_t M, typename H, typename E>
bool operator==
(
    const static_unordered_map<K, T, N, M, H, E>& x,
    const static_unordered_map<K, T, N, M, H, E>& y
);

Effects: Compares the contents of two containers.

Returns: Returns true if the contents of the x and y are equal, false otherwise.

operator!=

template <typename K, typename T, std::size_t N, std::size_t M, typename H, typename E>
bool operator!=
(
    const static_unordered_map<K, T, N, M, H, E>& x,
    const static_unordered_map<K, T, N, M, H, E>& y
);

Effects: Compares the contents of two containers.

Returns: Returns true if the contents of the x and y are not equal, false otherwise.

swap

template <typename K, typename T, std::size_t N, std::size_t M, typename H, typename E>
void swap
(
    static_unordered_map<K, T, N, M, H, E>& x,
    static_unordered_map<K, T, N, M, H, E>& y
);

Effects: Swaps the contents of x and y. Calls x.swap(y).

erase_if

template <typename K, typename T, std::size_t N, std::size_t M, typename H, typename E, typename Predicate>
typename static_unordered_map<K, T, N, M, H, E>::size_type
    erase_if(static_unordered_map<K, T, N, M, H, E>& c, Predicate pred);

Effects: Erases all elements that satisfy the predicate pred from the container.

pred is unary predicate which returns true if the element should be removed.

Returns: The number of erased elements.

End of document.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!