#include <ne_stl_set.h>

类 nstd::parallel_set< T, Hash, Eq, Alloc, N, Mtx > 继承关系图:

Public 成员函数
	parallel_set ()

Public 成员函数继承自 phmap::parallel_flat_hash_set< T, Hash, Eq, Alloc, N, Mtx_ >
	parallel_flat_hash_set ()

Public 成员函数继承自 phmap::priv::parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, Eq, Alloc >
	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)

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

	parallel_hash_set (InputIter first, InputIter last, size_t bucket_cnt, const hasher &hash_param, const allocator_type &alloc)

	parallel_hash_set (InputIter first, InputIter last, size_t bucket_cnt, const allocator_type &alloc)

	parallel_hash_set (InputIter first, InputIter last, const allocator_type &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())

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

	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)

	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)

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

const_iterator	begin () const

iterator	end ()

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)

std::pair< iterator, bool >	insert (T &&value)

std::pair< iterator, bool >	insert (const T &value)

std::pair< iterator, bool >	insert (init_type &&value)

iterator	insert (const_iterator, T &&value)

iterator	insert (const_iterator, const T &value)

iterator	insert (const_iterator, init_type &&value)

void	insert (InputIt first, InputIt last)

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)

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

std::pair< iterator, bool >	emplace_with_hash (size_t hashval, Args &&... args)

std::pair< iterator, bool >	emplace_with_hash (size_t hashval, Args &&... args)

iterator	emplace_hint_with_hash (size_t hashval, const_iterator, Args &&... args)

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

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

std::pair< iterator, bool >	emplace (Args &&... args)

std::pair< iterator, bool >	emplace (Args &&... 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)

iterator	lazy_emplace (const key_arg< K > &key, F &&f)

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

void	emplace_single (const key_arg< K > &key, F &&f)

bool	if_contains (const key_arg< K > &key, F &&f) const

bool	if_contains_unsafe (const key_arg< K > &key, F &&f) const

bool	modify_if (const key_arg< K > &key, F &&f)

bool	modify_if_impl (const key_arg< K > &key, F &&f)

bool	erase_if (const key_arg< K > &key, F &&f)

bool	erase_if_impl (const key_arg< K > &key, F &&f)

bool	lazy_emplace_l (const key_arg< K > &key, FExists &&fExists, FEmplace &&fEmplace)

void	for_each (F &&fCallback) const

void	for_each_m (F &&fCallback)

void	with_submap (size_t idx, F &&fCallback) const

void	with_submap_m (size_t idx, F &&fCallback)

Inner &	get_inner (size_t idx)

size_type	erase (const key_arg< K > &key)

iterator	erase (const_iterator cit)

iterator	erase (iterator it)

iterator	erase (const_iterator first, const_iterator last)

void	_erase (iterator it)

void	_erase (const_iterator cit)

void	merge (parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, E, Alloc > &src)

void	merge (parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, E, Alloc > &&src)

node_type	extract (const_iterator position)

node_type	extract (const key_arg< K > &key)

void	swap (parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx2_, phmap::priv::FlatHashSetPolicy< T >, 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)

size_t	count (const key_arg< K > &key) const

void	prefetch_hash (size_t hashval) const

void	prefetch (const key_arg< K > &key) const

iterator	find (const key_arg< K > &key, size_t hashval)

iterator	find (const key_arg< K > &key)

const_iterator	find (const key_arg< K > &key, size_t hashval) const

const_iterator	find (const key_arg< K > &key) const

bool	contains (const key_arg< K > &key) const

bool	contains (const key_arg< K > &key, size_t hashval) const

std::pair< iterator, iterator >	equal_range (const key_arg< K > &key)

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

size_t	hash (const K &key) const

bool	phmap_dump (OutputArchive &ar) const

bool	phmap_load (InputArchive &ar)

额外继承的成员函数
Public 类型继承自 phmap::priv::parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, Eq, Alloc >
using	EmbeddedSet = phmap::priv::raw_hash_set< phmap::priv::FlatHashSetPolicy< T >, 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 = phmap::priv::FlatHashSetPolicy< T >

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

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

using	node_type = node_handle< phmap::priv::FlatHashSetPolicy< T >, hash_policy_traits< phmap::priv::FlatHashSetPolicy< T > >, Alloc >

using	insert_return_type = InsertReturnType< iterator, node_type >

Protected 类型继承自 phmap::priv::parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, Eq, Alloc >
using	Lockable = phmap::LockableImpl< Mtx_ >

Protected 成员函数继承自 phmap::priv::parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, Eq, Alloc >
iterator	find (const key_arg< K > &key, size_t hashval, L &mutexlock)

pointer	find_ptr (const key_arg< K > &key, size_t hashval, L &mutexlock)

std::tuple< Inner *, size_t, bool >	find_or_prepare_insert_with_hash (size_t hashval, const K &key, typename Lockable::UniqueLock &mutexlock)

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 成员函数继承自 phmap::priv::parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, Eq, Alloc >
static size_t	subidx (size_t hashval)

static size_t	subcnt ()

Protected 属性继承自 phmap::priv::parallel_hash_set< N, phmap::priv::raw_hash_set, Mtx_, phmap::priv::FlatHashSetPolicy< T >, Hash, Eq, Alloc >
std::array< Inner, num_tables >	sets_

构造及析构函数说明

◆ parallel_set()

template<class T , class Hash = hash_default_hash<T>, class Eq = hash_default_eq<T>, class Alloc = Allocator<T>, size_t N = 4, class Mtx = NullMutex>

nstd::parallel_set< T, Hash, Eq, Alloc, N, Mtx >::parallel_set ( )

inline

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

D:/GitLab/builds/5sbaxrcd/0/nim-pc/california/nim-cross-platform-sdk/exports/include/ne_stl_set.h

Public 成员函数

额外继承的成员函数

构造及析构函数说明

◆ parallel_set()