Classes | Public Types | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Friends | List of all members
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc > Class Template Reference

#include <raw_hash_set.h>

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

Classes

class  const_iterator
 
class  constructor
 
struct  EmplaceDecomposable
 
struct  EqualElement
 
struct  FindElement
 
struct  FindInfo
 
struct  HashElement
 
struct  InsertSlot
 
class  iterator
 
struct  SameAsElementReference
 

Public Types

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

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 ()
 

Protected Member Functions

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
 

Private Types

using AllocTraits = absl::allocator_traits< allocator_type >
 
template<class... Ts>
using IsDecomposable = IsDecomposable< void, PolicyTraits, Hash, Eq, Ts... >
 
using KeyArgImpl = KeyArg< IsTransparent< Eq >::value &&IsTransparent< Hash >::value >
 
using Layout = absl::container_internal::Layout< ctrl_t, slot_type >
 
using PolicyTraits = hash_policy_traits< Policy >
 
template<class T >
using RequiresInsertable = typename std::enable_if< absl::disjunction< std::is_convertible< T, init_type >, SameAsElementReference< T > >::value, int >::type
 
template<class T >
using RequiresNotInit = typename std::enable_if<!std::is_same< T, init_type >::value, int >::type
 
using SlotAlloc = typename absl::allocator_traits< allocator_type >::template rebind_alloc< slot_type >
 
using SlotAllocTraits = typename absl::allocator_traits< allocator_type >::template rebind_traits< slot_type >
 

Private Member Functions

allocator_typealloc_ref ()
 
const allocator_typealloc_ref () const
 
void destroy_slots ()
 
void drop_deletes_without_resize () ABSL_ATTRIBUTE_NOINLINE
 
key_equaleq_ref ()
 
const key_equaleq_ref () const
 
void erase_meta_only (const_iterator it)
 
FindInfo find_first_non_full (size_t hash)
 
size_t & growth_left ()
 
bool has_element (const value_type &elem) const
 
hasherhash_ref ()
 
const hasherhash_ref () const
 
void initialize_slots ()
 
bool is_small () const
 
auto KeyTypeCanBeEq (const Eq &eq, const key_type &k) -> decltype(eq(k, k))
 
auto KeyTypeCanBeHashed (const Hash &h, const key_type &k) -> decltype(h(k))
 
raw_hash_setmove_assign (raw_hash_set &&that, std::true_type)
 
raw_hash_setmove_assign (raw_hash_set &&that, std::false_type)
 
probe_seq< Group::kWidthprobe (size_t hash) const
 
void rehash_and_grow_if_necessary ()
 
void reset_ctrl ()
 
void reset_growth_left ()
 
void resize (size_t new_capacity)
 
void set_ctrl (size_t i, ctrl_t h)
 

Static Private Member Functions

static Layout MakeLayout (size_t capacity)
 

Private Attributes

size_t capacity_ = 0
 
ctrl_tctrl_ = EmptyGroup()
 
HashtablezInfoHandle infoz_
 
absl::container_internal::CompressedTuple< size_t, hasher, key_equal, allocator_typesettings_ {0, hasher{}, key_equal{}, allocator_type{}}
 
size_t size_ = 0
 
slot_typeslots_ = nullptr
 

Friends

template<class Container , typename Enabler >
struct absl::container_internal::hashtable_debug_internal::HashtableDebugAccess
 
bool operator!= (const raw_hash_set &a, const raw_hash_set &b)
 
bool operator== (const raw_hash_set &a, const raw_hash_set &b)
 
struct RawHashSetTestOnlyAccess
 
void swap (raw_hash_set &a, raw_hash_set &b) noexcept(noexcept(a.swap(b)))
 

Detailed Description

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

Definition at line 447 of file raw_hash_set.h.

Member Typedef Documentation

◆ allocator_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::allocator_type = Alloc

Definition at line 527 of file raw_hash_set.h.

◆ AllocTraits

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::AllocTraits = absl::allocator_traits<allocator_type>
private

Definition at line 560 of file raw_hash_set.h.

◆ const_pointer

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::const_pointer = typename absl::allocator_traits< allocator_type>::template rebind_traits<value_type>::const_pointer

Definition at line 539 of file raw_hash_set.h.

◆ const_reference

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::const_reference = const value_type&

Definition at line 535 of file raw_hash_set.h.

◆ difference_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::difference_type = ptrdiff_t

Definition at line 529 of file raw_hash_set.h.

◆ hasher

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::hasher = Hash

Definition at line 530 of file raw_hash_set.h.

◆ init_type

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

Definition at line 522 of file raw_hash_set.h.

◆ insert_return_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert_return_type = InsertReturnType<iterator, node_type>

Definition at line 705 of file raw_hash_set.h.

◆ IsDecomposable

template<class Policy, class Hash, class Eq, class Alloc>
template<class... Ts>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>
private

Definition at line 594 of file raw_hash_set.h.

◆ key_arg

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

Definition at line 546 of file raw_hash_set.h.

◆ key_equal

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::key_equal = Eq

Definition at line 531 of file raw_hash_set.h.

◆ key_type

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

Definition at line 523 of file raw_hash_set.h.

◆ KeyArgImpl

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

Definition at line 519 of file raw_hash_set.h.

◆ Layout

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::Layout = absl::container_internal::Layout<ctrl_t, slot_type>
private

Definition at line 553 of file raw_hash_set.h.

◆ node_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>

Definition at line 704 of file raw_hash_set.h.

◆ pointer

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::pointer = typename absl::allocator_traits< allocator_type>::template rebind_traits<value_type>::pointer

Definition at line 537 of file raw_hash_set.h.

◆ policy_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::policy_type = Policy

Definition at line 532 of file raw_hash_set.h.

◆ PolicyTraits

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::PolicyTraits = hash_policy_traits<Policy>
private

Definition at line 517 of file raw_hash_set.h.

◆ reference

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::reference = value_type&

Definition at line 534 of file raw_hash_set.h.

◆ RequiresInsertable

template<class Policy, class Hash, class Eq, class Alloc>
template<class T >
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::RequiresInsertable = typename std::enable_if< absl::disjunction<std::is_convertible<T, init_type>, SameAsElementReference<T> >::value, int>::type
private

Definition at line 585 of file raw_hash_set.h.

◆ RequiresNotInit

template<class Policy, class Hash, class Eq, class Alloc>
template<class T >
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::RequiresNotInit = typename std::enable_if<!std::is_same<T, init_type>::value, int>::type
private

Definition at line 591 of file raw_hash_set.h.

◆ size_type

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::size_type = size_t

Definition at line 528 of file raw_hash_set.h.

◆ slot_type

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

Definition at line 526 of file raw_hash_set.h.

◆ SlotAlloc

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::SlotAlloc = typename absl::allocator_traits< allocator_type>::template rebind_alloc<slot_type>
private

Definition at line 562 of file raw_hash_set.h.

◆ SlotAllocTraits

template<class Policy, class Hash, class Eq, class Alloc>
using absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::SlotAllocTraits = typename absl::allocator_traits< allocator_type>::template rebind_traits<slot_type>
private

Definition at line 564 of file raw_hash_set.h.

◆ value_type

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

Definition at line 533 of file raw_hash_set.h.

Constructor & Destructor Documentation

◆ raw_hash_set() [1/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( )
inlinenoexcept

Definition at line 707 of file raw_hash_set.h.

◆ raw_hash_set() [2/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( size_t  bucket_count,
const hasher hash = hasher(),
const key_equal eq = key_equal(),
const allocator_type alloc = allocator_type() 
)
inlineexplicit

Definition at line 712 of file raw_hash_set.h.

◆ raw_hash_set() [3/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( size_t  bucket_count,
const hasher hash,
const allocator_type alloc 
)
inline

Definition at line 723 of file raw_hash_set.h.

◆ raw_hash_set() [4/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( size_t  bucket_count,
const allocator_type alloc 
)
inline

Definition at line 727 of file raw_hash_set.h.

◆ raw_hash_set() [5/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( const allocator_type alloc)
inlineexplicit

Definition at line 730 of file raw_hash_set.h.

◆ raw_hash_set() [6/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class InputIter >
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::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() 
)
inline

Definition at line 734 of file raw_hash_set.h.

◆ raw_hash_set() [7/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class InputIter >
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( InputIter  first,
InputIter  last,
size_t  bucket_count,
const hasher hash,
const allocator_type alloc 
)
inline

Definition at line 742 of file raw_hash_set.h.

◆ raw_hash_set() [8/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class InputIter >
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( InputIter  first,
InputIter  last,
size_t  bucket_count,
const allocator_type alloc 
)
inline

Definition at line 747 of file raw_hash_set.h.

◆ raw_hash_set() [9/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class InputIter >
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( InputIter  first,
InputIter  last,
const allocator_type alloc 
)
inline

Definition at line 752 of file raw_hash_set.h.

◆ raw_hash_set() [10/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::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() 
)
inline

Definition at line 777 of file raw_hash_set.h.

◆ raw_hash_set() [11/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::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() 
)
inline

Definition at line 782 of file raw_hash_set.h.

◆ raw_hash_set() [12/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( std::initializer_list< T >  init,
size_t  bucket_count,
const hasher hash,
const allocator_type alloc 
)
inline

Definition at line 788 of file raw_hash_set.h.

◆ raw_hash_set() [13/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( std::initializer_list< init_type init,
size_t  bucket_count,
const hasher hash,
const allocator_type alloc 
)
inline

Definition at line 792 of file raw_hash_set.h.

◆ raw_hash_set() [14/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( std::initializer_list< T >  init,
size_t  bucket_count,
const allocator_type alloc 
)
inline

Definition at line 797 of file raw_hash_set.h.

◆ raw_hash_set() [15/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( std::initializer_list< init_type init,
size_t  bucket_count,
const allocator_type alloc 
)
inline

Definition at line 801 of file raw_hash_set.h.

◆ raw_hash_set() [16/21]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( std::initializer_list< T >  init,
const allocator_type alloc 
)
inline

Definition at line 806 of file raw_hash_set.h.

◆ raw_hash_set() [17/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( std::initializer_list< init_type init,
const allocator_type alloc 
)
inline

Definition at line 809 of file raw_hash_set.h.

◆ raw_hash_set() [18/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( const raw_hash_set< Policy, Hash, Eq, Alloc > &  that)
inline

Definition at line 813 of file raw_hash_set.h.

◆ raw_hash_set() [19/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( const raw_hash_set< Policy, Hash, Eq, Alloc > &  that,
const allocator_type a 
)
inline

Definition at line 817 of file raw_hash_set.h.

◆ raw_hash_set() [20/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( raw_hash_set< Policy, Hash, Eq, Alloc > &&  that)
inlinenoexcept

Definition at line 833 of file raw_hash_set.h.

◆ raw_hash_set() [21/21]

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( raw_hash_set< Policy, Hash, Eq, Alloc > &&  that,
const allocator_type a 
)
inline

Definition at line 850 of file raw_hash_set.h.

◆ ~raw_hash_set()

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

Definition at line 891 of file raw_hash_set.h.

Member Function Documentation

◆ alloc_ref() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
allocator_type& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::alloc_ref ( )
inlineprivate

Definition at line 1765 of file raw_hash_set.h.

◆ alloc_ref() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
const allocator_type& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::alloc_ref ( ) const
inlineprivate

Definition at line 1766 of file raw_hash_set.h.

◆ begin() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::begin ( )
inline

Definition at line 893 of file raw_hash_set.h.

◆ begin() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
const_iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::begin ( ) const
inline

Definition at line 900 of file raw_hash_set.h.

◆ bucket_count()

template<class Policy, class Hash, class Eq, class Alloc>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::bucket_count ( ) const
inline

Definition at line 1321 of file raw_hash_set.h.

◆ capacity()

template<class Policy, class Hash, class Eq, class Alloc>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::capacity ( ) const
inline

Definition at line 909 of file raw_hash_set.h.

◆ cbegin()

template<class Policy, class Hash, class Eq, class Alloc>
const_iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::cbegin ( ) const
inline

Definition at line 904 of file raw_hash_set.h.

◆ cend()

template<class Policy, class Hash, class Eq, class Alloc>
const_iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::cend ( ) const
inline

Definition at line 905 of file raw_hash_set.h.

◆ clear()

template<class Policy, class Hash, class Eq, class Alloc>
ABSL_ATTRIBUTE_REINITIALIZES void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::clear ( )
inline

Definition at line 912 of file raw_hash_set.h.

◆ contains()

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
bool absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::contains ( const key_arg< K > &  key) const
inline

Definition at line 1303 of file raw_hash_set.h.

◆ count()

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::count ( const key_arg< K > &  key) const
inline

Definition at line 1247 of file raw_hash_set.h.

◆ destroy_slots()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::destroy_slots ( )
inlineprivate

Definition at line 1465 of file raw_hash_set.h.

◆ drop_deletes_without_resize()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::drop_deletes_without_resize ( )
inlineprivate

Definition at line 1513 of file raw_hash_set.h.

◆ emplace() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class... Args, typename std::enable_if< IsDecomposable< Args... >::value, int >::type = 0>
std::pair<iterator, bool> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace ( Args &&...  args)
inline

Definition at line 1042 of file raw_hash_set.h.

◆ emplace() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class... Args, typename std::enable_if< !IsDecomposable< Args... >::value, int >::type = 0>
std::pair<iterator, bool> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace ( Args &&...  args)
inline

Definition at line 1052 of file raw_hash_set.h.

◆ emplace_at()

template<class Policy, class Hash, class Eq, class Alloc>
template<class... Args>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_at ( size_t  i,
Args &&...  args 
)
inlineprotected

Definition at line 1697 of file raw_hash_set.h.

◆ emplace_hint()

template<class Policy, class Hash, class Eq, class Alloc>
template<class... Args>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_hint ( const_iterator  ,
Args &&...  args 
)
inline

Definition at line 1063 of file raw_hash_set.h.

◆ empty()

template<class Policy, class Hash, class Eq, class Alloc>
bool absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::empty ( ) const
inline

Definition at line 907 of file raw_hash_set.h.

◆ end() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::end ( )
inline

Definition at line 898 of file raw_hash_set.h.

◆ end() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
const_iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::end ( ) const
inline

Definition at line 903 of file raw_hash_set.h.

◆ eq_ref() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
key_equal& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::eq_ref ( )
inlineprivate

Definition at line 1763 of file raw_hash_set.h.

◆ eq_ref() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
const key_equal& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::eq_ref ( ) const
inlineprivate

Definition at line 1764 of file raw_hash_set.h.

◆ equal_range() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
std::pair<iterator, iterator> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::equal_range ( const key_arg< K > &  key)
inline

Definition at line 1308 of file raw_hash_set.h.

◆ equal_range() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
std::pair<const_iterator, const_iterator> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::equal_range ( const key_arg< K > &  key) const
inline

Definition at line 1314 of file raw_hash_set.h.

◆ erase() [1/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
size_type absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::erase ( const key_arg< K > &  key)
inline

Definition at line 1128 of file raw_hash_set.h.

◆ erase() [2/4]

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::erase ( const_iterator  cit)
inline

Definition at line 1147 of file raw_hash_set.h.

◆ erase() [3/4]

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::erase ( iterator  it)
inline

Definition at line 1151 of file raw_hash_set.h.

◆ erase() [4/4]

template<class Policy, class Hash, class Eq, class Alloc>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::erase ( const_iterator  first,
const_iterator  last 
)
inline

Definition at line 1157 of file raw_hash_set.h.

◆ erase_meta_only()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::erase_meta_only ( const_iterator  it)
inlineprivate

Definition at line 1417 of file raw_hash_set.h.

◆ extract() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
node_type absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::extract ( const_iterator  position)
inline

Definition at line 1183 of file raw_hash_set.h.

◆ extract() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, typename std::enable_if<!std::is_same< K, iterator >::value, int >::type = 0>
node_type absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::extract ( const key_arg< K > &  key)
inline

Definition at line 1193 of file raw_hash_set.h.

◆ find() [1/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::find ( const key_arg< K > &  key,
size_t  hash 
)
inline

Definition at line 1274 of file raw_hash_set.h.

◆ find() [2/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::find ( const key_arg< K > &  key)
inline

Definition at line 1289 of file raw_hash_set.h.

◆ find() [3/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
const_iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::find ( const key_arg< K > &  key,
size_t  hash 
) const
inline

Definition at line 1294 of file raw_hash_set.h.

◆ find() [4/4]

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
const_iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::find ( const key_arg< K > &  key) const
inline

Definition at line 1298 of file raw_hash_set.h.

◆ find_first_non_full()

template<class Policy, class Hash, class Eq, class Alloc>
FindInfo absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::find_first_non_full ( size_t  hash)
inlineprivate

Definition at line 1621 of file raw_hash_set.h.

◆ find_or_prepare_insert()

template<class Policy, class Hash, class Eq, class Alloc>
template<class K >
std::pair<size_t, bool> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::find_or_prepare_insert ( const K &  key)
inlineprotected

Definition at line 1657 of file raw_hash_set.h.

◆ get_allocator()

template<class Policy, class Hash, class Eq, class Alloc>
allocator_type absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::get_allocator ( ) const
inline

Definition at line 1332 of file raw_hash_set.h.

◆ growth_left()

template<class Policy, class Hash, class Eq, class Alloc>
size_t& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::growth_left ( )
inlineprivate

Definition at line 1743 of file raw_hash_set.h.

◆ has_element()

template<class Policy, class Hash, class Eq, class Alloc>
bool absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::has_element ( const value_type elem) const
inlineprivate

Definition at line 1591 of file raw_hash_set.h.

◆ hash_function()

template<class Policy, class Hash, class Eq, class Alloc>
hasher absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::hash_function ( ) const
inline

Definition at line 1330 of file raw_hash_set.h.

◆ hash_ref() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
hasher& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::hash_ref ( )
inlineprivate

Definition at line 1761 of file raw_hash_set.h.

◆ hash_ref() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
const hasher& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::hash_ref ( ) const
inlineprivate

Definition at line 1762 of file raw_hash_set.h.

◆ initialize_slots()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::initialize_slots ( )
inlineprivate

Definition at line 1438 of file raw_hash_set.h.

◆ insert() [1/11]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< T >::value, int >::type = 0, T * = nullptr>
std::pair<iterator, bool> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( T &&  value)
inline

Definition at line 944 of file raw_hash_set.h.

◆ insert() [2/11]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< const T &>::value, int >::type = 0>
std::pair<iterator, bool> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( const T &  value)
inline

Definition at line 965 of file raw_hash_set.h.

◆ insert() [3/11]

template<class Policy, class Hash, class Eq, class Alloc>
std::pair<iterator, bool> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( init_type &&  value)
inline

Definition at line 974 of file raw_hash_set.h.

◆ insert() [4/11]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< T >::value, int >::type = 0, T * = nullptr>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( const_iterator  ,
T &&  value 
)
inline

Definition at line 981 of file raw_hash_set.h.

◆ insert() [5/11]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< const T &>::value, int >::type = 0>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( const_iterator  ,
const T &  value 
)
inline

Definition at line 991 of file raw_hash_set.h.

◆ insert() [6/11]

template<class Policy, class Hash, class Eq, class Alloc>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( const_iterator  ,
init_type &&  value 
)
inline

Definition at line 995 of file raw_hash_set.h.

◆ insert() [7/11]

template<class Policy, class Hash, class Eq, class Alloc>
template<class InputIt >
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( InputIt  first,
InputIt  last 
)
inline

Definition at line 1000 of file raw_hash_set.h.

◆ insert() [8/11]

template<class Policy, class Hash, class Eq, class Alloc>
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< const T &> = 0>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( std::initializer_list< T >  ilist)
inline

Definition at line 1005 of file raw_hash_set.h.

◆ insert() [9/11]

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( std::initializer_list< init_type ilist)
inline

Definition at line 1009 of file raw_hash_set.h.

◆ insert() [10/11]

template<class Policy, class Hash, class Eq, class Alloc>
insert_return_type absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( node_type &&  node)
inline

Definition at line 1013 of file raw_hash_set.h.

◆ insert() [11/11]

template<class Policy, class Hash, class Eq, class Alloc>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( const_iterator  ,
node_type &&  node 
)
inline

Definition at line 1027 of file raw_hash_set.h.

◆ is_small()

template<class Policy, class Hash, class Eq, class Alloc>
bool absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::is_small ( ) const
inlineprivate

Definition at line 1759 of file raw_hash_set.h.

◆ iterator_at() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::iterator_at ( size_t  i)
inlineprotected

Definition at line 1706 of file raw_hash_set.h.

◆ iterator_at() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
const_iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::iterator_at ( size_t  i) const
inlineprotected

Definition at line 1707 of file raw_hash_set.h.

◆ key_eq()

template<class Policy, class Hash, class Eq, class Alloc>
key_equal absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::key_eq ( ) const
inline

Definition at line 1331 of file raw_hash_set.h.

◆ KeyTypeCanBeEq()

template<class Policy, class Hash, class Eq, class Alloc>
auto absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::KeyTypeCanBeEq ( const Eq &  eq,
const key_type k 
) -> decltype(eq(k, k))
private

◆ KeyTypeCanBeHashed()

template<class Policy, class Hash, class Eq, class Alloc>
auto absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::KeyTypeCanBeHashed ( const Hash h,
const key_type k 
) -> decltype(h(k))
private

◆ lazy_emplace()

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type, class F >
iterator absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::lazy_emplace ( const key_arg< K > &  key,
F &&  f 
)
inline

Definition at line 1108 of file raw_hash_set.h.

◆ load_factor()

template<class Policy, class Hash, class Eq, class Alloc>
float absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::load_factor ( ) const
inline

Definition at line 1322 of file raw_hash_set.h.

◆ MakeLayout()

template<class Policy, class Hash, class Eq, class Alloc>
static Layout absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::MakeLayout ( size_t  capacity)
inlinestaticprivate

Definition at line 555 of file raw_hash_set.h.

◆ max_load_factor() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
float absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::max_load_factor ( ) const
inline

Definition at line 1325 of file raw_hash_set.h.

◆ max_load_factor() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::max_load_factor ( float  )
inline

Definition at line 1326 of file raw_hash_set.h.

◆ max_size()

template<class Policy, class Hash, class Eq, class Alloc>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::max_size ( ) const
inline

Definition at line 910 of file raw_hash_set.h.

◆ merge() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<typename H , typename E >
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::merge ( raw_hash_set< Policy, H, E, Alloc > &  src)
inline

Definition at line 1167 of file raw_hash_set.h.

◆ merge() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
template<typename H , typename E >
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::merge ( raw_hash_set< Policy, H, E, Alloc > &&  src)
inline

Definition at line 1179 of file raw_hash_set.h.

◆ move_assign() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
raw_hash_set& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::move_assign ( raw_hash_set< Policy, Hash, Eq, Alloc > &&  that,
std::true_type   
)
inlineprivate

Definition at line 1644 of file raw_hash_set.h.

◆ move_assign() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
raw_hash_set& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::move_assign ( raw_hash_set< Policy, Hash, Eq, Alloc > &&  that,
std::false_type   
)
inlineprivate

Definition at line 1649 of file raw_hash_set.h.

◆ operator=() [1/2]

template<class Policy, class Hash, class Eq, class Alloc>
raw_hash_set& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::operator= ( const raw_hash_set< Policy, Hash, Eq, Alloc > &  that)
inline

Definition at line 871 of file raw_hash_set.h.

◆ operator=() [2/2]

template<class Policy, class Hash, class Eq, class Alloc>
raw_hash_set& absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::operator= ( raw_hash_set< Policy, Hash, Eq, Alloc > &&  that)
inlinenoexcept

Definition at line 880 of file raw_hash_set.h.

◆ prefetch()

template<class Policy, class Hash, class Eq, class Alloc>
template<class K = key_type>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::prefetch ( const key_arg< K > &  key) const
inline

Definition at line 1257 of file raw_hash_set.h.

◆ prepare_insert()

template<class Policy, class Hash, class Eq, class Alloc>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::prepare_insert ( size_t  hash)
inlineprotected

Definition at line 1674 of file raw_hash_set.h.

◆ probe()

template<class Policy, class Hash, class Eq, class Alloc>
probe_seq<Group::kWidth> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::probe ( size_t  hash) const
inlineprivate

Definition at line 1712 of file raw_hash_set.h.

◆ rehash()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::rehash ( size_t  n)
inline

Definition at line 1219 of file raw_hash_set.h.

◆ rehash_and_grow_if_necessary()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::rehash_and_grow_if_necessary ( )
inlineprivate

Definition at line 1579 of file raw_hash_set.h.

◆ reserve()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::reserve ( size_t  n)
inline

Definition at line 1235 of file raw_hash_set.h.

◆ reset_ctrl()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::reset_ctrl ( )
inlineprivate

Definition at line 1717 of file raw_hash_set.h.

◆ reset_growth_left()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::reset_growth_left ( )
inlineprivate

Definition at line 1723 of file raw_hash_set.h.

◆ resize()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::resize ( size_t  new_capacity)
inlineprivate

Definition at line 1483 of file raw_hash_set.h.

◆ set_ctrl()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::set_ctrl ( size_t  i,
ctrl_t  h 
)
inlineprivate

Definition at line 1729 of file raw_hash_set.h.

◆ size()

template<class Policy, class Hash, class Eq, class Alloc>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::size ( ) const
inline

Definition at line 908 of file raw_hash_set.h.

◆ swap()

template<class Policy, class Hash, class Eq, class Alloc>
void absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::swap ( raw_hash_set< Policy, Hash, Eq, Alloc > &  that)
inlinenoexcept

Definition at line 1198 of file raw_hash_set.h.

Friends And Related Function Documentation

◆ absl::container_internal::hashtable_debug_internal::HashtableDebugAccess

template<class Policy, class Hash, class Eq, class Alloc>
template<class Container , typename Enabler >
friend struct absl::container_internal::hashtable_debug_internal:: HashtableDebugAccess
friend

Definition at line 1356 of file raw_hash_set.h.

◆ operator!=

template<class Policy, class Hash, class Eq, class Alloc>
bool operator!= ( const raw_hash_set< Policy, Hash, Eq, Alloc > &  a,
const raw_hash_set< Policy, Hash, Eq, Alloc > &  b 
)
friend

Definition at line 1344 of file raw_hash_set.h.

◆ operator==

template<class Policy, class Hash, class Eq, class Alloc>
bool operator== ( const raw_hash_set< Policy, Hash, Eq, Alloc > &  a,
const raw_hash_set< Policy, Hash, Eq, Alloc > &  b 
)
friend

Definition at line 1334 of file raw_hash_set.h.

◆ RawHashSetTestOnlyAccess

template<class Policy, class Hash, class Eq, class Alloc>
friend struct RawHashSetTestOnlyAccess
friend

Definition at line 1710 of file raw_hash_set.h.

◆ swap

template<class Policy, class Hash, class Eq, class Alloc>
void swap ( raw_hash_set< Policy, Hash, Eq, Alloc > &  a,
raw_hash_set< Policy, Hash, Eq, Alloc > &  b 
)
friend

Definition at line 1348 of file raw_hash_set.h.

Member Data Documentation

◆ capacity_

template<class Policy, class Hash, class Eq, class Alloc>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::capacity_ = 0
private

Definition at line 1776 of file raw_hash_set.h.

◆ ctrl_

template<class Policy, class Hash, class Eq, class Alloc>
ctrl_t* absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::ctrl_ = EmptyGroup()
private

Definition at line 1773 of file raw_hash_set.h.

◆ infoz_

template<class Policy, class Hash, class Eq, class Alloc>
HashtablezInfoHandle absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::infoz_
private

Definition at line 1777 of file raw_hash_set.h.

◆ settings_

template<class Policy, class Hash, class Eq, class Alloc>
absl::container_internal::CompressedTuple<size_t , hasher, key_equal, allocator_type> absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::settings_ {0, hasher{}, key_equal{}, allocator_type{}}
private

Definition at line 1780 of file raw_hash_set.h.

◆ size_

template<class Policy, class Hash, class Eq, class Alloc>
size_t absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::size_ = 0
private

Definition at line 1775 of file raw_hash_set.h.

◆ slots_

template<class Policy, class Hash, class Eq, class Alloc>
slot_type* absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >::slots_ = nullptr
private

Definition at line 1774 of file raw_hash_set.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