Template Class unordered_set

• Defined in File unordered_set.hpp

Class Documentation

template<class Key, class Hash = std::hash<Key>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<Key>>
class uitsl::safe::unordered_set

Public Types

using key_type = typename impl_t::key_type

using value_type = typename impl_t::value_type

using hasher = typename impl_t::hasher

using key_equal = typename impl_t::key_equal

using allocator_type = typename impl_t::allocator_type

using pointer = typename impl_t::pointer

using const_pointer = typename impl_t::const_pointer

using reference = typename impl_t::reference

using const_reference = typename impl_t::const_reference

using size_type = typename impl_t::size_type

using difference_type = typename impl_t::difference_type

using iterator = typename impl_t::iterator

using const_iterator = typename impl_t::const_iterator

using local_iterator = typename impl_t::local_iterator

using const_local_iterator = typename impl_t::const_local_iterator

using node_type = typename impl_t::node_type

using insert_return_type = typename impl_t::insert_return_type

Public Functions

std::shared_mutex &GetMutex() const

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

unordered_set &operator=(const unordered_set &arg)

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

unordered_set &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)

iterator insert(const_iterator hint, const value_type &obj)

iterator insert(const_iterator hint, value_type &&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)

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(this_t &arg) noexcept(value && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>)

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

void clear() noexcept

template<class H2, class P2>
void merge(uitsl::safe::unordered_set<Key, H2, P2, Allocator> &source)

template<class H2, class P2>
void merge(uitsl::safe::unordered_set<Key, H2, P2, Allocator> &&source)

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

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

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

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

hasher hash_function() const

key_equal key_eq() const

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

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

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)