#include <phmap.h>

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

Public 类型
using	key_type = typename Policy::key_type

using	mapped_type = typename Policy::mapped_type

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

using	iterator = typename raw_hash_map::raw_hash_set::iterator

using	const_iterator = typename raw_hash_map::raw_hash_set::const_iterator

Public 类型继承自 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >
using	init_type = typename PolicyTraits::init_type

using	key_type = typename PolicyTraits::key_type

using	slot_type = typename PolicyTraits::slot_type

using	allocator_type = Alloc

using	size_type = size_t

using	difference_type = ptrdiff_t

using	hasher = Hash

using	key_equal = Eq

using	policy_type = Policy

using	value_type = typename PolicyTraits::value_type

using	reference = value_type&

using	const_reference = const value_type&

using	pointer

using	const_pointer

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

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

using	insert_return_type = InsertReturnType<iterator, node_type>

template<typename It >
using	IsRandomAccess

Public 成员函数
	raw_hash_map ()

template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
std::pair< iterator, bool >	insert_or_assign (key_arg< K > &&k, V &&v)

template<class K = key_type, class V = mapped_type, K * = nullptr>
std::pair< iterator, bool >	insert_or_assign (key_arg< K > &&k, const V &v)

template<class K = key_type, class V = mapped_type, V * = nullptr>
std::pair< iterator, bool >	insert_or_assign (const key_arg< K > &k, V &&v)

template<class K = key_type, class V = mapped_type>
std::pair< iterator, bool >	insert_or_assign (const key_arg< K > &k, const V &v)

template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
iterator	insert_or_assign (const_iterator, key_arg< K > &&k, V &&v)

template<class K = key_type, class V = mapped_type, K * = nullptr>
iterator	insert_or_assign (const_iterator, key_arg< K > &&k, const V &v)

template<class K = key_type, class V = mapped_type, V * = nullptr>
iterator	insert_or_assign (const_iterator, const key_arg< K > &k, V &&v)

template<class K = key_type, class V = mapped_type>
iterator	insert_or_assign (const_iterator, const key_arg< K > &k, const V &v)

template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0, K * = nullptr>
std::pair< iterator, bool >	try_emplace (key_arg< K > &&k, Args &&... args)

template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0>
std::pair< iterator, bool >	try_emplace (const key_arg< K > &k, Args &&... args)

template<class K = key_type, class... Args, K * = nullptr>
iterator	try_emplace (const_iterator, key_arg< K > &&k, Args &&... args)

template<class K = key_type, class... Args>
iterator	try_emplace (const_iterator, const key_arg< K > &k, Args &&... args)

template<class K = key_type, class P = Policy>
MappedReference< P >	at (const key_arg< K > &key)

template<class K = key_type, class P = Policy>
MappedConstReference< P >	at (const key_arg< K > &key) const

template<class K = key_type, class P = Policy, K * = nullptr>
MappedReference< P >	operator[] (key_arg< K > &&key)

template<class K = key_type, class P = Policy>
MappedReference< P >	operator[] (const key_arg< K > &key)

	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)

Public 成员函数继承自 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >
	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

Private 类型
template<class P >
using	MappedReference

template<class P >
using	MappedConstReference

using	KeyArgImpl

using	Base = raw_hash_set<Policy, Hash, Eq, Alloc>

Private 成员函数
template<class K , class V >
std::pair< iterator, bool >	insert_or_assign_impl (K &&k, V &&v)

template<class K = key_type, class... Args>
std::pair< iterator, bool >	try_emplace_impl (K &&k, Args &&... args)

额外继承的成员函数
Protected 成员函数继承自 phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >
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

成员类型定义说明

◆ Base

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

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

private

◆ const_iterator

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

using phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::const_iterator = typename raw_hash_map::raw_hash_set::const_iterator

◆ iterator

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

using phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::iterator = typename raw_hash_map::raw_hash_set::iterator

◆ key_arg

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

template<class K >

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

◆ key_type

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

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

◆ KeyArgImpl

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

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

private

初始值:

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

◆ mapped_type

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

using phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::mapped_type = typename Policy::mapped_type

◆ MappedConstReference

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

template<class P >

using phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::MappedConstReference

private

初始值:

decltype(P::value(

std::addressof(std::declval<typename raw_hash_map::const_reference>())))

◆ MappedReference

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

template<class P >

using phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::MappedReference

private

初始值:

decltype(P::value(

std::addressof(std::declval<typename raw_hash_map::reference>())))

构造及析构函数说明

◆ raw_hash_map()

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

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

inline

成员函数说明

◆ at() [1/2]

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

template<class K = key_type, class P = Policy>

MappedReference< P > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::at ( const key_arg< K > & key )

inline

◆ at() [2/2]

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

template<class K = key_type, class P = Policy>

MappedConstReference< P > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::at ( const key_arg< K > & key ) const

inline

◆ insert_or_assign() [1/8]

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

template<class K = key_type, class V = mapped_type>

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	const key_arg< K > &	k,
		const V &	v )

inline

◆ insert_or_assign() [2/8]

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

template<class K = key_type, class V = mapped_type, V * = nullptr>

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	const key_arg< K > &	k,
		V &&	v )

inline

◆ insert_or_assign() [3/8]

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

template<class K = key_type, class V = mapped_type>

iterator phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	const_iterator	,
		const key_arg< K > &	k,
		const V &	v )

inline

◆ insert_or_assign() [4/8]

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

template<class K = key_type, class V = mapped_type, V * = nullptr>

iterator phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	const_iterator	,
		const key_arg< K > &	k,
		V &&	v )

inline

◆ insert_or_assign() [5/8]

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

template<class K = key_type, class V = mapped_type, K * = nullptr>

iterator phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	const_iterator	,
		key_arg< K > &&	k,
		const V &	v )

inline

◆ insert_or_assign() [6/8]

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

template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>

iterator phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	const_iterator	,
		key_arg< K > &&	k,
		V &&	v )

inline

◆ insert_or_assign() [7/8]

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

template<class K = key_type, class V = mapped_type, K * = nullptr>

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	key_arg< K > &&	k,
		const V &	v )

inline

◆ insert_or_assign() [8/8]

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

template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign	(	key_arg< K > &&	k,
		V &&	v )

inline

◆ insert_or_assign_impl()

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

template<class K , class V >

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::insert_or_assign_impl	(	K &&	k,
		V &&	v )

inlineprivate

◆ operator[]() [1/2]

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

template<class K = key_type, class P = Policy>

MappedReference< P > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::operator[] ( const key_arg< K > & key )

inline

◆ operator[]() [2/2]

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

template<class K = key_type, class P = Policy, K * = nullptr>

MappedReference< P > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::operator[] ( key_arg< K > && key )

inline

◆ 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 ( const allocator_type & alloc )

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 ( const raw_hash_set & that )

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	(	const raw_hash_set &	that,
		const allocator_type &	a )

inline

◆ raw_hash_set() [5/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() [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,
		const allocator_type &	alloc )

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 = 0,
		const hasher &	hashfn = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inline

◆ raw_hash_set() [9/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 && that )

inlinenoexcept

◆ raw_hash_set() [10/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 &&	that,
		const allocator_type &	a )

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	(	size_t	bucket_cnt,
		const allocator_type &	alloc )

inline

◆ raw_hash_set() [12/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() [13/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() [14/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() [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 >

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() [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,
		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() [18/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() [19/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() [20/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() [21/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

◆ try_emplace() [1/4]

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

template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0>

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace	(	const key_arg< K > &	k,
		Args &&...	args )

inline

◆ try_emplace() [2/4]

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

template<class K = key_type, class... Args>

iterator phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace	(	const_iterator	,
		const key_arg< K > &	k,
		Args &&...	args )

inline

◆ try_emplace() [3/4]

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

template<class K = key_type, class... Args, K * = nullptr>

iterator phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace	(	const_iterator	,
		key_arg< K > &&	k,
		Args &&...	args )

inline

◆ try_emplace() [4/4]

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

template<class K = key_type, class... Args, typename std::enable_if< !std::is_convertible< K, const_iterator >::value, int >::type = 0, K * = nullptr>

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace	(	key_arg< K > &&	k,
		Args &&...	args )

inline

◆ try_emplace_impl()

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

template<class K = key_type, class... Args>

std::pair< iterator, bool > phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >::try_emplace_impl	(	K &&	k,
		Args &&...	args )

inlineprivate

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

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

Public 类型

Public 成员函数

Private 类型

Private 成员函数

额外继承的成员函数

成员类型定义说明

◆ Base

◆ const_iterator

◆ iterator

◆ key_arg

◆ key_type

◆ KeyArgImpl

◆ mapped_type

◆ MappedConstReference

◆ MappedReference

构造及析构函数说明

◆ raw_hash_map()

成员函数说明

◆ at() [1/2]

◆ at() [2/2]

◆ insert_or_assign() [1/8]

◆ insert_or_assign() [2/8]

◆ insert_or_assign() [3/8]

◆ insert_or_assign() [4/8]

◆ insert_or_assign() [5/8]

◆ insert_or_assign() [6/8]

◆ insert_or_assign() [7/8]

◆ insert_or_assign() [8/8]

◆ insert_or_assign_impl()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ raw_hash_set() [1/21]

◆ raw_hash_set() [2/21]

◆ raw_hash_set() [3/21]

◆ raw_hash_set() [4/21]

◆ raw_hash_set() [5/21]

◆ raw_hash_set() [6/21]

◆ raw_hash_set() [7/21]

◆ raw_hash_set() [8/21]

◆ raw_hash_set() [9/21]

◆ raw_hash_set() [10/21]

◆ raw_hash_set() [11/21]

◆ raw_hash_set() [12/21]

◆ raw_hash_set() [13/21]

◆ raw_hash_set() [14/21]

◆ raw_hash_set() [15/21]

◆ raw_hash_set() [16/21]

◆ raw_hash_set() [17/21]

◆ raw_hash_set() [18/21]

◆ raw_hash_set() [19/21]

◆ raw_hash_set() [20/21]

◆ raw_hash_set() [21/21]

◆ try_emplace() [1/4]

◆ try_emplace() [2/4]

◆ try_emplace() [3/4]

◆ try_emplace() [4/4]

◆ try_emplace_impl()