Template Class unordered_map

• Defined in File unordered_map.hpp

Class Documentation

template<class Key, class T, class Hash = std::hash<Key>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
class uitsl::safe::unordered_map

Public Types

using allocator_type = typename impl_t::allocator_type

using const_iterator = typename impl_t::const_iterator

using const_local_iterator = typename impl_t::const_local_iterator

using insert_return_type = typename impl_t::insert_return_type

using iterator = typename impl_t::iterator

using key_type = typename impl_t::key_type

using local_iterator = typename impl_t::local_iterator

using mapped_type = typename impl_t::mapped_type

using node_type = typename impl_t::node_type

using size_type = typename impl_t::size_type

using value_type = typename impl_t::value_type

Public Functions

template<typename ...Args>
unordered_map(Args&&... args)

unordered_map &operator=(const unordered_map &arg)

unordered_map &operator=(unordered_map &&arg) noexcept(value && is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>)

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

allocator_type get_allocator() const noexcept

iterator begin() noexcept

const_iterator begin() const noexcept

iterator end() noexcept

const_iterator end() const noexcept

const_iterator cbegin() const noexcept

const_iterator cend() const noexcept

bool empty() const noexcept

size_type size() const noexcept

size_type max_size() const noexcept

template<class ...Args>
std::pair<iterator, bool> emplace(Args&&... args)

template<class ...Args>
iterator emplace_hint(const_iterator position, Args&&... args)

std::pair<iterator, bool> insert(const value_type &obj)

std::pair<iterator, bool> insert(value_type &&obj)

template<class P>
std::pair<iterator, bool> insert(P &&obj)

iterator insert(const_iterator hint, const value_type &obj)

iterator insert(const_iterator hint, value_type &&obj)

template<class P>
iterator insert(const_iterator hint, P &&obj)

template<class InputIt>
void insert(InputIt first, InputIt last)

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

node_type extract(const_iterator position)

node_type extract(const key_type &x)

insert_return_type insert(node_type &&nh)

iterator insert(const_iterator hint, node_type &&nh)

template<class ...Args>
std::pair<iterator, bool> try_emplace(const key_type &k, Args&&... args)

template<class ...Args>
std::pair<iterator, bool> try_emplace(key_type &&k, Args&&... args)

template<class ...Args>
iterator try_emplace(const_iterator hint, const key_type &k, Args&&... args)

template<class ...Args>
iterator try_emplace(const_iterator hint, key_type &&k, Args&&... args)

template<class M>
std::pair<iterator, bool> insert_or_assign(const key_type &k, M &&obj)

template<class M>
std::pair<iterator, bool> insert_or_assign(key_type &&k, M &&obj)

template<class M>
iterator insert_or_assign(const_iterator hint, const key_type &k, M &&obj)

template<class M>
iterator insert_or_assign(const_iterator hint, key_type &&k, M &&obj)

iterator erase(iterator position)

iterator erase(const_iterator position)

size_type erase(const key_type &k)

iterator erase(const_iterator first, const_iterator last)

void swap(unordered_map &arg) noexcept(value && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>)

void clear() noexcept

template<class H2, class P2>
void merge(std::unordered_map<Key, T, H2, P2, Allocator> &source)

template<class H2, class P2>
void merge(std::unordered_map<Key, T, H2, P2, Allocator> &&source)

template<class H2, class P2>
void merge(std::unordered_multimap<Key, T, H2, P2, Allocator> &source)

template<class H2, class P2>
void merge(std::unordered_multimap<Key, T, H2, P2, Allocator> &&source)

iterator find(const key_type &k)

const_iterator find(const key_type &k) const

template<class K>
iterator find(const K &k)

template<class K>
const_iterator find(const K &k) const

template<class K>
size_type count(const key_type &k) const

template<class K>
size_type count(const K &k) const

bool contains(const key_type &k) const

template<class K>
bool contains(const K &k) const

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

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

template<class K>
std::pair<iterator, iterator> equal_range(const K &k)

template<class K>
std::pair<const_iterator, const_iterator> equal_range(const K &k) const

mapped_type &operator[](const key_type &k)

mapped_type &operator[](key_type &&k)

mapped_type &at(const key_type &k)

const mapped_type &at(const key_type &k) const

size_type bucket_count() const noexcept

size_type max_bucket_count() const noexcept

size_type bucket_size(size_type n) const

size_type bucket(const key_type &k) const

local_iterator begin(size_type n)

const_local_iterator begin(size_type n) const

local_iterator end(size_type n)

const_local_iterator end(size_type n) const

const_local_iterator cbegin(size_type n) const

const_local_iterator cend(size_type n) const

float load_factor() const noexcept

float max_load_factor() const noexcept

void max_load_factor(float z)

void rehash(size_type n)

void reserve(size_type n)