phmap.h 文件参考

#include <algorithm>
#include <cmath>
#include <cstring>
#include <iterator>
#include <limits>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
#include <array>
#include <cassert>
#include <atomic>
#include "phmap_fwd_decl.h"
#include "phmap_utils.h"
#include "phmap_base.h"

浏览源代码.

类
class	phmap::priv::probe_seq< Width >
struct	phmap::priv::RequireUsableKey< ContainerKey, Hash, Eq >
struct	phmap::priv::IsDecomposable< E, Policy, Hash, Eq, Ts >
struct	phmap::priv::IsDecomposable< phmap::void_t< decltype(Policy::apply(RequireUsableKey< typename Policy::key_type, Hash, Eq >(), std::declval< Ts >()...))>, Policy, Hash, Eq, Ts... >
class	phmap::priv::BitMask< T, SignificantBits, Shift >
struct	phmap::priv::GroupPortableImpl
struct	phmap::priv::hashtable_debug_internal::HashtableDebugAccess< Container, Enabler >
struct	phmap::priv::HashtablezInfo
class	phmap::priv::HashtablezInfoHandle
class	phmap::priv::HashtablezSampler
struct	phmap::priv::memory_internal::WithConstructedImplF< T, F >
class	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::SameAsElementReference< T >
class	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::iterator
class	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::const_iterator
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::has_difference_operator< T >
class	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::constructor
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::FindElement
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::HashElement
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::EqualElement< K1 >
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::EmplaceDecomposable
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::EmplaceDecomposableHashval
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::InsertSlot< do_destroy >
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::InsertSlotWithHash< do_destroy >
struct	phmap::priv::raw_hash_set< Policy, Hash, Eq, Alloc >::FindInfo
class	phmap::priv::raw_hash_map< Policy, Hash, Eq, Alloc >
class	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::Inner
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::Inner::Params
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::SameAsElementReference< T >
class	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::iterator
class	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::const_iterator
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::ReturnKey_
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::EmplaceDecomposableHashval
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::EmplaceDecomposable
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::FindElement
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::HashElement
struct	phmap::priv::parallel_hash_set< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >::EqualElement< K1 >
class	phmap::priv::parallel_hash_map< N, RefSet, Mtx_, Policy, Hash, Eq, Alloc >
struct	phmap::priv::FlatHashSetPolicy< T >
struct	phmap::priv::FlatHashMapPolicy< K, V >
struct	phmap::priv::node_hash_policy< Reference, Policy >
struct	phmap::priv::NodeHashSetPolicy< T >
class	phmap::priv::NodeHashMapPolicy< Key, Value >
struct	phmap::priv::HashEq< T * >
struct	phmap::priv::HashEq< T * >::Hash
struct	phmap::priv::HashEq< T * >::Eq
struct	phmap::priv::HashEq< std::unique_ptr< T, D > >
struct	phmap::priv::HashEq< std::shared_ptr< T > >
struct	phmap::priv::hashtable_debug_internal::has_member_type_raw_hash_set< typename, typename >
struct	phmap::priv::hashtable_debug_internal::has_member_type_raw_hash_set< T, phmap::void_t< typename T::raw_hash_set > >
struct	phmap::priv::hashtable_debug_internal::HashtableDebugAccess< Set, typename std::enable_if< has_member_type_raw_hash_set< Set >::value >::type >
struct	phmap::priv::hashtable_debug_internal::has_member_type_EmbeddedSet< typename, typename >
struct	phmap::priv::hashtable_debug_internal::has_member_type_EmbeddedSet< T, phmap::void_t< typename T::EmbeddedSet > >
struct	phmap::priv::hashtable_debug_internal::HashtableDebugAccess< Set, typename std::enable_if< has_member_type_EmbeddedSet< Set >::value >::type >
class	phmap::flat_hash_set< T, Hash, Eq, Alloc >
class	phmap::flat_hash_map< K, V, Hash, Eq, Alloc >
class	phmap::node_hash_set< T, Hash, Eq, Alloc >
class	phmap::node_hash_map< Key, Value, Hash, Eq, Alloc >
class	phmap::parallel_flat_hash_set< T, Hash, Eq, Alloc, N, Mtx_ >
class	phmap::parallel_flat_hash_map< K, V, Hash, Eq, Alloc, N, Mtx_ >
class	phmap::parallel_node_hash_set< T, Hash, Eq, Alloc, N, Mtx_ >
class	phmap::parallel_node_hash_map< Key, Value, Hash, Eq, Alloc, N, Mtx_ >

命名空间
namespace	phmap
namespace	phmap::priv
namespace	phmap::priv::hashtable_debug_internal
namespace	phmap::priv::memory_internal

类型定义
using	phmap::priv::ctrl_t = signed char
using	phmap::priv::h2_t = uint8_t
using	phmap::priv::Group = GroupPortableImpl

枚举
enum	phmap::priv::Ctrl : ctrl_t { phmap::priv::kEmpty = -128 , phmap::priv::kDeleted = -2 , phmap::priv::kSentinel = -1 }

函数
template<typename AllocType >
void	phmap::priv::SwapAlloc (AllocType &lhs, AllocType &rhs, std::true_type)
template<typename AllocType >
void	phmap::priv::SwapAlloc (AllocType &, AllocType &, std::false_type)
template<class T >
constexpr bool	phmap::priv::IsNoThrowSwappable ()
template<typename T >
int	phmap::priv::TrailingZeros (T x)
template<typename T >
int	phmap::priv::LeadingZeros (T x)
ctrl_t *	phmap::priv::EmptyGroup ()
size_t	phmap::priv::HashSeed (const ctrl_t *ctrl)
size_t	phmap::priv::H1 (size_t hashval, const ctrl_t *)
h2_t	phmap::priv::H2 (size_t hashval)
bool	phmap::priv::IsEmpty (ctrl_t c)
bool	phmap::priv::IsFull (ctrl_t c)
bool	phmap::priv::IsDeleted (ctrl_t c)
bool	phmap::priv::IsEmptyOrDeleted (ctrl_t c)
constexpr size_t	phmap::priv::NumClonedBytes ()
bool	phmap::priv::IsValidCapacity (size_t n)
void	phmap::priv::ConvertDeletedToEmptyAndFullToDeleted (ctrl_t *ctrl, size_t capacity)
size_t	phmap::priv::NormalizeCapacity (size_t n)
size_t	phmap::priv::CapacityToGrowth (size_t capacity)
size_t	phmap::priv::GrowthToLowerboundCapacity (size_t growth)
template<typename T , typename = typename T::mapped_type>
auto	phmap::priv::hashtable_debug_internal::GetKey (const typename T::value_type &pair, int) -> decltype(get< 0 >(pair))
template<typename T >
const T::key_type &	phmap::priv::hashtable_debug_internal::GetKey (const typename T::key_type &key, char)
void	phmap::priv::RecordRehashSlow (HashtablezInfo *, size_t)
static void	phmap::priv::RecordInsertSlow (HashtablezInfo *, size_t, size_t)
static void	phmap::priv::RecordEraseSlow (HashtablezInfo *)
static HashtablezInfo *	phmap::priv::SampleSlow (int64_t *)
static void	phmap::priv::UnsampleSlow (HashtablezInfo *)
static HashtablezInfoHandle	phmap::priv::Sample ()
static void	phmap::priv::SetHashtablezEnabled (bool)
static void	phmap::priv::SetHashtablezSampleParameter (int32_t)
static void	phmap::priv::SetHashtablezMaxSamples (int32_t)
template<class Alloc , class T , class Tuple , size_t... I>
void	phmap::priv::memory_internal::ConstructFromTupleImpl (Alloc *alloc, T *ptr, Tuple &&t, phmap::index_sequence< I... >)
template<class T , class Tuple , size_t... Is, class F >
decltype(std::declval< F >()(std::declval< T >()))	phmap::priv::memory_internal::WithConstructedImpl (Tuple &&t, phmap::index_sequence< Is... >, F &&f)
template<class T , size_t... Is>
auto	phmap::priv::memory_internal::TupleRefImpl (T &&t, phmap::index_sequence< Is... >) -> decltype(std::forward_as_tuple(std::get< Is >(std::forward< T >(t))...))
template<class T >
auto	phmap::priv::memory_internal::TupleRef (T &&t) -> decltype(TupleRefImpl(std::forward< T >(t), phmap::make_index_sequence< std::tuple_size< typename std::decay< T >::type >::value >()))
template<class F , class K , class V >
decltype(std::declval< F >()(std::declval< const K & >(), std::piecewise_construct, std::declval< std::tuple< K > >(), std::declval< V >()))	phmap::priv::memory_internal::DecomposePairImpl (F &&f, std::pair< std::tuple< K >, V > p)
size_t	phmap::priv::RandomSeed ()
template<class Alloc , class T , class Tuple >
void	phmap::priv::ConstructFromTuple (Alloc *alloc, T *ptr, Tuple &&t)
template<class T , class Tuple , class F >
decltype(std::declval< F >()(std::declval< T >()))	phmap::priv::WithConstructed (Tuple &&t, F &&f)
std::pair< std::tuple<>, std::tuple<> >	phmap::priv::PairArgs ()
template<class F , class S >
std::pair< std::tuple< F && >, std::tuple< S && > >	phmap::priv::PairArgs (F &&f, S &&s)
template<class F , class S >
std::pair< std::tuple< const F & >, std::tuple< const S & > >	phmap::priv::PairArgs (const std::pair< F, S > &p)
template<class F , class S >
std::pair< std::tuple< F && >, std::tuple< S && > >	phmap::priv::PairArgs (std::pair< F, S > &&p)
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))))
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)...)))
template<class F , class Arg >
decltype(std::declval< F >()(std::declval< const Arg & >(), std::declval< Arg >()))	phmap::priv::DecomposeValue (F &&f, Arg &&arg)
template<class C , class Pred >
std::size_t	phmap::priv::erase_if (C &c, Pred pred)
template<class T , class Hash , class Eq , class Alloc , class Pred >
std::size_t	phmap::erase_if (phmap::flat_hash_set< T, Hash, Eq, Alloc > &c, Pred pred)
template<class T , class Hash , class Eq , class Alloc , class Pred >
std::size_t	phmap::erase_if (phmap::node_hash_set< T, Hash, Eq, Alloc > &c, Pred pred)
template<class T , class Hash , class Eq , class Alloc , size_t N, class Mtx_ , class Pred >
std::size_t	phmap::erase_if (phmap::parallel_flat_hash_set< T, Hash, Eq, Alloc, N, Mtx_ > &c, Pred pred)
template<class T , class Hash , class Eq , class Alloc , size_t N, class Mtx_ , class Pred >
std::size_t	phmap::erase_if (phmap::parallel_node_hash_set< T, Hash, Eq, Alloc, N, Mtx_ > &c, Pred pred)
template<class K , class V , class Hash , class Eq , class Alloc , class Pred >
std::size_t	phmap::erase_if (phmap::flat_hash_map< K, V, Hash, Eq, Alloc > &c, Pred pred)
template<class K , class V , class Hash , class Eq , class Alloc , class Pred >
std::size_t	phmap::erase_if (phmap::node_hash_map< K, V, Hash, Eq, Alloc > &c, Pred pred)
template<class K , class V , class Hash , class Eq , class Alloc , size_t N, class Mtx_ , class Pred >
std::size_t	phmap::erase_if (phmap::parallel_flat_hash_map< K, V, Hash, Eq, Alloc, N, Mtx_ > &c, Pred pred)
template<class K , class V , class Hash , class Eq , class Alloc , size_t N, class Mtx_ , class Pred >
std::size_t	phmap::erase_if (phmap::parallel_node_hash_map< K, V, Hash, Eq, Alloc, N, Mtx_ > &c, Pred pred)