#include <raw_hash_set.h>

Inheritance diagram for absl::container_internal::raw_hash_set< Policy, Hash, Eq, Alloc >:

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, iterator >	equal_range (const key_arg< K > &key)

template<class K = key_type>
std::pair< const_iterator, const_iterator >	equal_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_set &	operator= (const raw_hash_set &that)

raw_hash_set &	operator= (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_type &	alloc_ref ()

const allocator_type &	alloc_ref () const

void	destroy_slots ()

void	drop_deletes_without_resize () ABSL_ATTRIBUTE_NOINLINE

key_equal &	eq_ref ()

const key_equal &	eq_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

hasher &	hash_ref ()

const hasher &	hash_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_set &	move_assign (raw_hash_set &&that, std::true_type)

raw_hash_set &	move_assign (raw_hash_set &&that, std::false_type)

probe_seq< Group::kWidth >	probe (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_t *	ctrl_ = EmptyGroup()

HashtablezInfoHandle	infoz_

absl::container_internal::CompressedTuple< size_t, hasher, key_equal, allocator_type >	settings_ {0, hasher{}, key_equal{}, allocator_type{}}

size_t	size_ = 0

slot_type *	slots_ = 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)))