phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > 模板类 参考

#include <phmap.h>

类 phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > 继承关系图:

类
class	const_iterator
struct	EmplaceDecomposable
struct	EmplaceDecomposableHashval
struct	EqualElement
struct	FindElement
struct	HashElement
struct	Inner
class	iterator
struct	ReturnKey_
struct	SameAsElementReference

Public 类型
using	EmbeddedSet = RefSet<Policy, Hash, Eq, Alloc>
using	EmbeddedIterator = typename EmbeddedSet::iterator
using	EmbeddedConstIterator = typename EmbeddedSet::const_iterator
using	constructor = typename EmbeddedSet::constructor
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>

Public 成员函数
	parallel_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)
	parallel_hash_set (size_t bucket_cnt, const hasher &hash_param=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
	parallel_hash_set (size_t bucket_cnt, const hasher &hash_param, const allocator_type &alloc)
	parallel_hash_set (size_t bucket_cnt, const allocator_type &alloc)
	parallel_hash_set (const allocator_type &alloc)
template<class InputIter >
	parallel_hash_set (InputIter first, InputIter last, size_t bucket_cnt=0, const hasher &hash_param=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
template<class InputIter >
	parallel_hash_set (InputIter first, InputIter last, size_t bucket_cnt, const hasher &hash_param, const allocator_type &alloc)
template<class InputIter >
	parallel_hash_set (InputIter first, InputIter last, size_t bucket_cnt, const allocator_type &alloc)
template<class InputIter >
	parallel_hash_set (InputIter first, InputIter last, const allocator_type &alloc)
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
	parallel_hash_set (std::initializer_list< T > init, size_t bucket_cnt=0, const hasher &hash_param=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
	parallel_hash_set (std::initializer_list< init_type > init, size_t bucket_cnt=0, const hasher &hash_param=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
	parallel_hash_set (std::initializer_list< T > init, size_t bucket_cnt, const hasher &hash_param, const allocator_type &alloc)
	parallel_hash_set (std::initializer_list< init_type > init, size_t bucket_cnt, const hasher &hash_param, const allocator_type &alloc)
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< T > = 0>
	parallel_hash_set (std::initializer_list< T > init, size_t bucket_cnt, const allocator_type &alloc)
	parallel_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>
	parallel_hash_set (std::initializer_list< T > init, const allocator_type &alloc)
	parallel_hash_set (std::initializer_list< init_type > init, const allocator_type &alloc)
	parallel_hash_set (const parallel_hash_set &that)
	parallel_hash_set (const parallel_hash_set &that, const allocator_type &a)
	parallel_hash_set (parallel_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)
	parallel_hash_set (parallel_hash_set &&that, const allocator_type &a)
parallel_hash_set &	operator= (const parallel_hash_set &that)
parallel_hash_set &	operator= (parallel_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)
	~parallel_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 ()
void	clear (std::size_t submap_index)
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< T >::value, int >::type = 0, T * = nullptr>
std::pair< iterator, bool >	insert (T &&value)
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< const T & >::value, int >::type = 0>
std::pair< iterator, bool >	insert (const T &value)
std::pair< iterator, bool >	insert (init_type &&value)
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< T >::value, int >::type = 0, T * = nullptr>
iterator	insert (const_iterator, T &&value)
template<class T , RequiresInsertable< T > = 0, typename std::enable_if< IsDecomposable< const T & >::value, int >::type = 0>
iterator	insert (const_iterator, const T &value)
iterator	insert (const_iterator, init_type &&value)
template<class InputIt >
void	insert (InputIt first, InputIt last)
template<class T , RequiresNotInit< T > = 0, RequiresInsertable< const T & > = 0>
void	insert (std::initializer_list< T > ilist)
void	insert (std::initializer_list< init_type > ilist)
insert_return_type	insert (node_type &&node)
iterator	insert (const_iterator, node_type &&node)
template<class K , class... Args>
std::pair< iterator, bool >	emplace_decomposable_with_hash (const K &key, size_t hashval, 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_with_hash (size_t hashval, 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_with_hash (const key_arg< K > &key, size_t hashval, F &&f)
template<class K , class... Args>
std::pair< iterator, bool >	emplace_decomposable (const K &key, 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 (Args &&... args)
template<class... Args>
iterator	emplace_hint (const_iterator, Args &&... args)
iterator	make_iterator (Inner *inner, const EmbeddedIterator it)
std::pair< iterator, bool >	make_rv (Inner *inner, const std::pair< EmbeddedIterator, bool > &res)
template<class K = key_type, class F >
iterator	lazy_emplace (const key_arg< K > &key, 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, class F >
void	emplace_single (const key_arg< K > &key, F &&f)
template<class K = key_type, class F >
bool	if_contains (const key_arg< K > &key, F &&f) const
template<class K = key_type, class F >
bool	if_contains_unsafe (const key_arg< K > &key, F &&f) const
template<class K = key_type, class F >
bool	modify_if (const key_arg< K > &key, F &&f)
template<class K = key_type, class F , class L >
bool	modify_if_impl (const key_arg< K > &key, F &&f)
template<class K = key_type, class F >
bool	erase_if (const key_arg< K > &key, F &&f)
template<class K = key_type, class F , class L >
bool	erase_if_impl (const key_arg< K > &key, F &&f)
template<class K = key_type, class FExists , class FEmplace >
bool	lazy_emplace_l (const key_arg< K > &key, FExists &&fExists, FEmplace &&fEmplace)
template<class F >
void	for_each (F &&fCallback) const
template<class F >
void	for_each_m (F &&fCallback)
template<class F >
void	with_submap (size_t idx, F &&fCallback) const
template<class F >
void	with_submap_m (size_t idx, F &&fCallback)
Inner &	get_inner (size_t idx)
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 E = Eq>
void	merge (parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, E, Alloc > &src)
template<typename E = Eq>
void	merge (parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, 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)
template<class Mtx2_ >
void	swap (parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > &that) noexcept(IsNoThrowSwappable< EmbeddedSet >() &&(!AllocTraits::propagate_on_container_swap::value||IsNoThrowSwappable< allocator_type >()))
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>
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
template<typename OutputArchive >
bool	phmap_dump (OutputArchive &ar) const
template<typename InputArchive >
bool	phmap_load (InputArchive &ar)

Protected 类型
using	Lockable = phmap::LockableImpl<Mtx_>

Protected 成员函数
template<class K = key_type, class L = typename Lockable::SharedLock>
pointer	find_ptr (const key_arg< K > &key, size_t hashval, L &mutexlock)
template<class K = key_type, class L = typename Lockable::SharedLock>
iterator	find (const key_arg< K > &key, size_t hashval, L &mutexlock)
template<class K >
std::tuple< Inner *, size_t, bool >	find_or_prepare_insert_with_hash (size_t hashval, const K &key, typename Lockable::UniqueLock &mutexlock)
template<class K >
std::tuple< Inner *, size_t, bool >	find_or_prepare_insert (const K &key, typename Lockable::UniqueLock &mutexlock)
iterator	iterator_at (Inner *inner, const EmbeddedIterator &it)
const_iterator	iterator_at (Inner *inner, const EmbeddedIterator &it) const

静态 Protected 成员函数
static size_t	subidx (size_t hashval)
static size_t	subcnt ()

Protected 属性
std::array< Inner, num_tables >	sets_

Private 类型
using	PolicyTraits = hash_policy_traits<Policy>
using	KeyArgImpl
using	AllocTraits = phmap::allocator_traits<allocator_type>
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))
void	erase_meta_only (const_iterator cit)
void	drop_deletes_without_resize () PHMAP_ATTRIBUTE_NOINLINE
bool	has_element (const value_type &elem) const
template<class Mtx2_ >
parallel_hash_set &	move_assign (parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > &&that, std::true_type)
template<class Mtx2_ >
parallel_hash_set &	move_assign (parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > &&that, std::false_type)
size_t	growth_left ()
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 constexpr size_t	num_tables = 1 << N
static constexpr size_t	mask = num_tables - 1

友元
template<class Container , typename Enabler >
struct	phmap::priv::hashtable_debug_internal::HashtableDebugAccess
struct	RawHashSetTestOnlyAccess
bool	operator== (const parallel_hash_set &a, const parallel_hash_set &b)
bool	operator!= (const parallel_hash_set &a, const parallel_hash_set &b)
template<class Mtx2_ >
void	swap (parallel_hash_set &a, parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > &b) noexcept(noexcept(a.swap(b)))

成员类型定义说明

allocator_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::allocator_type = Alloc

AllocTraits

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::AllocTraits = phmap::allocator_traits<allocator_type>

private

const_pointer

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::const_pointer

初始值:

 typename phmap::allocator_traits<
        allocator_type>::template rebind_traits<value_type>::const_pointer

const_reference

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::const_reference = const value_type&

constructor

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::constructor = typename EmbeddedSet::constructor

difference_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::difference_type = ptrdiff_t

EmbeddedConstIterator

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::EmbeddedConstIterator = typename EmbeddedSet::const_iterator

EmbeddedIterator

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::EmbeddedIterator = typename EmbeddedSet::iterator

EmbeddedSet

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::EmbeddedSet = RefSet<Policy, Hash, Eq, Alloc>

hasher

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::hasher = Hash

init_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::init_type = typename PolicyTraits::init_type

insert_return_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert_return_type = InsertReturnType<iterator, node_type>

IsDecomposable

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class... Ts>

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>

private

key_arg

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::key_arg = typename KeyArgImpl::template type<K, key_type>

key_equal

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::key_equal = Eq

key_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::key_type = typename PolicyTraits::key_type

KeyArgImpl

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::KeyArgImpl

private

初始值:

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

Lockable

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::Lockable = phmap::LockableImpl<Mtx_>

protected

node_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>

pointer

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::pointer

初始值:

 typename phmap::allocator_traits<
        allocator_type>::template rebind_traits<value_type>::pointer

policy_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::policy_type = Policy

PolicyTraits

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::PolicyTraits = hash_policy_traits<Policy>

private

reference

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::reference = value_type&

RequiresInsertable

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class T >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, 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<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class T >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::RequiresNotInit

private

初始值:

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

size_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::size_type = size_t

slot_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::slot_type = typename PolicyTraits::slot_type

value_type

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

using phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::value_type = typename PolicyTraits::value_type

构造及析构函数说明

parallel_hash_set() [1/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( )

inlinenoexcept

parallel_hash_set() [2/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( size_t bucket_cnt, const hasher & hash_param = hasher(), const key_equal & eq = key_equal(), const allocator_type & alloc = allocator_type() )

inlineexplicit

parallel_hash_set() [3/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( size_t bucket_cnt, const hasher & hash_param, const allocator_type & alloc )

inline

parallel_hash_set() [4/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( size_t bucket_cnt, const allocator_type & alloc )

inline

parallel_hash_set() [5/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( const allocator_type & alloc )

inlineexplicit

parallel_hash_set() [6/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( InputIter first, InputIter last, size_t bucket_cnt = 0, const hasher & hash_param = hasher(), const key_equal & eq = key_equal(), const allocator_type & alloc = allocator_type() )

inline

parallel_hash_set() [7/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( InputIter first, InputIter last, size_t bucket_cnt, const hasher & hash_param, const allocator_type & alloc )

inline

parallel_hash_set() [8/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

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

inline

parallel_hash_set() [9/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class InputIter >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( InputIter first, InputIter last, const allocator_type & alloc )

inline

parallel_hash_set() [10/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( std::initializer_list< T > init, size_t bucket_cnt = 0, const hasher & hash_param = hasher(), const key_equal & eq = key_equal(), const allocator_type & alloc = allocator_type() )

inline

parallel_hash_set() [11/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( std::initializer_list< init_type > init, size_t bucket_cnt = 0, const hasher & hash_param = hasher(), const key_equal & eq = key_equal(), const allocator_type & alloc = allocator_type() )

inline

parallel_hash_set() [12/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( std::initializer_list< T > init, size_t bucket_cnt, const hasher & hash_param, const allocator_type & alloc )

inline

parallel_hash_set() [13/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( std::initializer_list< init_type > init, size_t bucket_cnt, const hasher & hash_param, const allocator_type & alloc )

inline

parallel_hash_set() [14/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

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

inline

parallel_hash_set() [15/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

inline

parallel_hash_set() [16/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

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

inline

parallel_hash_set() [17/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

inline

parallel_hash_set() [18/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( const parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & that )

inline

parallel_hash_set() [19/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( const parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & that, const allocator_type & a )

inline

parallel_hash_set() [20/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > && that )

inlinenoexcept

parallel_hash_set() [21/21]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::parallel_hash_set ( parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > && that, const allocator_type & a )

inline

~parallel_hash_set()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::~parallel_hash_set ( )

inline

成员函数说明

_erase() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::_erase ( const_iterator cit )

inline

_erase() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::_erase ( iterator it )

inline

alloc_ref() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

allocator_type & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::alloc_ref ( )

inlineprivate

alloc_ref() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const allocator_type & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::alloc_ref ( ) const

inlineprivate

begin() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::begin ( )

inline

begin() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::begin ( ) const

inline

bucket_count()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::bucket_count ( ) const

inline

capacity()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::capacity ( ) const

inline

cbegin()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::cbegin ( ) const

inline

cend()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::cend ( ) const

inline

clear() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

PHMAP_ATTRIBUTE_REINITIALIZES void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::clear ( )

inline

clear() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::clear ( std::size_t submap_index )

inline

contains() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::contains ( const key_arg< K > & key ) const

inline

contains() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

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

inline

count()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::count ( const key_arg< K > & key ) const

inline

drop_deletes_without_resize()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::drop_deletes_without_resize ( )

inlineprivate

emplace() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace ( Args &&... args )

inline

emplace() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace ( Args &&... args )

inline

emplace_decomposable()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K , class... Args>

std::pair< iterator, bool > phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace_decomposable ( const K & key, Args &&... args )

inline

emplace_decomposable_with_hash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K , class... Args>

std::pair< iterator, bool > phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace_decomposable_with_hash ( const K & key, size_t hashval, Args &&... args )

inline

emplace_hint()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class... Args>

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace_hint ( const_iterator , Args &&... args )

inline

emplace_hint_with_hash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class... Args>

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

inline

emplace_single()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace_single ( const key_arg< K > & key, F && f )

inline

emplace_single_with_hash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, 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<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace_with_hash ( size_t hashval, Args &&... args )

inline

emplace_with_hash() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::emplace_with_hash ( size_t hashval, Args &&... args )

inline

empty()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::empty ( ) const

inline

end() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::end ( )

inline

end() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::end ( ) const

inline

eq_ref() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

key_equal & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::eq_ref ( )

inlineprivate

eq_ref() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const key_equal & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::eq_ref ( ) const

inlineprivate

equal_range() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

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

inline

equal_range() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

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

inline

erase() [1/4]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

size_type phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::erase ( const key_arg< K > & key )

inline

erase() [2/4]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::erase ( const_iterator cit )

inline

erase() [3/4]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::erase ( const_iterator first, const_iterator last )

inline

erase() [4/4]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::erase ( iterator it )

inline

erase_if()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::erase_if ( const key_arg< K > & key, F && f )

inline

erase_if_impl()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F , class L >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::erase_if_impl ( const key_arg< K > & key, F && f )

inline

erase_meta_only()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::erase_meta_only ( const_iterator cit )

inlineprivate

extract() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::extract ( const key_arg< K > & key )

inline

extract() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

node_type phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::extract ( const_iterator position )

inline

find() [1/5]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::find ( const key_arg< K > & key )

inline

find() [2/5]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

const_iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::find ( const key_arg< K > & key ) const

inline

find() [3/5]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

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

inline

find() [4/5]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

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

inline

find() [5/5]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class L = typename Lockable::SharedLock>

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::find ( const key_arg< K > & key, size_t hashval, L & mutexlock )

inlineprotected

find_or_prepare_insert()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K >

std::tuple< Inner *, size_t, bool > phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::find_or_prepare_insert ( const K & key, typename Lockable::UniqueLock & mutexlock )

inlineprotected

find_or_prepare_insert_with_hash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K >

std::tuple< Inner *, size_t, bool > phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::find_or_prepare_insert_with_hash ( size_t hashval, const K & key, typename Lockable::UniqueLock & mutexlock )

inlineprotected

find_ptr()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class L = typename Lockable::SharedLock>

pointer phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::find_ptr ( const key_arg< K > & key, size_t hashval, L & mutexlock )

inlineprotected

for_each()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class F >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::for_each ( F && fCallback ) const

inline

for_each_m()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class F >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::for_each_m ( F && fCallback )

inline

get_allocator()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

allocator_type phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::get_allocator ( ) const

inline

get_inner()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

Inner & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::get_inner ( size_t idx )

inline

growth_left()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::growth_left ( )

inlineprivate

has_element()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::has_element ( const value_type & elem ) const

inlineprivate

hash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K >

size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::hash ( const K & key ) const

inline

hash_function()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

hasher phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::hash_function ( ) const

inline

hash_ref() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

hasher & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::hash_ref ( )

inlineprivate

hash_ref() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const hasher & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::hash_ref ( ) const

inlineprivate

if_contains()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::if_contains ( const key_arg< K > & key, F && f ) const

inline

if_contains_unsafe()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::if_contains_unsafe ( const key_arg< K > & key, F && f ) const

inline

insert() [1/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( const T & value )

inline

insert() [2/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( const_iterator , const T & value )

inline

insert() [3/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( const_iterator , init_type && value )

inline

insert() [4/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( const_iterator , node_type && node )

inline

insert() [5/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( const_iterator , T && value )

inline

insert() [6/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

inline

insert() [7/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class InputIt >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( InputIt first, InputIt last )

inline

insert() [8/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

insert_return_type phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( node_type && node )

inline

insert() [9/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( std::initializer_list< init_type > ilist )

inline

insert() [10/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

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

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( std::initializer_list< T > ilist )

inline

insert() [11/11]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , 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::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::insert ( T && value )

inline

iterator_at() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::iterator_at ( Inner * inner, const EmbeddedIterator & it )

inlineprotected

iterator_at() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

const_iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::iterator_at ( Inner * inner, const EmbeddedIterator & it ) const

inlineprotected

key_eq()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

key_equal phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::key_eq ( ) const

inline

KeyTypeCanBeEq()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

auto phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::KeyTypeCanBeEq ( const Eq & eq, const key_type & k ) -> decltype(eq(k, k))

private

KeyTypeCanBeHashed()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

auto phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::KeyTypeCanBeHashed ( const Hash & h, const key_type & k ) -> decltype(h(k))

private

lazy_emplace()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::lazy_emplace ( const key_arg< K > & key, F && f )

inline

lazy_emplace_l()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class FExists , class FEmplace >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::lazy_emplace_l ( const key_arg< K > & key, FExists && fExists, FEmplace && fEmplace )

inline

lazy_emplace_with_hash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

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

inline

load_factor()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

float phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::load_factor ( ) const

inline

make_iterator()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

iterator phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::make_iterator ( Inner * inner, const EmbeddedIterator it )

inline

make_rv()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

std::pair< iterator, bool > phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::make_rv ( Inner * inner, const std::pair< EmbeddedIterator, bool > & res )

inline

max_load_factor() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

float phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::max_load_factor ( ) const

inline

max_load_factor() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::max_load_factor ( float )

inline

max_size()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::max_size ( ) const

inline

merge() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<typename E = Eq>

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::merge ( parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, E, Alloc > && src )

inline

merge() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<typename E = Eq>

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::merge ( parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, E, Alloc > & src )

inline

modify_if()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::modify_if ( const key_arg< K > & key, F && f )

inline

modify_if_impl()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type, class F , class L >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::modify_if_impl ( const key_arg< K > & key, F && f )

inline

move_assign() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class Mtx2_ >

parallel_hash_set & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::move_assign ( parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > && that, std::false_type  )

inlineprivate

move_assign() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class Mtx2_ >

parallel_hash_set & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::move_assign ( parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > && that, std::true_type  )

inlineprivate

operator=() [1/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

parallel_hash_set & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::operator= ( const parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & that )

inline

operator=() [2/2]

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

parallel_hash_set & phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::operator= ( parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > && that )

inlinenoexcept

phmap_dump()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<typename OutputArchive >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::phmap_dump

(

OutputArchive &

ar

)

const

phmap_load()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<typename InputArchive >

bool phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::phmap_load

(

InputArchive &

ar

)

prefetch()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class K = key_type>

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::prefetch ( const key_arg< K > & key ) const

inline

prefetch_hash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::prefetch_hash ( size_t hashval ) const

inline

rehash()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::rehash ( size_t n )

inline

reserve()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::reserve ( size_t n )

inline

size()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::size ( ) const

inline

subcnt()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

static size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::subcnt ( )

inlinestaticprotected

subidx()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

static size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::subidx ( size_t hashval )

inlinestaticprotected

swap()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class Mtx2_ >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::swap ( parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > & that )

inlinenoexcept

with_submap()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class F >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::with_submap ( size_t idx, F && fCallback ) const

inline

with_submap_m()

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class F >

void phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::with_submap_m ( size_t idx, F && fCallback )

inline

友元及相关函数文档

operator!=

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

bool operator!= ( const parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & a, const parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & b )

friend

operator==

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

bool operator== ( const parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & a, const parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & b )

friend

phmap::priv::hashtable_debug_internal::HashtableDebugAccess

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class Container , typename Enabler >

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

friend

RawHashSetTestOnlyAccess

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

friend struct RawHashSetTestOnlyAccess

friend

swap

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

template<class Mtx2_ >

void swap ( parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc > & a, parallel_hash_set< N, RefSet, Mtx2_, Policy, Hash, Eq, Alloc > & b )

friend

类成员变量说明

mask

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

constexpr size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::mask = num_tables - 1

staticconstexprprivate

num_tables

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

constexpr size_t phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::num_tables = 1 << N

staticconstexprprivate

sets_

template<size_t N, template< class, class, class, class > class RefSet, class Mtx_ , class Policy , class Hash , class Eq , class Alloc >

std::array<Inner, num_tables> phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::sets_

protected

---

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

• 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