Public Types | Public Member Functions | Private Types | Private Member Functions | List of all members
absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc > Class Template Reference

#include <raw_hash_map.h>

Inheritance diagram for absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >:
Inheritance graph
[legend]

Public Types

using const_iterator = typename raw_hash_map::raw_hash_set::const_iterator
 
using iterator = typename raw_hash_map::raw_hash_set::iterator
 
template<class K >
using key_arg = typename KeyArgImpl::template type< K, key_type >
 
using key_type = typename Policy::key_type
 
using mapped_type = typename Policy::mapped_type
 
- Public Types inherited from absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >
using allocator_type = Alloc
 
using const_pointer = typename absl::allocator_traits< allocator_type >::template rebind_traits< value_type >::const_pointer
 
using const_reference = const value_type &
 
using difference_type = ptrdiff_t
 
using hasher = Hash
 
using init_type = typename PolicyTraits::init_type
 
using insert_return_type = InsertReturnType< iterator, node_type >
 
template<class K >
using key_arg = typename KeyArgImpl::template type< K, key_type >
 
using key_equal = Eq
 
using key_type = typename PolicyTraits::key_type
 
using node_type = node_handle< Policy, hash_policy_traits< Policy >, Alloc >
 
using pointer = typename absl::allocator_traits< allocator_type >::template rebind_traits< value_type >::pointer
 
using policy_type = Policy
 
using reference = value_type &
 
using size_type = size_t
 
using slot_type = typename PolicyTraits::slot_type
 
using value_type = typename PolicyTraits::value_type
 

Public Member Functions

template<class K = key_type, class P = Policy>
MappedReference< P > at (const key_arg< K > &key)
 
template<class K = key_type, class P = Policy>
MappedConstReference< P > at (const key_arg< K > &key) const
 
template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
std::pair< iterator, bool > insert_or_assign (key_arg< K > &&k, V &&v)
 
template<class K = key_type, class V = mapped_type, K * = nullptr>
std::pair< iterator, bool > insert_or_assign (key_arg< K > &&k, const V &v)
 
template<class K = key_type, class V = mapped_type, V * = nullptr>
std::pair< iterator, bool > insert_or_assign (const key_arg< K > &k, V &&v)
 
template<class K = key_type, class V = mapped_type>
std::pair< iterator, bool > insert_or_assign (const key_arg< K > &k, const V &v)
 
template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
iterator insert_or_assign (const_iterator, key_arg< K > &&k, V &&v)
 
template<class K = key_type, class V = mapped_type, K * = nullptr>
iterator insert_or_assign (const_iterator, key_arg< K > &&k, const V &v)
 
template<class K = key_type, class V = mapped_type, V * = nullptr>
iterator insert_or_assign (const_iterator, const key_arg< K > &k, V &&v)
 
template<class K = key_type, class V = mapped_type>
iterator insert_or_assign (const_iterator, const key_arg< K > &k, const V &v)
 
template<class K = key_type, class P = Policy, K * = nullptr>
MappedReference< P > operator[] (key_arg< K > &&key)
 
template<class K = key_type, class P = Policy>
MappedReference< P > operator[] (const key_arg< K > &key)
 
 raw_hash_map ()
 
template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0, K * = nullptr>
std::pair< iterator, bool > try_emplace (key_arg< K > &&k, Args &&... args)
 
template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0>
std::pair< iterator, bool > try_emplace (const key_arg< K > &k, Args &&... args)
 
template<class K = key_type, class... Args, K * = nullptr>
iterator try_emplace (const_iterator, key_arg< K > &&k, Args &&... args)
 
template<class K = key_type, class... Args>
iterator try_emplace (const_iterator, const key_arg< K > &k, Args &&... args)
 
- Public Member Functions inherited from absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >
iterator begin ()
 
const_iterator begin () const
 
size_t bucket_count () const
 
size_t capacity () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
ABSL_ATTRIBUTE_REINITIALIZES void clear ()
 
template<class K = key_type>
bool contains (const key_arg< K > &key) const
 
template<class K = key_type>
size_t count (const key_arg< K > &key) const
 
template<class... Args, typename std::enable_if< IsDecomposable< Args... >::value, int >::type = 0>
std::pair< iterator, bool > emplace (Args &&... args)
 
template<class... Args, typename std::enable_if< !IsDecomposable< Args... >::value, int >::type = 0>
std::pair< iterator, bool > emplace (Args &&... args)
 
template<class... Args>
iterator emplace_hint (const_iterator, Args &&... args)
 
bool empty () const
 
iterator end ()
 
const_iterator end () const
 
template<class K = key_type>
std::pair< iterator, iteratorequal_range (const key_arg< K > &key)
 
template<class K = key_type>
std::pair< const_iterator, const_iteratorequal_range (const key_arg< K > &key) const
 
template<class K = key_type>
size_type erase (const key_arg< K > &key)
 
void erase (const_iterator cit)
 
void erase (iterator it)
 
iterator erase (const_iterator first, const_iterator last)
 
node_type extract (const_iterator position)
 
template<class K = key_type, typename std::enable_if<!std::is_same< K, iterator >::value, int >::type = 0>
node_type extract (const key_arg< K > &key)
 
template<class K = key_type>
iterator find (const key_arg< K > &key, size_t hash)
 
template<class K = key_type>
iterator find (const key_arg< K > &key)
 
template<class K = key_type>
const_iterator find (const key_arg< K > &key, size_t hash) const
 
template<class K = key_type>
const_iterator find (const key_arg< K > &key) const
 
allocator_type get_allocator () const
 
hasher hash_function () const
 
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< T >::value, int >::type = 0, T * = nullptr>
std::pair< iterator, bool > insert (T &&value)
 
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< const T &>::value, int >::type = 0>
std::pair< iterator, bool > insert (const T &value)
 
std::pair< iterator, bool > insert (init_type &&value)
 
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< T >::value, int >::type = 0, T * = nullptr>
iterator insert (const_iterator, T &&value)
 
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< const T &>::value, int >::type = 0>
iterator insert (const_iterator, const T &value)
 
iterator insert (const_iterator, init_type &&value)
 
template<class InputIt >
void insert (InputIt first, InputIt last)
 
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< const T &> = 0>
void insert (std::initializer_list< T > ilist)
 
void insert (std::initializer_list< init_type > ilist)
 
insert_return_type insert (node_type &&node)
 
iterator insert (const_iterator, node_type &&node)
 
key_equal key_eq () const
 
template<class K = key_type, class F >
iterator lazy_emplace (const key_arg< K > &key, F &&f)
 
float load_factor () const
 
float max_load_factor () const
 
void max_load_factor (float)
 
size_t max_size () const
 
template<typename H , typename E >
void merge (raw_hash_set< Policy, H, E, Alloc > &src)
 
template<typename H , typename E >
void merge (raw_hash_set< Policy, H, E, Alloc > &&src)
 
raw_hash_setoperator= (const raw_hash_set &that)
 
raw_hash_setoperator= (raw_hash_set &&that) noexcept(absl::allocator_traits< allocator_type >::is_always_equal::value &&std::is_nothrow_move_assignable< hasher >::value &&std::is_nothrow_move_assignable< key_equal >::value)
 
template<class K = key_type>
void prefetch (const key_arg< K > &key) const
 
 raw_hash_set () noexcept(std::is_nothrow_default_constructible< hasher >::value &&std::is_nothrow_default_constructible< key_equal >::value &&std::is_nothrow_default_constructible< allocator_type >::value)
 
 raw_hash_set (size_t bucket_count, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
 
 raw_hash_set (size_t bucket_count, const hasher &hash, const allocator_type &alloc)
 
 raw_hash_set (size_t bucket_count, const allocator_type &alloc)
 
 raw_hash_set (const allocator_type &alloc)
 
template<class InputIter >
 raw_hash_set (InputIter first, InputIter last, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
 
template<class InputIter >
 raw_hash_set (InputIter first, InputIter last, size_t bucket_count, const hasher &hash, const allocator_type &alloc)
 
template<class InputIter >
 raw_hash_set (InputIter first, InputIter last, size_t bucket_count, const allocator_type &alloc)
 
template<class InputIter >
 raw_hash_set (InputIter first, InputIter last, const allocator_type &alloc)
 
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
 raw_hash_set (std::initializer_list< T > init, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
 
 raw_hash_set (std::initializer_list< init_type > init, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
 
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
 raw_hash_set (std::initializer_list< T > init, size_t bucket_count, const hasher &hash, const allocator_type &alloc)
 
 raw_hash_set (std::initializer_list< init_type > init, size_t bucket_count, const hasher &hash, const allocator_type &alloc)
 
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
 raw_hash_set (std::initializer_list< T > init, size_t bucket_count, const allocator_type &alloc)
 
 raw_hash_set (std::initializer_list< init_type > init, size_t bucket_count, const allocator_type &alloc)
 
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
 raw_hash_set (std::initializer_list< T > init, const allocator_type &alloc)
 
 raw_hash_set (std::initializer_list< init_type > init, const allocator_type &alloc)
 
 raw_hash_set (const raw_hash_set &that)
 
 raw_hash_set (const raw_hash_set &that, const allocator_type &a)
 
 raw_hash_set (raw_hash_set &&that) noexcept(std::is_nothrow_copy_constructible< hasher >::value &&std::is_nothrow_copy_constructible< key_equal >::value &&std::is_nothrow_copy_constructible< allocator_type >::value)
 
 raw_hash_set (raw_hash_set &&that, const allocator_type &a)
 
void rehash (size_t n)
 
void reserve (size_t n)
 
size_t size () const
 
void swap (raw_hash_set &that) noexcept(IsNoThrowSwappable< hasher >() &&IsNoThrowSwappable< key_equal >() &&(!AllocTraits::propagate_on_container_swap::value||IsNoThrowSwappable< allocator_type >()))
 
 ~raw_hash_set ()
 

Private Types

using KeyArgImpl = KeyArg< IsTransparent< Eq >::value &&IsTransparent< Hash >::value >
 
template<class P >
using MappedConstReference = decltype(P::value(std::addressof(std::declval< typename raw_hash_map::const_reference >())))
 
template<class P >
using MappedReference = decltype(P::value(std::addressof(std::declval< typename raw_hash_map::reference >())))
 

Private Member Functions

template<class K , class V >
std::pair< iterator, bool > insert_or_assign_impl (K &&k, V &&v)
 
template<class K = key_type, class... Args>
std::pair< iterator, bool > try_emplace_impl (K &&k, Args &&... args)
 

Additional Inherited Members

- Protected Member Functions inherited from absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >
template<class... Args>
void emplace_at (size_t i, Args &&... args)
 
template<class K >
std::pair< size_t, bool > find_or_prepare_insert (const K &key)
 
iterator iterator_at (size_t i)
 
const_iterator iterator_at (size_t i) const
 
size_t prepare_insert (size_t hash) ABSL_ATTRIBUTE_NOINLINE
 

Detailed Description

template<class Policy, class Hash, class Eq, class Alloc>
class absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >

Definition at line 29 of file raw_hash_map.h.

Member Typedef Documentation

◆ const_iterator

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::const_iterator = typename raw_hash_map::raw_hash_set::const_iterator

Definition at line 57 of file raw_hash_map.h.

◆ iterator

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::iterator = typename raw_hash_map::raw_hash_set::iterator

Definition at line 56 of file raw_hash_map.h.

◆ key_arg

template<class Policy, class Hash, class Eq, class Alloc>
template<class K >
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::key_arg = typename KeyArgImpl::template type<K, key_type>

Definition at line 49 of file raw_hash_map.h.

◆ key_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::key_type = typename Policy::key_type

Definition at line 46 of file raw_hash_map.h.

◆ KeyArgImpl

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::KeyArgImpl = KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>
private

Definition at line 43 of file raw_hash_map.h.

◆ mapped_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::mapped_type = typename Policy::mapped_type

Definition at line 47 of file raw_hash_map.h.

◆ MappedConstReference

template<class Policy, class Hash, class Eq, class Alloc>
template<class P >
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::MappedConstReference = decltype(P::value( std::addressof(std::declval<typename raw_hash_map::const_reference>())))
private

Definition at line 40 of file raw_hash_map.h.

◆ MappedReference

template<class Policy, class Hash, class Eq, class Alloc>
template<class P >
using absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::MappedReference = decltype(P::value( std::addressof(std::declval<typename raw_hash_map::reference>())))
private

Definition at line 35 of file raw_hash_map.h.

Constructor & Destructor Documentation

◆ raw_hash_map()

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::raw_hash_map ( )
inline

Definition at line 59 of file raw_hash_map.h.

Member Function Documentation

◆ at() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class P = Policy>
MappedReference<P> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::at ( const key_arg< K > &  key)
inline

Definition at line 137 of file raw_hash_map.h.

◆ at() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class P = Policy>
MappedConstReference<P> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::at ( const key_arg< K > &  key) const
inline

Definition at line 144 of file raw_hash_map.h.

◆ insert_or_assign() [1/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( key_arg< K > &&  k,
V &&  v 
)
inline

Definition at line 71 of file raw_hash_map.h.

◆ insert_or_assign() [2/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type, K * = nullptr>
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( key_arg< K > &&  k,
const V &  v 
)
inline

Definition at line 76 of file raw_hash_map.h.

◆ insert_or_assign() [3/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type, V * = nullptr>
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( const key_arg< K > &  k,
V &&  v 
)
inline

Definition at line 81 of file raw_hash_map.h.

◆ insert_or_assign() [4/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type>
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( const key_arg< K > &  k,
const V &  v 
)
inline

Definition at line 86 of file raw_hash_map.h.

◆ insert_or_assign() [5/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
iterator absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( const_iterator  ,
key_arg< K > &&  k,
V &&  v 
)
inline

Definition at line 92 of file raw_hash_map.h.

◆ insert_or_assign() [6/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type, K * = nullptr>
iterator absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( const_iterator  ,
key_arg< K > &&  k,
const V &  v 
)
inline

Definition at line 97 of file raw_hash_map.h.

◆ insert_or_assign() [7/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type, V * = nullptr>
iterator absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( const_iterator  ,
const key_arg< K > &  k,
V &&  v 
)
inline

Definition at line 102 of file raw_hash_map.h.

◆ insert_or_assign() [8/8]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class V = mapped_type>
iterator absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign ( const_iterator  ,
const key_arg< K > &  k,
const V &  v 
)
inline

Definition at line 107 of file raw_hash_map.h.

◆ insert_or_assign_impl()

template<class Policy, class Hash, class Eq, class Alloc>
template<class K , class V >
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign_impl ( K &&  k,
V &&  v 
)
inlineprivate

Definition at line 162 of file raw_hash_map.h.

◆ operator[]() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class P = Policy, K * = nullptr>
MappedReference<P> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::operator[] ( key_arg< K > &&  key)
inline

Definition at line 151 of file raw_hash_map.h.

◆ operator[]() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class P = Policy>
MappedReference<P> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::operator[] ( const key_arg< K > &  key)
inline

Definition at line 156 of file raw_hash_map.h.

◆ try_emplace() [1/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0, K * = nullptr>
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace ( key_arg< K > &&  k,
Args &&...  args 
)
inline

Definition at line 115 of file raw_hash_map.h.

◆ try_emplace() [2/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0>
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace ( const key_arg< K > &  k,
Args &&...  args 
)
inline

Definition at line 122 of file raw_hash_map.h.

◆ try_emplace() [3/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class... Args, K * = nullptr>
iterator absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace ( const_iterator  ,
key_arg< K > &&  k,
Args &&...  args 
)
inline

Definition at line 127 of file raw_hash_map.h.

◆ try_emplace() [4/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class... Args>
iterator absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace ( const_iterator  ,
const key_arg< K > &  k,
Args &&...  args 
)
inline

Definition at line 132 of file raw_hash_map.h.

◆ try_emplace_impl()

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class... Args>
std::pair<iterator, bool> absl::container_internal::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace_impl ( K &&  k,
Args &&...  args 
)
inlineprivate

Definition at line 172 of file raw_hash_map.h.


The documentation for this class was generated from the following file:


abseil_cpp
Author(s):
autogenerated on Mon Feb 28 2022 21:31:23