phmap::priv 命名空间参考

命名空间
namespace	hashtable_debug_internal
namespace	internal_compressed_tuple
namespace	internal_layout
namespace	memory_internal

类
struct	Aligned
class	BitMask
class	btree
class	btree_container
struct	btree_iterator
class	btree_map_container
class	btree_multimap_container
class	btree_multiset_container
class	btree_node
class	btree_set_container
struct	common_params
struct	CommonAccess
class	CompressedTuple
class	CompressedTuple<>
struct	FlatHashMapPolicy
struct	FlatHashSetPolicy
struct	GroupPortableImpl
struct	hash_policy_traits
struct	HashEq
struct	HashEq< std::shared_ptr< T > >
struct	HashEq< std::unique_ptr< T, D > >
struct	HashEq< T * >
struct	HashtablezInfo
class	HashtablezInfoHandle
class	HashtablezSampler
struct	InsertReturnType
struct	IsDecomposable
struct	IsDecomposable< phmap::void_t< decltype(Policy::apply(RequireUsableKey< typename Policy::key_type, Hash, Eq >(), std::declval< Ts >()...))>, Policy, Hash, Eq, Ts... >
struct	IsTransparent
struct	IsTransparent< T, phmap::void_t< typename T::is_transparent > >
struct	key_compare_to_adapter
struct	key_compare_to_adapter< phmap::Less< std::string > >
struct	key_compare_to_adapter< std::greater< std::string > >
struct	key_compare_to_adapter< std::less< std::string > >
struct	KeyArg
struct	KeyArg< false >
class	Layout
struct	map_params
struct	map_slot_policy
union	map_slot_type
class	node_handle
class	node_handle< Policy, PolicyTraits, Alloc, phmap::void_t< typename Policy::mapped_type > >
class	node_handle_base
struct	node_hash_policy
class	NodeHashMapPolicy
struct	NodeHashSetPolicy
class	parallel_hash_map
class	parallel_hash_set
class	probe_seq
class	raw_hash_map
class	raw_hash_set
struct	RequireUsableKey
struct	SearchResult
struct	SearchResult< V, false >
struct	set_params
struct	set_slot_policy
struct	StringBtreeDefaultGreater
struct	StringBtreeDefaultLess
struct	upper_bound_adapter

类型定义
template<typename Compare , typename T >
using	btree_is_key_compare_to
using	ctrl_t = signed char
using	h2_t = uint8_t
using	Group = GroupPortableImpl
template<class T >
using	hash_default_hash = typename priv::HashEq<T>::Hash
template<class T >
using	hash_default_eq = typename priv::HashEq<T>::Eq
template<class T >
using	Allocator = typename phmap::Allocator<T>
template<class T1 , class T2 >
using	Pair = typename phmap::Pair<T1, T2>

枚举
enum class	MatchKind : uint8_t { kEq , kNe }
enum	Ctrl : ctrl_t { kEmpty = -128 , kDeleted = -2 , kSentinel = -1 }

函数
template<typename AllocType >
void	SwapAlloc (AllocType &lhs, AllocType &rhs, std::true_type)
template<typename AllocType >
void	SwapAlloc (AllocType &, AllocType &, std::false_type)
template<class T >
constexpr bool	IsNoThrowSwappable ()
template<typename T >
int	TrailingZeros (T x)
template<typename T >
int	LeadingZeros (T x)
ctrl_t *	EmptyGroup ()
size_t	HashSeed (const ctrl_t *ctrl)
size_t	H1 (size_t hashval, const ctrl_t *)
h2_t	H2 (size_t hashval)
bool	IsEmpty (ctrl_t c)
bool	IsFull (ctrl_t c)
bool	IsDeleted (ctrl_t c)
bool	IsEmptyOrDeleted (ctrl_t c)
constexpr size_t	NumClonedBytes ()
bool	IsValidCapacity (size_t n)
void	ConvertDeletedToEmptyAndFullToDeleted (ctrl_t *ctrl, size_t capacity)
size_t	NormalizeCapacity (size_t n)
size_t	CapacityToGrowth (size_t capacity)
size_t	GrowthToLowerboundCapacity (size_t growth)
void	RecordRehashSlow (HashtablezInfo *, size_t)
static void	RecordInsertSlow (HashtablezInfo *, size_t, size_t)
static void	RecordEraseSlow (HashtablezInfo *)
static HashtablezInfo *	SampleSlow (int64_t *)
static void	UnsampleSlow (HashtablezInfo *)
static HashtablezInfoHandle	Sample ()
static void	SetHashtablezEnabled (bool)
static void	SetHashtablezSampleParameter (int32_t)
static void	SetHashtablezMaxSamples (int32_t)
size_t	RandomSeed ()
template<class Alloc , class T , class Tuple >
void	ConstructFromTuple (Alloc *alloc, T *ptr, Tuple &&t)
template<class T , class Tuple , class F >
decltype(std::declval< F >()(std::declval< T >()))	WithConstructed (Tuple &&t, F &&f)
std::pair< std::tuple<>, std::tuple<> >	PairArgs ()
template<class F , class S >
std::pair< std::tuple< F && >, std::tuple< S && > >	PairArgs (F &&f, S &&s)
template<class F , class S >
std::pair< std::tuple< const F & >, std::tuple< const S & > >	PairArgs (const std::pair< F, S > &p)
template<class F , class S >
std::pair< std::tuple< F && >, std::tuple< S && > >	PairArgs (std::pair< F, S > &&p)
template<class F , class S >
auto	PairArgs (std::piecewise_construct_t, F &&f, S &&s) -> decltype(std::make_pair(memory_internal::TupleRef(std::forward< F >(f)), memory_internal::TupleRef(std::forward< S >(s))))
template<class F , class... Args>
auto	DecomposePair (F &&f, Args &&... args) -> decltype(memory_internal::DecomposePairImpl(std::forward< F >(f), PairArgs(std::forward< Args >(args)...)))
template<class F , class Arg >
decltype(std::declval< F >()(std::declval< const Arg & >(), std::declval< Arg >()))	DecomposeValue (F &&f, Arg &&arg)
template<class C , class Pred >
std::size_t	erase_if (C &c, Pred pred)
template<size_t Alignment, class Alloc >
void *	Allocate (Alloc *alloc, size_t n)
template<size_t Alignment, class Alloc >
void	Deallocate (Alloc *alloc, void *p, size_t n)
void	SanitizerPoisonMemoryRegion (const void *m, size_t s)
void	SanitizerUnpoisonMemoryRegion (const void *m, size_t s)
template<typename T >
void	SanitizerPoisonObject (const T *object)
template<typename T >
void	SanitizerUnpoisonObject (const T *object)

类型定义说明

Allocator

template<class T >

using phmap::priv::Allocator = typename phmap::Allocator<T>

btree_is_key_compare_to

template<typename Compare , typename T >

using phmap::priv::btree_is_key_compare_to

初始值:

 
        std::is_convertible<phmap::invoke_result_t<Compare, const T &, const T &>,
                            phmap::weak_ordering>

ctrl_t

using phmap::priv::ctrl_t = signed char

Group

using phmap::priv::Group = GroupPortableImpl

h2_t

using phmap::priv::h2_t = uint8_t

hash_default_eq

template<class T >

using phmap::priv::hash_default_eq = typename priv::HashEq<T>::Eq

hash_default_hash

template<class T >

using phmap::priv::hash_default_hash = typename priv::HashEq<T>::Hash

Pair

template<class T1 , class T2 >

using phmap::priv::Pair = typename phmap::Pair<T1, T2>

枚举类型说明

Ctrl

enum phmap::priv::Ctrl : ctrl_t

枚举值
kEmpty
kDeleted
kSentinel

MatchKind

enum class phmap::priv::MatchKind : uint8_t

strong

枚举值
kEq
kNe

函数说明

Allocate()

template<size_t Alignment, class Alloc >

void * phmap::priv::Allocate	(	Alloc *	alloc,
		size_t	n )

CapacityToGrowth()

size_t phmap::priv::CapacityToGrowth ( size_t capacity )

inline

ConstructFromTuple()

template<class Alloc , class T , class Tuple >

void phmap::priv::ConstructFromTuple	(	Alloc *	alloc,
		T *	ptr,
		Tuple &&	t )

ConvertDeletedToEmptyAndFullToDeleted()

void phmap::priv::ConvertDeletedToEmptyAndFullToDeleted ( ctrl_t * ctrl, size_t capacity )

inline

Deallocate()

template<size_t Alignment, class Alloc >

void phmap::priv::Deallocate	(	Alloc *	alloc,
		void *	p,
		size_t	n )

DecomposePair()

template<class F , class... Args>

auto phmap::priv::DecomposePair	(	F &&	f,
		Args &&...	args ) -> decltype(memory_internal::DecomposePairImpl( std::forward<F>(f), PairArgs(std::forward<Args>(args)...)))

DecomposeValue()

template<class F , class Arg >

decltype(std::declval< F >()(std::declval< const Arg & >(), std::declval< Arg >())) phmap::priv::DecomposeValue	(	F &&	f,
		Arg &&	arg )

EmptyGroup()

ctrl_t * phmap::priv::EmptyGroup ( )

inline

erase_if()

template<class C , class Pred >

std::size_t phmap::priv::erase_if	(	C &	c,
		Pred	pred )

GrowthToLowerboundCapacity()

size_t phmap::priv::GrowthToLowerboundCapacity ( size_t growth )

inline

H1()

size_t phmap::priv::H1 ( size_t hashval, const ctrl_t *  )

inline

H2()

h2_t phmap::priv::H2 ( size_t hashval )

inline

HashSeed()

size_t phmap::priv::HashSeed ( const ctrl_t * ctrl )

inline

IsDeleted()

bool phmap::priv::IsDeleted ( ctrl_t c )

inline

IsEmpty()

bool phmap::priv::IsEmpty ( ctrl_t c )

inline

IsEmptyOrDeleted()

bool phmap::priv::IsEmptyOrDeleted ( ctrl_t c )

inline

IsFull()

bool phmap::priv::IsFull ( ctrl_t c )

inline

IsNoThrowSwappable()

template<class T >

constexpr bool phmap::priv::IsNoThrowSwappable ( )

constexpr

IsValidCapacity()

bool phmap::priv::IsValidCapacity ( size_t n )

inline

LeadingZeros()

template<typename T >

int phmap::priv::LeadingZeros

(

T

x

)

NormalizeCapacity()

size_t phmap::priv::NormalizeCapacity ( size_t n )

inline

NumClonedBytes()

constexpr size_t phmap::priv::NumClonedBytes ( )

constexpr

PairArgs() [1/5]

std::pair< std::tuple<>, std::tuple<> > phmap::priv::PairArgs ( )

inline

PairArgs() [2/5]

template<class F , class S >

std::pair< std::tuple< const F & >, std::tuple< const S & > > phmap::priv::PairArgs

(

const std::pair< F, S > &

p

)

PairArgs() [3/5]

template<class F , class S >

std::pair< std::tuple< F && >, std::tuple< S && > > phmap::priv::PairArgs	(	F &&	f,
		S &&	s )

PairArgs() [4/5]

template<class F , class S >

std::pair< std::tuple< F && >, std::tuple< S && > > phmap::priv::PairArgs

(

std::pair< F, S > &&

p

)

PairArgs() [5/5]

template<class F , class S >

auto phmap::priv::PairArgs	(	std::piecewise_construct_t	,
		F &&	f,
		S &&	s ) -> decltype(std::make_pair(memory_internal::TupleRef(std::forward<F>(f)), memory_internal::TupleRef(std::forward<S>(s))))

RandomSeed()

size_t phmap::priv::RandomSeed ( )

inline

RecordEraseSlow()

static void phmap::priv::RecordEraseSlow ( HashtablezInfo * )

inlinestatic

RecordInsertSlow()

static void phmap::priv::RecordInsertSlow ( HashtablezInfo * , size_t , size_t  )

inlinestatic

RecordRehashSlow()

void phmap::priv::RecordRehashSlow ( HashtablezInfo * , size_t  )

inline

Sample()

static HashtablezInfoHandle phmap::priv::Sample ( )

inlinestatic

SampleSlow()

static HashtablezInfo * phmap::priv::SampleSlow ( int64_t * )

inlinestatic

SanitizerPoisonMemoryRegion()

void phmap::priv::SanitizerPoisonMemoryRegion ( const void * m, size_t s )

inline

SanitizerPoisonObject()

template<typename T >

void phmap::priv::SanitizerPoisonObject ( const T * object )

inline

SanitizerUnpoisonMemoryRegion()

void phmap::priv::SanitizerUnpoisonMemoryRegion ( const void * m, size_t s )

inline

SanitizerUnpoisonObject()

template<typename T >

void phmap::priv::SanitizerUnpoisonObject ( const T * object )

inline

SetHashtablezEnabled()

static void phmap::priv::SetHashtablezEnabled ( bool )

inlinestatic

SetHashtablezMaxSamples()

static void phmap::priv::SetHashtablezMaxSamples ( int32_t )

inlinestatic

SetHashtablezSampleParameter()

static void phmap::priv::SetHashtablezSampleParameter ( int32_t )

inlinestatic

SwapAlloc() [1/2]

template<typename AllocType >

void phmap::priv::SwapAlloc	(	AllocType &	,
		AllocType &	,
		std::false_type	)

SwapAlloc() [2/2]

template<typename AllocType >

void phmap::priv::SwapAlloc	(	AllocType &	lhs,
		AllocType &	rhs,
		std::true_type	)

TrailingZeros()

template<typename T >

int phmap::priv::TrailingZeros

(

T

x

)

UnsampleSlow()

static void phmap::priv::UnsampleSlow ( HashtablezInfo * )

inlinestatic

WithConstructed()

template<class T , class Tuple , class F >

decltype(std::declval< F >()(std::declval< T >())) phmap::priv::WithConstructed	(	Tuple &&	t,
		F &&	f )