#include <phmap.h>

类 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc > 继承关系图:

类
class	const_iterator

class	constructor

struct	EmplaceDecomposable

struct	EmplaceDecomposableHashval

struct	EqualElement

struct	FindElement

struct	FindInfo

struct	has_difference_operator

struct	HashElement

struct	InsertSlot

struct	InsertSlotWithHash

class	iterator

struct	SameAsElementReference

Public 类型
using	init_type = typename PolicyTraits::init_type

using	key_type = typename PolicyTraits::key_type

using	slot_type = typename PolicyTraits::slot_type

using	allocator_type = Alloc

using	size_type = size_t

using	difference_type = ptrdiff_t

using	hasher = Hash

using	key_equal = Eq

using	policy_type = Policy

using	value_type = typename PolicyTraits::value_type

using	reference = value_type&

using	const_reference = const value_type&

using	pointer

using	const_pointer

template<class K >
using	key_arg = typename KeyArgImpl::template type<K, key_type>

using	node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>

using	insert_return_type = InsertReturnType<iterator, node_type>

template<typename It >
using	IsRandomAccess

Public 成员函数
	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_cnt, const hasher &hashfn=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())

	raw_hash_set (size_t bucket_cnt, const hasher &hashfn, const allocator_type &alloc)

	raw_hash_set (size_t bucket_cnt, const allocator_type &alloc)

	raw_hash_set (const allocator_type &alloc)

template<class InputIter >
	raw_hash_set (InputIter first, InputIter last, size_t bucket_cnt=0, const hasher &hashfn=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_cnt, const hasher &hashfn, const allocator_type &alloc)

template<class InputIter >
	raw_hash_set (InputIter first, InputIter last, size_t bucket_cnt, 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_cnt=0, const hasher &hashfn=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_cnt=0, const hasher &hashfn=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_cnt, const hasher &hashfn, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< init_type > init, size_t bucket_cnt, const hasher &hashfn, const allocator_type &alloc)

template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
	raw_hash_set (std::initializer_list< T > init, size_t bucket_cnt, const allocator_type &alloc)

	raw_hash_set (std::initializer_list< init_type > init, size_t bucket_cnt, 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)

raw_hash_set &	operator= (const raw_hash_set &that)

raw_hash_set &	operator= (raw_hash_set &&that) noexcept(phmap::allocator_traits< allocator_type >::is_always_equal::value &&std::is_nothrow_move_assignable< hasher >::value &&std::is_nothrow_move_assignable< key_equal >::value)

	~raw_hash_set ()

iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

const_iterator	cbegin () const

const_iterator	cend () const

bool	empty () const

size_t	size () const

size_t	capacity () const

size_t	max_size () const

PHMAP_ATTRIBUTE_REINITIALIZES void	clear ()

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 , typename phmap::enable_if_t< has_difference_operator< InputIt >::value, int > = 0>
void	insert (InputIt first, InputIt last)

template<class InputIt , typename phmap::enable_if_t<!has_difference_operator< InputIt >::value, int > = 0>
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)

insert_return_type	insert (node_type &&node, size_t hashval)

iterator	insert (const_iterator, node_type &&node)

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_with_hash (size_t hashval, 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, typename std::enable_if<!IsDecomposable< Args... >::value, int >::type = 0>
std::pair< iterator, bool >	emplace_with_hash (size_t hashval, Args &&... args)

template<class... Args>
iterator	emplace_hint (const_iterator, Args &&... args)

template<class... Args>
iterator	emplace_hint_with_hash (size_t hashval, const_iterator, Args &&... args)

template<class K = key_type, class F >
iterator	lazy_emplace (const key_arg< K > &key, F &&f)

template<class K = key_type, class F >
iterator	lazy_emplace_with_hash (const key_arg< K > &key, size_t hashval, F &&f)

template<class K = key_type, class F >
void	lazy_emplace_at (size_t &idx, F &&f)

template<class K = key_type, class F >
void	emplace_single_with_hash (const key_arg< K > &key, size_t hashval, F &&f)

template<class K = key_type>
size_type	erase (const key_arg< K > &key)

iterator	erase (const_iterator cit)

void	_erase (iterator it)

void	_erase (const_iterator cit)

iterator	erase (iterator it)

iterator	erase (const_iterator first, const_iterator last)

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)

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)

void	swap (raw_hash_set &that) noexcept(IsNoThrowSwappable< hasher >() &&IsNoThrowSwappable< key_equal >() &&(!AllocTraits::propagate_on_container_swap::value\|\|IsNoThrowSwappable< allocator_type >()))

template<typename OutputArchive >
bool	phmap_dump (OutputArchive &) const

template<typename InputArchive >
bool	phmap_load (InputArchive &)

void	rehash (size_t n)

void	reserve (size_t n)

template<class K = key_type>
size_t	count (const key_arg< K > &key) const

void	prefetch_hash (size_t hashval) const

template<class K = key_type>
void	prefetch (const key_arg< K > &key) const

template<class K = key_type>
iterator	find (const key_arg< K > &key, size_t hashval)

template<class K = key_type>
pointer	find_ptr (const key_arg< K > &key, size_t hashval)

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 hashval) const

template<class K = key_type>
const_iterator	find (const key_arg< K > &key) const

template<class K = key_type>
bool	contains (const key_arg< K > &key) const

template<class K = key_type>
bool	contains (const key_arg< K > &key, size_t hashval) 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

size_t	bucket_count () const

float	load_factor () const

float	max_load_factor () const

void	max_load_factor (float)

hasher	hash_function () const

key_equal	key_eq () const

allocator_type	get_allocator () const

template<class K >
size_t	hash (const K &key) const

Protected 成员函数
template<class K >
std::pair< size_t, bool >	find_or_prepare_insert (const K &key, size_t hashval)

template<class K >
std::pair< size_t, bool >	find_or_prepare_insert (const K &key)

size_t	prepare_insert (size_t hashval) PHMAP_ATTRIBUTE_NOINLINE

template<class... Args>
void	emplace_at (size_t i, Args &&... args)

iterator	iterator_at (size_t i)

const_iterator	iterator_at (size_t i) const

Private 类型
using	PolicyTraits = hash_policy_traits<Policy>

using	KeyArgImpl

using	Layout = phmap::priv::Layout<ctrl_t, slot_type>

using	AllocTraits = phmap::allocator_traits<allocator_type>

using	SlotAlloc

using	SlotAllocTraits

template<class T >
using	RequiresInsertable

template<class T >
using	RequiresNotInit

template<class... Ts>
using	IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>

Private 成员函数
auto	KeyTypeCanBeHashed (const Hash &h, const key_type &k) -> decltype(h(k))

auto	KeyTypeCanBeEq (const Eq &eq, const key_type &k) -> decltype(eq(k, k))

template<class K = key_type>
bool	find_impl (const key_arg< K > &key, size_t hashval, size_t &offset)

template<class K , class... Args>
std::pair< iterator, bool >	emplace_decomposable (const K &key, size_t hashval, Args &&... args)

void	erase_meta_only (const_iterator it)

void	initialize_slots (size_t new_capacity)

void	destroy_slots ()

void	resize (size_t new_capacity)

void	drop_deletes_without_resize () PHMAP_ATTRIBUTE_NOINLINE

void	rehash_and_grow_if_necessary ()

bool	has_element (const value_type &elem, size_t hashval) const

bool	has_element (const value_type &elem) const

FindInfo	find_first_non_full (size_t hashval)

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 hashval) const

void	reset_ctrl (size_t capacity)

void	reset_growth_left (size_t capacity)

void	set_ctrl (size_t i, ctrl_t h)

size_t &	growth_left ()

bool	is_small () const

hasher &	hash_ref ()

const hasher &	hash_ref () const

key_equal &	eq_ref ()

const key_equal &	eq_ref () const

allocator_type &	alloc_ref ()

const allocator_type &	alloc_ref () const

静态 Private 成员函数
static Layout	MakeLayout (size_t capacity)

Private 属性
ctrl_t *	ctrl_ = EmptyGroup()

slot_type *	slots_ = nullptr

size_t	size_ = 0

size_t	capacity_ = 0

HashtablezInfoHandle	infoz_

phmap::priv::CompressedTuple< size_t, hasher, key_equal, allocator_type >	settings_ {0, hasher{}, key_equal{}, allocator_type{}}

友元
template<class Container , typename Enabler >
struct	phmap::priv::hashtable_debug_internal::HashtableDebugAccess

struct	RawHashSetTestOnlyAccess

template<size_t N, template< class, class, class, class > class RefSet, class M , class P , class H , class E , class A >
class	parallel_hash_set

template<size_t N, template< class, class, class, class > class RefSet, class M , class P , class H , class E , class A >
class	parallel_hash_map

bool	operator== (const raw_hash_set &a, const raw_hash_set &b)

bool	operator!= (const raw_hash_set &a, const raw_hash_set &b)

void	swap (raw_hash_set &a, raw_hash_set &b) noexcept(noexcept(a.swap(b)))

成员类型定义说明

◆ allocator_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::allocator_type = Alloc

◆ AllocTraits

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::AllocTraits = phmap::allocator_traits<allocator_type>

private

◆ const_pointer

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::const_pointer

初始值:

typename phmap::allocator_traits<

allocator_type>::template rebind_traits<value_type>::const_pointer

phmap::priv::raw_hash_set::allocator_type

Alloc allocator_type

Definition phmap.h:850

phmap::allocator_traits

Definition phmap_base.h:1379

◆ const_reference

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::const_reference = const value_type&

◆ difference_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::difference_type = ptrdiff_t

◆ hasher

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::hasher = Hash

◆ init_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::init_type = typename PolicyTraits::init_type

◆ insert_return_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert_return_type = InsertReturnType<iterator, node_type>

◆ IsDecomposable

template<class Policy , class Hash , class Eq , class Alloc >

template<class... Ts>

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>

private

◆ IsRandomAccess

template<class Policy , class Hash , class Eq , class Alloc >

template<typename It >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::IsRandomAccess

初始值:

std::is_same<typename std::iterator_traits<It>::iterator_category,

std::random_access_iterator_tag>

◆ key_arg

template<class Policy , class Hash , class Eq , class Alloc >

template<class K >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::key_arg = typename KeyArgImpl::template type<K, key_type>

◆ key_equal

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::key_equal = Eq

◆ key_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::key_type = typename PolicyTraits::key_type

◆ KeyArgImpl

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::KeyArgImpl

private

初始值:

KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>

◆ Layout

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::Layout = phmap::priv::Layout<ctrl_t, slot_type>

private

◆ node_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>

◆ pointer

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::pointer

初始值:

typename phmap::allocator_traits<

allocator_type>::template rebind_traits<value_type>::pointer

◆ policy_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::policy_type = Policy

◆ PolicyTraits

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::PolicyTraits = hash_policy_traits<Policy>

private

◆ reference

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::reference = value_type&

◆ RequiresInsertable

template<class Policy , class Hash , class Eq , class Alloc >

template<class T >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::RequiresInsertable

private

初始值:

 typename std::enable_if<
        phmap::disjunction<std::is_convertible<T, init_type>,
                           SameAsElementReference<T>>::value,
        int>::type

◆ RequiresNotInit

template<class Policy , class Hash , class Eq , class Alloc >

template<class T >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::RequiresNotInit

private

初始值:

typename std::enable_if<!std::is_same<T, init_type>::value, int>::type

◆ size_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::size_type = size_t

◆ slot_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::slot_type = typename PolicyTraits::slot_type

◆ SlotAlloc

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::SlotAlloc

private

初始值:

typename phmap::allocator_traits<

allocator_type>::template rebind_alloc<slot_type>

◆ SlotAllocTraits

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::SlotAllocTraits

private

初始值:

typename phmap::allocator_traits<

allocator_type>::template rebind_traits<slot_type>

◆ value_type

template<class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::value_type = typename PolicyTraits::value_type

构造及析构函数说明

◆ raw_hash_set() [1/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( )

inlinenoexcept

◆ raw_hash_set() [2/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	size_t	bucket_cnt,
		const hasher &	hashfn = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inlineexplicit

◆ raw_hash_set() [3/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	size_t	bucket_cnt,
		const hasher &	hashfn,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [4/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	size_t	bucket_cnt,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [5/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( const allocator_type & alloc )

inlineexplicit

◆ raw_hash_set() [6/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	InputIter	first,
		InputIter	last,
		size_t	bucket_cnt = 0,
		const hasher &	hashfn = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inline

◆ raw_hash_set() [7/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	InputIter	first,
		InputIter	last,
		size_t	bucket_cnt,
		const hasher &	hashfn,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [8/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	InputIter	first,
		InputIter	last,
		size_t	bucket_cnt,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [9/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	InputIter	first,
		InputIter	last,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [10/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< T >	init,
		size_t	bucket_cnt = 0,
		const hasher &	hashfn = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inline

◆ raw_hash_set() [11/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< init_type >	init,
		size_t	bucket_cnt = 0,
		const hasher &	hashfn = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inline

◆ raw_hash_set() [12/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< T >	init,
		size_t	bucket_cnt,
		const hasher &	hashfn,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [13/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< init_type >	init,
		size_t	bucket_cnt,
		const hasher &	hashfn,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [14/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< T >	init,
		size_t	bucket_cnt,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [15/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< init_type >	init,
		size_t	bucket_cnt,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [16/21]

template<class Policy , class Hash , class Eq , class Alloc >

template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< T >	init,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [17/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	std::initializer_list< init_type >	init,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [18/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( const raw_hash_set< Policy, Hash, Eq, Alloc > & that )

inline

◆ raw_hash_set() [19/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	const raw_hash_set< Policy, Hash, Eq, Alloc > &	that,
		const allocator_type &	a )

inline

◆ raw_hash_set() [20/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set ( raw_hash_set< Policy, Hash, Eq, Alloc > && that )

inlinenoexcept

◆ raw_hash_set() [21/21]

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::raw_hash_set	(	raw_hash_set< Policy, Hash, Eq, Alloc > &&	that,
		const allocator_type &	a )

inline

◆ ~raw_hash_set()

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::~raw_hash_set ( )

inline

成员函数说明

◆ _erase() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::_erase ( const_iterator cit )

inline

◆ _erase() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::_erase ( iterator it )

inline

◆ alloc_ref() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

allocator_type & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::alloc_ref ( )

inlineprivate

◆ alloc_ref() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

const allocator_type & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::alloc_ref ( ) const

inlineprivate

◆ begin() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::begin ( )

inline

◆ begin() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::begin ( ) const

inline

◆ bucket_count()

template<class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::bucket_count ( ) const

inline

◆ capacity()

template<class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::capacity ( ) const

inline

◆ cbegin()

template<class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::cbegin ( ) const

inline

◆ cend()

template<class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::cend ( ) const

inline

◆ clear()

template<class Policy , class Hash , class Eq , class Alloc >

PHMAP_ATTRIBUTE_REINITIALIZES void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::clear ( )

inline

◆ contains() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::contains ( const key_arg< K > & key ) const

inline

◆ contains() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::contains	(	const key_arg< K > &	key,
		size_t	hashval ) const

inline

◆ count()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::count ( const key_arg< K > & key ) const

inline

◆ destroy_slots()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::destroy_slots ( )

inlineprivate

◆ drop_deletes_without_resize()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::drop_deletes_without_resize ( )

inlineprivate

◆ 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 > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace ( Args &&... args )

inline

◆ 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 > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace ( Args &&... args )

inline

◆ emplace_at()

template<class Policy , class Hash , class Eq , class Alloc >

template<class... Args>

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_at	(	size_t	i,
		Args &&...	args )

inlineprotected

◆ emplace_decomposable()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K , class... Args>

std::pair< iterator, bool > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_decomposable	(	const K &	key,
		size_t	hashval,
		Args &&...	args )

inlineprivate

◆ emplace_hint()

template<class Policy , class Hash , class Eq , class Alloc >

template<class... Args>

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_hint	(	const_iterator	,
		Args &&...	args )

inline

◆ emplace_hint_with_hash()

template<class Policy , class Hash , class Eq , class Alloc >

template<class... Args>

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_hint_with_hash	(	size_t	hashval,
		const_iterator	,
		Args &&...	args )

inline

◆ emplace_single_with_hash()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_single_with_hash	(	const key_arg< K > &	key,
		size_t	hashval,
		F &&	f )

inline

◆ emplace_with_hash() [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 > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_with_hash	(	size_t	hashval,
		Args &&...	args )

inline

◆ emplace_with_hash() [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 > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::emplace_with_hash	(	size_t	hashval,
		Args &&...	args )

inline

◆ empty()

template<class Policy , class Hash , class Eq , class Alloc >

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::empty ( ) const

inline

◆ end() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::end ( )

inline

◆ end() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::end ( ) const

inline

◆ eq_ref() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

key_equal & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::eq_ref ( )

inlineprivate

◆ eq_ref() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

const key_equal & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::eq_ref ( ) const

inlineprivate

◆ equal_range() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

std::pair< iterator, iterator > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::equal_range ( const key_arg< K > & key )

inline

◆ equal_range() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

std::pair< const_iterator, const_iterator > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::equal_range ( const key_arg< K > & key ) const

inline

◆ erase() [1/4]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

size_type phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::erase ( const key_arg< K > & key )

inline

◆ erase() [2/4]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::erase ( const_iterator cit )

inline

◆ erase() [3/4]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::erase	(	const_iterator	first,
		const_iterator	last )

inline

◆ erase() [4/4]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::erase ( iterator it )

inline

◆ erase_meta_only()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::erase_meta_only ( const_iterator it )

inlineprivate

◆ extract() [1/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 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::extract ( const key_arg< K > & key )

inline

◆ extract() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

node_type phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::extract ( const_iterator position )

inline

◆ find() [1/4]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find ( const key_arg< K > & key )

inline

◆ find() [2/4]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

const_iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find ( const key_arg< K > & key ) const

inline

◆ find() [3/4]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find	(	const key_arg< K > &	key,
		size_t	hashval )

inline

◆ find() [4/4]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

const_iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find	(	const key_arg< K > &	key,
		size_t	hashval ) const

inline

◆ find_first_non_full()

template<class Policy , class Hash , class Eq , class Alloc >

FindInfo phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find_first_non_full ( size_t hashval )

inlineprivate

◆ find_impl()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find_impl	(	const key_arg< K > &	key,
		size_t	hashval,
		size_t &	offset )

inlineprivate

◆ find_or_prepare_insert() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K >

std::pair< size_t, bool > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find_or_prepare_insert ( const K & key )

inlineprotected

◆ find_or_prepare_insert() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<class K >

std::pair< size_t, bool > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find_or_prepare_insert	(	const K &	key,
		size_t	hashval )

inlineprotected

◆ find_ptr()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

pointer phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::find_ptr	(	const key_arg< K > &	key,
		size_t	hashval )

inline

◆ get_allocator()

template<class Policy , class Hash , class Eq , class Alloc >

allocator_type phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::get_allocator ( ) const

inline

◆ growth_left()

template<class Policy , class Hash , class Eq , class Alloc >

size_t & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::growth_left ( )

inlineprivate

◆ has_element() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::has_element ( const value_type & elem ) const

inlineprivate

◆ has_element() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::has_element	(	const value_type &	elem,
		size_t	hashval ) const

inlineprivate

◆ hash()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::hash ( const K & key ) const

inline

◆ hash_function()

template<class Policy , class Hash , class Eq , class Alloc >

hasher phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::hash_function ( ) const

inline

◆ hash_ref() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

hasher & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::hash_ref ( )

inlineprivate

◆ hash_ref() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

const hasher & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::hash_ref ( ) const

inlineprivate

◆ initialize_slots()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::initialize_slots ( size_t new_capacity )

inlineprivate

◆ insert() [1/13]

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 > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( const T & value )

inline

◆ insert() [2/13]

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 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert	(	const_iterator	,
		const T &	value )

inline

◆ insert() [3/13]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert	(	const_iterator	,
		init_type &&	value )

inline

◆ insert() [4/13]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert	(	const_iterator	,
		node_type &&	node )

inline

◆ insert() [5/13]

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 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert	(	const_iterator	,
		T &&	value )

inline

◆ insert() [6/13]

template<class Policy , class Hash , class Eq , class Alloc >

std::pair< iterator, bool > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( init_type && value )

inline

◆ insert() [7/13]

template<class Policy , class Hash , class Eq , class Alloc >

template<class InputIt , typename phmap::enable_if_t< has_difference_operator< InputIt >::value, int > = 0>

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert	(	InputIt	first,
		InputIt	last )

inline

◆ insert() [8/13]

template<class Policy , class Hash , class Eq , class Alloc >

template<class InputIt , typename phmap::enable_if_t<!has_difference_operator< InputIt >::value, int > = 0>

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert	(	InputIt	first,
		InputIt	last )

inline

◆ insert() [9/13]

template<class Policy , class Hash , class Eq , class Alloc >

insert_return_type phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( node_type && node )

inline

◆ insert() [10/13]

template<class Policy , class Hash , class Eq , class Alloc >

insert_return_type phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert	(	node_type &&	node,
		size_t	hashval )

inline

◆ insert() [11/13]

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( std::initializer_list< init_type > ilist )

inline

◆ insert() [12/13]

template<class Policy , class Hash , class Eq , class Alloc >

template<class T , RequiresNotInit< T > = 0, RequiresInsertable< const T & > = 0>

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( std::initializer_list< T > ilist )

inline

◆ insert() [13/13]

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 > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::insert ( T && value )

inline

◆ is_small()

template<class Policy , class Hash , class Eq , class Alloc >

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::is_small ( ) const

inlineprivate

◆ iterator_at() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::iterator_at ( size_t i )

inlineprotected

◆ iterator_at() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::iterator_at ( size_t i ) const

inlineprotected

◆ key_eq()

template<class Policy , class Hash , class Eq , class Alloc >

key_equal phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::key_eq ( ) const

inline

◆ KeyTypeCanBeEq()

template<class Policy , class Hash , class Eq , class Alloc >

auto phmap::priv::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 phmap::priv::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 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::lazy_emplace	(	const key_arg< K > &	key,
		F &&	f )

inline

◆ lazy_emplace_at()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::lazy_emplace_at	(	size_t &	idx,
		F &&	f )

inline

◆ lazy_emplace_with_hash()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

iterator phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::lazy_emplace_with_hash	(	const key_arg< K > &	key,
		size_t	hashval,
		F &&	f )

inline

◆ load_factor()

template<class Policy , class Hash , class Eq , class Alloc >

float phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::load_factor ( ) const

inline

◆ MakeLayout()

template<class Policy , class Hash , class Eq , class Alloc >

static Layout phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::MakeLayout ( size_t capacity )

inlinestaticprivate

◆ max_load_factor() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

float phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::max_load_factor ( ) const

inline

◆ max_load_factor() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::max_load_factor ( float )

inline

◆ max_size()

template<class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::max_size ( ) const

inline

◆ merge() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<typename H , typename E >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::merge ( raw_hash_set< Policy, H, E, Alloc > && src )

inline

◆ merge() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

template<typename H , typename E >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::merge ( raw_hash_set< Policy, H, E, Alloc > & src )

inline

◆ move_assign() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

raw_hash_set & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::move_assign	(	raw_hash_set< Policy, Hash, Eq, Alloc > &&	that,
		std::false_type	)

inlineprivate

◆ move_assign() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

raw_hash_set & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::move_assign	(	raw_hash_set< Policy, Hash, Eq, Alloc > &&	that,
		std::true_type	)

inlineprivate

◆ operator=() [1/2]

template<class Policy , class Hash , class Eq , class Alloc >

raw_hash_set & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::operator= ( const raw_hash_set< Policy, Hash, Eq, Alloc > & that )

inline

◆ operator=() [2/2]

template<class Policy , class Hash , class Eq , class Alloc >

raw_hash_set & phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::operator= ( raw_hash_set< Policy, Hash, Eq, Alloc > && that )

inlinenoexcept

◆ phmap_dump()

template<class Policy , class Hash , class Eq , class Alloc >

template<typename OutputArchive >

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::phmap_dump ( OutputArchive & ar ) const

◆ phmap_load()

template<class Policy , class Hash , class Eq , class Alloc >

template<typename InputArchive >

bool phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::phmap_load ( InputArchive & ar )

◆ prefetch()

template<class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::prefetch ( const key_arg< K > & key ) const

inline

◆ prefetch_hash()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::prefetch_hash ( size_t hashval ) const

inline

◆ prepare_insert()

template<class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::prepare_insert ( size_t hashval )

inlineprotected

◆ probe()

template<class Policy , class Hash , class Eq , class Alloc >

probe_seq< Group::kWidth > phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::probe ( size_t hashval ) const

inlineprivate

◆ rehash()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::rehash ( size_t n )

inline

◆ rehash_and_grow_if_necessary()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::rehash_and_grow_if_necessary ( )

inlineprivate

◆ reserve()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::reserve ( size_t n )

inline

◆ reset_ctrl()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::reset_ctrl ( size_t capacity )

inlineprivate

◆ reset_growth_left()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::reset_growth_left ( size_t capacity )

inlineprivate

◆ resize()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::resize ( size_t new_capacity )

inlineprivate

◆ set_ctrl()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::set_ctrl	(	size_t	i,
		ctrl_t	h )

inlineprivate

◆ size()

template<class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::size ( ) const

inline

◆ swap()

template<class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::swap ( raw_hash_set< Policy, Hash, Eq, Alloc > & that )

inlinenoexcept

友元及相关函数文档

◆ 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

◆ 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

◆ parallel_hash_map

template<class Policy , class Hash , class Eq , class Alloc >

template<size_t N, template< class, class, class, class > class RefSet, class M , class P , class H , class E , class A >

friend class parallel_hash_map

friend

◆ parallel_hash_set

template<class Policy , class Hash , class Eq , class Alloc >

template<size_t N, template< class, class, class, class > class RefSet, class M , class P , class H , class E , class A >

friend class parallel_hash_set

friend

◆ phmap::priv::hashtable_debug_internal::HashtableDebugAccess

template<class Policy , class Hash , class Eq , class Alloc >

template<class Container , typename Enabler >

friend struct phmap::priv::hashtable_debug_internal::HashtableDebugAccess

friend

◆ RawHashSetTestOnlyAccess

template<class Policy , class Hash , class Eq , class Alloc >

friend struct RawHashSetTestOnlyAccess

friend

◆ 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

类成员变量说明

◆ capacity_

template<class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::capacity_ = 0

private

◆ ctrl_

template<class Policy , class Hash , class Eq , class Alloc >

ctrl_t* phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::ctrl_ = EmptyGroup()

private

◆ infoz_

template<class Policy , class Hash , class Eq , class Alloc >

HashtablezInfoHandle phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::infoz_

private

◆ settings_

template<class Policy , class Hash , class Eq , class Alloc >

phmap::priv::CompressedTuple<size_t , hasher, key_equal, allocator_type> phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::settings_ {0, hasher{}, key_equal{}, allocator_type{}}

private

◆ size_

template<class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::size_ = 0

private

◆ slots_

template<class Policy , class Hash , class Eq , class Alloc >

slot_type* phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::slots_ = nullptr

private

该类的文档由以下文件生成:

D:/GitLab/builds/wydSYb3b/0/nim-pc/california/nim-cross-platform-sdk/exports/include/phmap.h
D:/GitLab/builds/wydSYb3b/0/nim-pc/california/nim-cross-platform-sdk/exports/include/phmap_dump.h

类

Public 类型

Public 成员函数

Protected 成员函数

Private 类型

Private 成员函数

静态 Private 成员函数

Private 属性

友元

成员类型定义说明

◆ allocator_type

◆ AllocTraits

◆ const_pointer

◆ const_reference

◆ difference_type

◆ hasher

◆ init_type

◆ insert_return_type

◆ IsDecomposable

◆ IsRandomAccess

◆ key_arg

◆ key_equal

◆ key_type

◆ KeyArgImpl

◆ Layout

◆ node_type

◆ pointer

◆ policy_type

◆ PolicyTraits

◆ reference

◆ RequiresInsertable

◆ RequiresNotInit

◆ size_type

◆ slot_type

◆ SlotAlloc

◆ SlotAllocTraits

◆ value_type

构造及析构函数说明

◆ raw_hash_set() [1/21]

◆ raw_hash_set() [2/21]

◆ raw_hash_set() [3/21]

◆ raw_hash_set() [4/21]

◆ raw_hash_set() [5/21]

◆ raw_hash_set() [6/21]

◆ raw_hash_set() [7/21]

◆ raw_hash_set() [8/21]

◆ raw_hash_set() [9/21]

◆ raw_hash_set() [10/21]

◆ raw_hash_set() [11/21]

◆ raw_hash_set() [12/21]

◆ raw_hash_set() [13/21]

◆ raw_hash_set() [14/21]

◆ raw_hash_set() [15/21]

◆ raw_hash_set() [16/21]

◆ raw_hash_set() [17/21]

◆ raw_hash_set() [18/21]

◆ raw_hash_set() [19/21]

◆ raw_hash_set() [20/21]

◆ raw_hash_set() [21/21]

◆ ~raw_hash_set()

成员函数说明

◆ _erase() [1/2]

◆ _erase() [2/2]

◆ alloc_ref() [1/2]

◆ alloc_ref() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ bucket_count()

◆ capacity()

◆ cbegin()

◆ cend()

◆ clear()

◆ contains() [1/2]

◆ contains() [2/2]

◆ count()

◆ destroy_slots()

◆ drop_deletes_without_resize()

◆ emplace() [1/2]

◆ emplace() [2/2]

◆ emplace_at()