hpx/parcelport_libfabric/unordered_map.hpp

See Public API for a list of names and headers that are part of the public HPX API.

namespace hpx
namespace concurrent
template<class Key, class Value, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, Value>>>
class unordered_map

Public Types

typedef hpx::lcos::local::readers_writer_mutex rw_mutex_type
typedef std::unique_lock<rw_mutex_type> write_lock
typedef std::shared_lock<rw_mutex_type> read_lock
typedef std::defer_lock_t defer_lock
typedef base_map::key_type key_type
typedef base_map::mapped_type mapped_type
typedef base_map::value_type value_type
typedef base_map::size_type size_type
typedef base_map::difference_type difference_type
typedef base_map::hasher hasher
typedef base_map::key_equal key_equal
typedef base_map::allocator_type allocator_type
typedef base_map::reference reference
typedef base_map::const_reference const_reference
typedef base_map::pointer pointer
typedef base_map::const_pointer const_pointer
typedef base_map::iterator iterator
typedef base_map::const_iterator const_iterator
typedef base_map::local_iterator local_iterator
typedef base_map::const_local_iterator const_local_iterator
typedef read_lock map_read_lock_type
typedef write_lock map_write_lock_type

Public Functions

unordered_map(size_type n = 64, const hasher &hf = hasher(), const key_equal &eql = key_equal(), const allocator_type &a = allocator_type())
template<typename InputIterator>
unordered_map(InputIterator first, InputIterator last, size_type n = 64, const hasher &hf = hasher(), const key_equal &eql = key_equal(), const allocator_type &a = allocator_type())
unordered_map(const unordered_map &other)
unordered_map(const allocator_type &a)
unordered_map(const unordered_map &other, const allocator_type &a)
unordered_map(unordered_map &&other)
unordered_map(unordered_map &&other, const allocator_type &a)
unordered_map(std::initializer_list<value_type> il, size_type n = 64, const hasher &hf = hasher(), const key_equal &eql = key_equal(), const allocator_type &a = allocator_type())
~unordered_map()
unordered_map &operator=(const unordered_map &other)
unordered_map &operator=(unordered_map &&other)
unordered_map &operator=(std::initializer_list<value_type> il)
void swap(unordered_map &other)
std::pair<iterator, bool> insert(const value_type &x)
iterator insert(const_iterator hint, const value_type &x)
template<class InputIterator>
void insert(InputIterator first, InputIterator last)
std::pair<iterator, bool> insert(value_type &&x)
iterator insert(const_iterator hint, value_type &&x)
void insert(std::initializer_list<value_type> il)
template<typename ...Args>
std::pair<iterator, bool> emplace(Args&&... args)
template<typename ...Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
iterator erase(const_iterator position)
size_type erase(const key_type &k)
iterator erase(const_iterator first, const_iterator last)
void clear()
bool empty() const
size_type size() const
size_type max_size() const
iterator begin()
const_iterator begin() const
iterator end()
const_iterator end() const
const_iterator cbegin() const
const_iterator cend() const
rw_mutex_type &read_write_mutex()
hasher hash_function() const
key_equal key_eq() const
iterator find(const key_type &k)
const_iterator find(const key_type &k) const
std::pair<const_iterator, bool> is_in_map(const key_type &k) const
size_type count(const key_type &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
const mapped_type &operator[](const key_type &k) const
mapped_type &at(const key_type &k)
const mapped_type &at(const key_type &k) const

Private Types

typedef std::unordered_map<Key, Value, Hash, KeyEqual, Allocator> base_map

Private Members

base_map map_
rw_mutex_type mutex_
read_lock iterator_lock_