phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc > 模板类 参考

#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 = typename phmap::allocator_traits< allocator_type >::template rebind_traits< value_type >::pointer
using	const_pointer = typename phmap::allocator_traits< allocator_type >::template rebind_traits< value_type >::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 = std::is_same< typename std::iterator_traits< It >::iterator_category, std::random_access_iterator_tag >

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 = KeyArg< IsTransparent< Eq >::value &&IsTransparent< Hash >::value >
using	Layout = phmap::priv::Layout< ctrl_t, slot_type >
using	AllocTraits = phmap::allocator_traits< allocator_type >
using	SlotAlloc = typename phmap::allocator_traits< allocator_type >::template rebind_alloc< slot_type >
using	SlotAllocTraits = typename phmap::allocator_traits< allocator_type >::template rebind_traits< slot_type >
template<class T >
using	RequiresInsertable = typename std::enable_if< phmap::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
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

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 = KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>

private

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 = typename std::enable_if< phmap::disjunction<std::is_convertible<T, init_type>, SameAsElementReference<T> >::value, int>::type

private

RequiresNotInit

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

template<class T >

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::RequiresNotInit = typename std::enable_if<!std::is_same<T, init_type>::value, int>::type

private

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 = typename phmap::allocator_traits< allocator_type>::template rebind_alloc<slot_type>

private

SlotAllocTraits

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

using phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::SlotAllocTraits = typename phmap::allocator_traits< allocator_type>::template rebind_traits<slot_type>

private

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/5sbaxrcd/0/nim-pc/california/nim-cross-platform-sdk/exports/include/phmap.h
• D:/GitLab/builds/5sbaxrcd/0/nim-pc/california/nim-cross-platform-sdk/exports/include/phmap_dump.h