phmap_base.h 文件参考

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <string>
#include <type_traits>
#include <utility>
#include <functional>
#include <tuple>
#include <memory>
#include <mutex>
#include "phmap_config.h"

浏览源代码.

类
struct	phmap::EqualTo< T >
struct	phmap::Less< T >
struct	phmap::type_traits_internal::VoidTImpl< Ts >
struct	phmap::type_traits_internal::default_alignment_of_aligned_storage< Len, std::aligned_storage< Len, Align > >
struct	phmap::type_traits_internal::is_detected_impl< Enabler, Op, Args >
struct	phmap::type_traits_internal::is_detected_impl< typename VoidTImpl< Op< Args... > >::type, Op, Args... >
struct	phmap::type_traits_internal::is_detected< Op, Args >
struct	phmap::type_traits_internal::is_detected_convertible_impl< Enabler, To, Op, Args >
struct	phmap::type_traits_internal::is_detected_convertible_impl< typename std::enable_if< std::is_convertible< Op< Args... >, To >::value >::type, To, Op, Args... >
struct	phmap::type_traits_internal::is_detected_convertible< To, Op, Args >
struct	phmap::is_copy_assignable< T >
struct	phmap::is_move_assignable< T >
struct	phmap::conjunction< T, Ts... >
struct	phmap::conjunction< T >
struct	phmap::conjunction<>
struct	phmap::disjunction< T, Ts... >
struct	phmap::disjunction< T >
struct	phmap::disjunction<>
struct	phmap::negation< T >
struct	phmap::is_trivially_destructible< T >
struct	phmap::is_trivially_default_constructible< T >
struct	phmap::is_trivially_copy_constructible< T >
struct	phmap::is_trivially_copy_assignable< T >
struct	phmap::type_traits_internal::IsHashable< Key, typename >
struct	phmap::type_traits_internal::IsHashable< Key, phmap::enable_if_t< std::is_convertible< decltype(std::declval< std::hash< Key > & >()(std::declval< Key const & >())), std::size_t >::value > >
struct	phmap::type_traits_internal::AssertHashEnabledHelper
struct	phmap::type_traits_internal::AssertHashEnabledHelper::NAT
struct	phmap::priv::hash_policy_traits< Policy, class >
struct	phmap::priv::hash_policy_traits< Policy, class >::ReturnKey
struct	phmap::priv::hash_policy_traits< Policy, class >::ConstantIteratorsImpl< P, class >
struct	phmap::priv::hash_policy_traits< Policy, class >::ConstantIteratorsImpl< P, phmap::void_t< typename P::constant_iterators > >
struct	phmap::internal::identity< T >
struct	phmap::base_internal::StrippedAccept< Derived >
struct	phmap::base_internal::StrippedAccept< Derived >::Accept< Args >
struct	phmap::base_internal::MemFunAndRef
struct	phmap::base_internal::MemFunAndRef::AcceptImpl< Args >
struct	phmap::base_internal::MemFunAndRef::AcceptImpl< R(C::*)(Params...), Obj, Args... >
struct	phmap::base_internal::MemFunAndRef::AcceptImpl< R(C::*)(Params...) const, Obj, Args... >
struct	phmap::base_internal::MemFunAndPtr
struct	phmap::base_internal::MemFunAndPtr::AcceptImpl< Args >
struct	phmap::base_internal::MemFunAndPtr::AcceptImpl< R(C::*)(Params...), Ptr, Args... >
struct	phmap::base_internal::MemFunAndPtr::AcceptImpl< R(C::*)(Params...) const, Ptr, Args... >
struct	phmap::base_internal::DataMemAndRef
struct	phmap::base_internal::DataMemAndRef::AcceptImpl< Args >
struct	phmap::base_internal::DataMemAndRef::AcceptImpl< R C::*, Obj >
struct	phmap::base_internal::DataMemAndPtr
struct	phmap::base_internal::DataMemAndPtr::AcceptImpl< Args >
struct	phmap::base_internal::DataMemAndPtr::AcceptImpl< R C::*, Ptr >
struct	phmap::base_internal::Callable
struct	phmap::base_internal::Invoker< Args >
struct	phmap::integer_sequence< T, Ints >
struct	phmap::utility_internal::Extend< integer_sequence< T, Ints... >, SeqSize, 0 >
struct	phmap::utility_internal::Extend< integer_sequence< T, Ints... >, SeqSize, 1 >
struct	phmap::utility_internal::Gen< T, N >
struct	phmap::utility_internal::Gen< T, 0 >
struct	phmap::in_place_t
struct	phmap::in_place_type_t< T >
struct	phmap::in_place_index_t< I >
struct	phmap::memory_internal::MakeUniqueResult< T >
struct	phmap::memory_internal::MakeUniqueResult< T[]>
struct	phmap::memory_internal::MakeUniqueResult< T[N]>
struct	phmap::memory_internal::ExtractOr< Extract, Obj, Default, typename >
struct	phmap::memory_internal::ExtractOr< Extract, Obj, Default, void_t< Extract< Obj > > >
struct	phmap::memory_internal::GetFirstArg< Class< T, Args... > >
struct	phmap::memory_internal::ElementType< Ptr, typename >
struct	phmap::memory_internal::ElementType< T, void_t< typename T::element_type > >
struct	phmap::memory_internal::RebindFirstArg< Class< T, Args... >, U >
struct	phmap::memory_internal::RebindPtr< T, U, typename >
struct	phmap::memory_internal::RebindPtr< T, U, void_t< typename T::template rebind< U > > >
struct	phmap::memory_internal::RebindAlloc< T, U, bool >
struct	phmap::memory_internal::RebindAlloc< A, U, true >
struct	phmap::pointer_traits< Ptr >
struct	phmap::pointer_traits< T * >
struct	phmap::allocator_traits< Alloc >
struct	phmap::allocator_is_nothrow< Alloc >
struct	phmap::default_allocator_is_nothrow
class	phmap::bad_optional_access
struct	phmap::nullopt_t
struct	phmap::nullopt_t::init_t
struct	phmap::optional_internal::empty_struct
class	phmap::optional_internal::optional_data_dtor_base< T, unused >
struct	phmap::optional_internal::optional_data_dtor_base< T, unused >::dummy_type
class	phmap::optional_internal::optional_data_dtor_base< T, true >
struct	phmap::optional_internal::optional_data_dtor_base< T, true >::dummy_type
class	phmap::optional_internal::optional_data_base< T >
class	phmap::optional_internal::optional_data< T, true >
class	phmap::optional_internal::optional_data< T, false >
class	phmap::optional_internal::optional_ctor_base< copy_traits::copyable >
class	phmap::optional_internal::optional_ctor_base< copy_traits::movable >
class	phmap::optional_internal::optional_ctor_base< copy_traits::non_movable >
class	phmap::optional_internal::optional_assign_base< copy_traits::copyable >
class	phmap::optional_internal::optional_assign_base< copy_traits::movable >
class	phmap::optional_internal::optional_assign_base< copy_traits::non_movable >
struct	phmap::optional_internal::is_constructible_convertible_from_optional< T, U >
struct	phmap::optional_internal::is_constructible_convertible_assignable_from_optional< T, U >
struct	phmap::optional_internal::optional_hash_base< T, typename >
struct	phmap::optional_internal::optional_hash_base< T, decltype(std::hash< phmap::remove_const_t< T > >()(std::declval< phmap::remove_const_t< T > >()))>
class	phmap::optional< T >
struct	std::hash< phmap::optional< T > >
struct	phmap::priv::IsTransparent< class, class >
struct	phmap::priv::IsTransparent< T, phmap::void_t< typename T::is_transparent > >
struct	phmap::priv::KeyArg< is_transparent >
struct	phmap::priv::KeyArg< false >
class	phmap::priv::node_handle_base< PolicyTraits, Alloc >
struct	phmap::priv::node_handle_base< PolicyTraits, Alloc >::transfer_tag_t
struct	phmap::priv::node_handle_base< PolicyTraits, Alloc >::move_tag_t
class	phmap::priv::node_handle< Policy, PolicyTraits, Alloc, typename >
class	phmap::priv::node_handle< Policy, PolicyTraits, Alloc, phmap::void_t< typename Policy::mapped_type > >
struct	phmap::priv::CommonAccess
struct	phmap::priv::InsertReturnType< Iterator, NodeType >
struct	phmap::span_internal::ElementType< C >
struct	phmap::span_internal::ElementType< T(&)[N]>
struct	phmap::span_internal::IsConvertibleHelper< From, To >
struct	phmap::span_internal::IsConvertible< From, To >
class	phmap::Span< T >
struct	phmap::priv::internal_layout::NotAligned< T >
struct	phmap::priv::internal_layout::NotAligned< const Aligned< T, N > >
struct	phmap::priv::internal_layout::Type< T >
struct	phmap::priv::internal_layout::Type< Aligned< T, N > >
struct	phmap::priv::internal_layout::SizeOf< T >
struct	phmap::priv::internal_layout::SizeOf< Aligned< T, N > >
struct	phmap::priv::internal_layout::AlignOf< T >
struct	phmap::priv::internal_layout::AlignOf< Aligned< T, N > >
class	phmap::priv::internal_layout::LayoutImpl< std::tuple< Elements... >, phmap::index_sequence< SizeSeq... >, phmap::index_sequence< OffsetSeq... > >
class	phmap::priv::Layout< Ts >
struct	phmap::priv::internal_compressed_tuple::Elem< CompressedTuple< B... >, I >
struct	phmap::priv::internal_compressed_tuple::Storage< D, I, bool >
struct	phmap::priv::internal_compressed_tuple::Storage< D, I, true >
struct	phmap::priv::internal_compressed_tuple::CompressedTupleImpl< CompressedTuple< Ts... >, phmap::index_sequence< I... > >
class	phmap::priv::CompressedTuple< Ts >
class	phmap::priv::CompressedTuple<>
struct	phmap::priv::memory_internal::OffsetOf< Pair, class >
struct	phmap::priv::memory_internal::OffsetOf< Pair, typename std::is_standard_layout< Pair >::type >
struct	phmap::priv::memory_internal::IsLayoutCompatible< K, V >
struct	phmap::priv::memory_internal::IsLayoutCompatible< K, V >::Pair
union	phmap::priv::map_slot_type< K, V >
struct	phmap::priv::map_slot_policy< K, V >
struct	phmap::adopt_lock_t
struct	phmap::defer_lock_t
struct	phmap::try_to_lock_t
class	phmap::NullMutex
class	phmap::LockableBaseImpl< MutexType >
struct	phmap::LockableBaseImpl< MutexType >::DoNothing
class	phmap::LockableBaseImpl< MutexType >::WriteLock
class	phmap::LockableBaseImpl< MutexType >::ReadLock
class	phmap::LockableBaseImpl< MutexType >::WriteLocks
class	phmap::LockableBaseImpl< MutexType >::ReadLocks
class	phmap::LockableImpl< Mtx_ >
class	phmap::LockableImpl< phmap::NullMutex >

命名空间
namespace	phmap
namespace	phmap::type_traits_internal
namespace	phmap::priv
namespace	phmap::internal
namespace	phmap::base_internal
namespace	phmap::utility_internal
namespace	phmap::memory_internal
namespace	phmap::optional_internal
namespace	std
	STL namespace
namespace	phmap::span_internal
namespace	phmap::priv::internal_layout
namespace	phmap::priv::internal_layout::adl_barrier
namespace	phmap::priv::internal_compressed_tuple
namespace	phmap::thread_safety_analysis
namespace	phmap::priv::memory_internal

宏定义
#define	PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_   1
#define	PHMAP_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)
#define	PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
#define	PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(x)
#define	PHMAP_GUARDED_BY(x)   PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
#define	PHMAP_PT_GUARDED_BY(x)   PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
#define	PHMAP_ACQUIRED_AFTER(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
#define	PHMAP_ACQUIRED_BEFORE(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
#define	PHMAP_EXCLUSIVE_LOCKS_REQUIRED(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
#define	PHMAP_SHARED_LOCKS_REQUIRED(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
#define	PHMAP_LOCKS_EXCLUDED(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
#define	PHMAP_LOCK_RETURNED(x)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
#define	PHMAP_LOCKABLE    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
#define	PHMAP_SCOPED_LOCKABLE    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
#define	PHMAP_EXCLUSIVE_LOCK_FUNCTION(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
#define	PHMAP_SHARED_LOCK_FUNCTION(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
#define	PHMAP_UNLOCK_FUNCTION(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
#define	PHMAP_EXCLUSIVE_TRYLOCK_FUNCTION(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
#define	PHMAP_SHARED_TRYLOCK_FUNCTION(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
#define	PHMAP_ASSERT_EXCLUSIVE_LOCK(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
#define	PHMAP_ASSERT_SHARED_LOCK(...)    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
#define	PHMAP_NO_THREAD_SAFETY_ANALYSIS    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
#define	PHMAP_TS_UNCHECKED(x)   ""
#define	PHMAP_TS_FIXME(x)   ""
#define	PHMAP_NO_THREAD_SAFETY_ANALYSIS_FIXME   PHMAP_NO_THREAD_SAFETY_ANALYSIS
#define	PHMAP_GUARDED_BY_FIXME(x)
#define	PHMAP_TS_UNCHECKED_READ(x)   thread_safety_analysis::ts_unchecked_read(x)

类型定义
template<class T >
using	phmap::Allocator = typename std::allocator< T >
template<class T1 , class T2 >
using	phmap::Pair = typename std::pair< T1, T2 >
template<typename T >
using	phmap::type_traits_internal::IsCopyAssignableImpl = decltype(std::declval< T & >()=std::declval< const T & >())
template<typename T >
using	phmap::type_traits_internal::IsMoveAssignableImpl = decltype(std::declval< T & >()=std::declval< T && >())
template<typename T >
using	phmap::remove_cv_t = typename std::remove_cv< T >::type
template<typename T >
using	phmap::remove_const_t = typename std::remove_const< T >::type
template<typename T >
using	phmap::remove_volatile_t = typename std::remove_volatile< T >::type
template<typename T >
using	phmap::add_cv_t = typename std::add_cv< T >::type
template<typename T >
using	phmap::add_const_t = typename std::add_const< T >::type
template<typename T >
using	phmap::add_volatile_t = typename std::add_volatile< T >::type
template<typename T >
using	phmap::remove_reference_t = typename std::remove_reference< T >::type
template<typename T >
using	phmap::add_lvalue_reference_t = typename std::add_lvalue_reference< T >::type
template<typename T >
using	phmap::add_rvalue_reference_t = typename std::add_rvalue_reference< T >::type
template<typename T >
using	phmap::remove_pointer_t = typename std::remove_pointer< T >::type
template<typename T >
using	phmap::add_pointer_t = typename std::add_pointer< T >::type
template<typename T >
using	phmap::make_signed_t = typename std::make_signed< T >::type
template<typename T >
using	phmap::make_unsigned_t = typename std::make_unsigned< T >::type
template<typename T >
using	phmap::remove_extent_t = typename std::remove_extent< T >::type
template<typename T >
using	phmap::remove_all_extents_t = typename std::remove_all_extents< T >::type
template<size_t Len, size_t Align = type_traits_internal:: default_alignment_of_aligned_storage<Len>::value>
using	phmap::aligned_storage_t = typename std::aligned_storage< Len, Align >::type
template<typename T >
using	phmap::decay_t = typename std::decay< T >::type
template<bool B, typename T = void>
using	phmap::enable_if_t = typename std::enable_if< B, T >::type
template<bool B, typename T , typename F >
using	phmap::conditional_t = typename std::conditional< B, T, F >::type
template<typename... T>
using	phmap::common_type_t = typename std::common_type< T... >::type
template<typename T >
using	phmap::underlying_type_t = typename std::underlying_type< T >::type
template<class F , class... ArgTypes>
using	phmap::invoke_result_t = typename std::result_of< F(ArgTypes...)>::type
template<typename T >
using	phmap::internal::identity_t = typename identity< T >::type
template<typename F , typename... Args>
using	phmap::base_internal::InvokeT = decltype(Invoker< F, Args... >::type::Invoke(std::declval< F >(), std::declval< Args >()...))
template<size_t... Ints>
using	phmap::index_sequence = integer_sequence< size_t, Ints... >
template<typename T , T N>
using	phmap::make_integer_sequence = typename utility_internal::Gen< T, N >::type
template<size_t N>
using	phmap::make_index_sequence = make_integer_sequence< size_t, N >
template<typename... Ts>
using	phmap::index_sequence_for = make_index_sequence< sizeof...(Ts)>
template<template< typename > class Extract, typename Obj , typename Default >
using	phmap::memory_internal::ExtractOrT = typename ExtractOr< Extract, Obj, Default, void >::type
template<typename T >
using	phmap::memory_internal::GetPointer = typename T::pointer
template<typename T >
using	phmap::memory_internal::GetConstPointer = typename T::const_pointer
template<typename T >
using	phmap::memory_internal::GetVoidPointer = typename T::void_pointer
template<typename T >
using	phmap::memory_internal::GetConstVoidPointer = typename T::const_void_pointer
template<typename T >
using	phmap::memory_internal::GetDifferenceType = typename T::difference_type
template<typename T >
using	phmap::memory_internal::GetSizeType = typename T::size_type
template<typename T >
using	phmap::memory_internal::GetPropagateOnContainerCopyAssignment = typename T::propagate_on_container_copy_assignment
template<typename T >
using	phmap::memory_internal::GetPropagateOnContainerMoveAssignment = typename T::propagate_on_container_move_assignment
template<typename T >
using	phmap::memory_internal::GetPropagateOnContainerSwap = typename T::propagate_on_container_swap
template<typename T >
using	phmap::memory_internal::GetIsAlwaysEqual = typename T::is_always_equal
template<typename Alloc >
using	phmap::memory_internal::GetIsNothrow = typename Alloc::is_nothrow
template<typename C >
using	phmap::span_internal::HasSize = std::is_integral< phmap::decay_t< decltype(std::declval< C & >().size())> >
template<typename T , typename C >
using	phmap::span_internal::HasData = std::is_convertible< phmap::decay_t< decltype(GetData(std::declval< C & >()))> *, T *const * >
template<typename C >
using	phmap::span_internal::ElementT = typename ElementType< C >::type
template<typename T >
using	phmap::span_internal::EnableIfMutable = typename std::enable_if<!std::is_const< T >::value, int >::type
template<typename From , typename To >
using	phmap::span_internal::EnableIfConvertibleToSpanConst = typename std::enable_if< IsConvertible< From, Span< const To > >::value >::type
template<size_t >
using	phmap::priv::internal_layout::IntToSize = size_t
template<class >
using	phmap::priv::internal_layout::TypeToSize = size_t
template<class T , class... Ts>
using	phmap::priv::internal_layout::Contains = phmap::disjunction< std::is_same< T, Ts >... >
template<class From , class To >
using	phmap::priv::internal_layout::CopyConst = typename std::conditional< std::is_const< From >::value, const To, To >::type
template<class T >
using	phmap::priv::internal_layout::SliceType = Span< T >
template<bool C>
using	phmap::priv::internal_layout::EnableIf = typename std::enable_if< C, int >::type
template<class T >
using	phmap::priv::internal_layout::IsLegalElementType = std::integral_constant< bool, !std::is_reference< T >::value &&!std::is_volatile< T >::value &&!std::is_reference< typename Type< T >::type >::value &&!std::is_volatile< typename Type< T >::type >::value &&adl_barrier::IsPow2(AlignOf< T >::value)>
template<size_t NumSizes, class... Ts>
using	phmap::priv::internal_layout::LayoutType = LayoutImpl< std::tuple< Ts... >, phmap::make_index_sequence< NumSizes >, phmap::make_index_sequence< adl_barrier::Min(sizeof...(Ts), NumSizes+1)> >
template<typename D , size_t I>
using	phmap::priv::internal_compressed_tuple::ElemT = typename Elem< D, I >::type

枚举
enum class	phmap::optional_internal::copy_traits { phmap::optional_internal::copyable = 0 , phmap::optional_internal::movable = 1 , phmap::optional_internal::non_movable = 2 }

函数
template<class... Ts>
void	phmap::type_traits_internal::AssertHashEnabled ()
static void	phmap::base_internal::ThrowStdLogicError (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdLogicError (const char *what_arg)
static void	phmap::base_internal::ThrowStdInvalidArgument (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdInvalidArgument (const char *what_arg)
static void	phmap::base_internal::ThrowStdDomainError (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdDomainError (const char *what_arg)
static void	phmap::base_internal::ThrowStdLengthError (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdLengthError (const char *what_arg)
static void	phmap::base_internal::ThrowStdOutOfRange (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdOutOfRange (const char *what_arg)
static void	phmap::base_internal::ThrowStdRuntimeError (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdRuntimeError (const char *what_arg)
static void	phmap::base_internal::ThrowStdRangeError (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdRangeError (const char *what_arg)
static void	phmap::base_internal::ThrowStdOverflowError (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdOverflowError (const char *what_arg)
static void	phmap::base_internal::ThrowStdUnderflowError (const std::string &what_arg)
static void	phmap::base_internal::ThrowStdUnderflowError (const char *what_arg)
static void	phmap::base_internal::ThrowStdBadFunctionCall ()
static void	phmap::base_internal::ThrowStdBadAlloc ()
template<typename F , typename... Args>
InvokeT< F, Args... >	phmap::base_internal::Invoke (F &&f, Args &&... args)
	phmap::PHMAP_INTERNAL_INLINE_CONSTEXPR (in_place_t, in_place, {})
template<typename T >
constexpr phmap::remove_reference_t< T > &&	phmap::move (T &&t) noexcept
template<typename T >
constexpr T &&	phmap::forward (phmap::remove_reference_t< T > &t) noexcept
template<typename Functor , typename Tuple , std::size_t... Indexes>
auto	phmap::utility_internal::apply_helper (Functor &&functor, Tuple &&t, index_sequence< Indexes... >) -> decltype(phmap::base_internal::Invoke(phmap::forward< Functor >(functor), std::get< Indexes >(phmap::forward< Tuple >(t))...))
template<typename Functor , typename Tuple >
auto	phmap::apply (Functor &&functor, Tuple &&t) -> decltype(utility_internal::apply_helper(phmap::forward< Functor >(functor), phmap::forward< Tuple >(t), phmap::make_index_sequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >{}))
template<typename T , typename U = T>
T	phmap::exchange (T &obj, U &&new_value)
template<typename T >
std::unique_ptr< T >	phmap::WrapUnique (T *ptr)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult< T >::scalar	phmap::make_unique (Args &&... args)
template<typename T >
memory_internal::MakeUniqueResult< T >::array	phmap::make_unique (size_t n)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult< T >::invalid	phmap::make_unique (Args &&...)=delete
template<typename T >
auto	phmap::RawPtr (T &&ptr) -> decltype(std::addressof(*ptr))
std::nullptr_t	phmap::RawPtr (std::nullptr_t)
template<typename T , typename D >
std::shared_ptr< T >	phmap::ShareUniquePtr (std::unique_ptr< T, D > &&ptr)
template<typename T >
std::weak_ptr< T >	phmap::WeakenPtr (const std::shared_ptr< T > &ptr)
template<typename T , typename U >
constexpr bool	phmap::memory_internal::HasRebindAlloc (...)
template<typename T , typename U >
constexpr bool	phmap::memory_internal::HasRebindAlloc (typename std::allocator_traits< T >::template rebind_alloc< U > *)
template<typename Allocator , typename Iterator , typename... Args>
void	phmap::memory_internal::ConstructRange (Allocator &alloc, Iterator first, Iterator last, const Args &... args)
template<typename Allocator , typename Iterator , typename InputIterator >
void	phmap::memory_internal::CopyRange (Allocator &alloc, Iterator destination, InputIterator first, InputIterator last)
constexpr nullopt_t	phmap::nullopt (nullopt_t::init)
void	phmap::optional_internal::throw_bad_optional_access ()
template<typename T >
constexpr copy_traits	phmap::optional_internal::get_ctor_copy_traits ()
template<typename T >
constexpr copy_traits	phmap::optional_internal::get_assign_copy_traits ()
bool	phmap::optional_internal::convertible_to_bool (bool)
template<typename T , typename std::enable_if< std::is_move_constructible< T >::value, bool >::type = false>
void	phmap::swap (optional< T > &a, optional< T > &b) noexcept(noexcept(a.swap(b)))
template<typename T >
constexpr optional< typename std::decay< T >::type >	phmap::make_optional (T &&v)
template<typename T , typename... Args>
constexpr optional< T >	phmap::make_optional (Args &&... args)
template<typename T , typename U , typename... Args>
constexpr optional< T >	phmap::make_optional (std::initializer_list< U > il, Args &&... args)
template<typename T , typename U >
constexpr auto	phmap::operator== (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x== *y))
template<typename T , typename U >
constexpr auto	phmap::operator!= (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x != *y))
template<typename T , typename U >
constexpr auto	phmap::operator< (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x< *y))
template<typename T , typename U >
constexpr auto	phmap::operator> (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x > *y))
template<typename T , typename U >
constexpr auto	phmap::operator<= (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x<= *y))
template<typename T , typename U >
constexpr auto	phmap::operator>= (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x >= *y))
template<typename T >
constexpr bool	phmap::operator== (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	phmap::operator== (nullopt_t, const optional< T > &x) noexcept
template<typename T >
constexpr bool	phmap::operator!= (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	phmap::operator!= (nullopt_t, const optional< T > &x) noexcept
template<typename T >
constexpr bool	phmap::operator< (const optional< T > &, nullopt_t) noexcept
template<typename T >
constexpr bool	phmap::operator< (nullopt_t, const optional< T > &x) noexcept
template<typename T >
constexpr bool	phmap::operator<= (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	phmap::operator<= (nullopt_t, const optional< T > &) noexcept
template<typename T >
constexpr bool	phmap::operator> (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	phmap::operator> (nullopt_t, const optional< T > &) noexcept
template<typename T >
constexpr bool	phmap::operator>= (const optional< T > &, nullopt_t) noexcept
template<typename T >
constexpr bool	phmap::operator>= (nullopt_t, const optional< T > &x) noexcept
template<typename T , typename U >
constexpr auto	phmap::operator== (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x==v))
template<typename T , typename U >
constexpr auto	phmap::operator== (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v== *x))
template<typename T , typename U >
constexpr auto	phmap::operator!= (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x !=v))
template<typename T , typename U >
constexpr auto	phmap::operator!= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v != *x))
template<typename T , typename U >
constexpr auto	phmap::operator< (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x< v))
template<typename T , typename U >
constexpr auto	phmap::operator< (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v< *x))
template<typename T , typename U >
constexpr auto	phmap::operator<= (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x<=v))
template<typename T , typename U >
constexpr auto	phmap::operator<= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v<= *x))
template<typename T , typename U >
constexpr auto	phmap::operator> (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x > v))
template<typename T , typename U >
constexpr auto	phmap::operator> (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v > *x))
template<typename T , typename U >
constexpr auto	phmap::operator>= (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x >=v))
template<typename T , typename U >
constexpr auto	phmap::operator>= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v >= *x))
constexpr size_t	phmap::span_internal::Min (size_t a, size_t b) noexcept
template<typename C >
constexpr auto	phmap::span_internal::GetDataImpl (C &c, char) noexcept -> decltype(c.data())
char *	phmap::span_internal::GetDataImpl (std::string &s, int) noexcept
template<typename C >
constexpr auto	phmap::span_internal::GetData (C &c) noexcept -> decltype(GetDataImpl(c, 0))
template<typename T >
bool	phmap::span_internal::EqualImpl (Span< T > a, Span< T > b)
template<typename T >
bool	phmap::span_internal::LessThanImpl (Span< T > a, Span< T > b)
template<typename T >
bool	phmap::operator== (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator== (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator== (Span< T > a, const U &b)
template<typename T >
bool	phmap::operator!= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator!= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator!= (Span< T > a, const U &b)
template<typename T >
bool	phmap::operator< (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator< (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator< (Span< T > a, const U &b)
template<typename T >
bool	phmap::operator> (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator> (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator> (Span< T > a, const U &b)
template<typename T >
bool	phmap::operator<= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator<= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator<= (Span< T > a, const U &b)
template<typename T >
bool	phmap::operator>= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator>= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	phmap::operator>= (Span< T > a, const U &b)
template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span< T >	phmap::MakeSpan (T *ptr, size_t size) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
Span< T >	phmap::MakeSpan (T *begin, T *end) noexcept
template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto	phmap::MakeSpan (C &c) noexcept -> decltype(phmap::MakeSpan(span_internal::GetData(c), c.size()))
template<int &... ExplicitArgumentBarrier, typename T , size_t N>
constexpr Span< T >	phmap::MakeSpan (T(&array)[N]) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span< const T >	phmap::MakeConstSpan (T *ptr, size_t size) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
Span< const T >	phmap::MakeConstSpan (T *begin, T *end) noexcept
template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto	phmap::MakeConstSpan (const C &c) noexcept -> decltype(MakeSpan(c))
template<int &... ExplicitArgumentBarrier, typename T , size_t N>
constexpr Span< const T >	phmap::MakeConstSpan (const T(&array)[N]) noexcept
template<class Needle , class... Ts>
constexpr size_t	phmap::priv::internal_layout::adl_barrier::Find (Needle, Needle, Ts...)
template<class Needle , class T , class... Ts>
constexpr size_t	phmap::priv::internal_layout::adl_barrier::Find (Needle, T, Ts...)
constexpr bool	phmap::priv::internal_layout::adl_barrier::IsPow2 (size_t n)
constexpr size_t	phmap::priv::internal_layout::adl_barrier::Align (size_t n, size_t m)
constexpr size_t	phmap::priv::internal_layout::adl_barrier::Min (size_t a, size_t b)
constexpr size_t	phmap::priv::internal_layout::adl_barrier::Max (size_t a)
template<class... Ts>
constexpr size_t	phmap::priv::internal_layout::adl_barrier::Max (size_t a, size_t b, Ts... rest)
template<typename T >
constexpr bool	phmap::priv::internal_compressed_tuple::IsFinal ()
template<typename T >
constexpr bool	phmap::priv::internal_compressed_tuple::ShouldUseBase ()
template<size_t Alignment, class Alloc >
void *	phmap::priv::Allocate (Alloc *alloc, size_t n)
template<size_t Alignment, class Alloc >
void	phmap::priv::Deallocate (Alloc *alloc, void *p, size_t n)
void	phmap::priv::SanitizerPoisonMemoryRegion (const void *m, size_t s)
void	phmap::priv::SanitizerUnpoisonMemoryRegion (const void *m, size_t s)
template<typename T >
void	phmap::priv::SanitizerPoisonObject (const T *object)
template<typename T >
void	phmap::priv::SanitizerUnpoisonObject (const T *object)
template<typename T >
const T &	phmap::thread_safety_analysis::ts_unchecked_read (const T &v) PHMAP_NO_THREAD_SAFETY_ANALYSIS
template<typename T >
T &	phmap::thread_safety_analysis::ts_unchecked_read (T &v) PHMAP_NO_THREAD_SAFETY_ANALYSIS

变量
template<typename D , typename I >
struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC	phmap::priv::internal_compressed_tuple::CompressedTupleImpl

宏定义说明

PHMAP_ACQUIRED_AFTER

#define PHMAP_ACQUIRED_AFTER

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))

PHMAP_ACQUIRED_BEFORE

#define PHMAP_ACQUIRED_BEFORE

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))

PHMAP_ASSERT_EXCLUSIVE_LOCK

#define PHMAP_ASSERT_EXCLUSIVE_LOCK

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))

PHMAP_ASSERT_SHARED_LOCK

#define PHMAP_ASSERT_SHARED_LOCK

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))

PHMAP_EXCLUSIVE_LOCK_FUNCTION

#define PHMAP_EXCLUSIVE_LOCK_FUNCTION

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))

PHMAP_EXCLUSIVE_LOCKS_REQUIRED

#define PHMAP_EXCLUSIVE_LOCKS_REQUIRED

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))

PHMAP_EXCLUSIVE_TRYLOCK_FUNCTION

#define PHMAP_EXCLUSIVE_TRYLOCK_FUNCTION

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))

PHMAP_GUARDED_BY

#define PHMAP_GUARDED_BY

(

x

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))

PHMAP_GUARDED_BY_FIXME

#define PHMAP_GUARDED_BY_FIXME

(

x

)

PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC

#define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC

PHMAP_INTERNAL_INLINE_CONSTEXPR

#define PHMAP_INTERNAL_INLINE_CONSTEXPR	(		var_type,
			name,
			init
	)

值:

  template <class /*PhmapInternalDummy*/ = void>                               \
  struct PhmapInternalInlineVariableHolder##name {                             \
    static constexpr ::phmap::internal::identity_t<var_type> kInstance = init; \
  };                                                                          \
                                                                              \
  template <class PhmapInternalDummy>                                          \
  constexpr ::phmap::internal::identity_t<var_type>                            \
      PhmapInternalInlineVariableHolder##name<PhmapInternalDummy>::kInstance;   \
                                                                              \
  static constexpr const ::phmap::internal::identity_t<var_type>&              \
      name = /* NOLINT */                                                     \
      PhmapInternalInlineVariableHolder##name<>::kInstance;                    \
  static_assert(sizeof(void (*)(decltype(name))) != 0,                        \
                "Silence unused variable warnings.")

PHMAP_LOCK_RETURNED

#define PHMAP_LOCK_RETURNED

(

x

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))

PHMAP_LOCKABLE

#define PHMAP_LOCKABLE    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lockable)

PHMAP_LOCKS_EXCLUDED

#define PHMAP_LOCKS_EXCLUDED

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))

PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_

#define PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_   1

PHMAP_NO_THREAD_SAFETY_ANALYSIS

#define PHMAP_NO_THREAD_SAFETY_ANALYSIS    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)

PHMAP_NO_THREAD_SAFETY_ANALYSIS_FIXME

#define PHMAP_NO_THREAD_SAFETY_ANALYSIS_FIXME   PHMAP_NO_THREAD_SAFETY_ANALYSIS

PHMAP_PT_GUARDED_BY

#define PHMAP_PT_GUARDED_BY

(

x

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))

PHMAP_SCOPED_LOCKABLE

#define PHMAP_SCOPED_LOCKABLE    PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)

PHMAP_SHARED_LOCK_FUNCTION

#define PHMAP_SHARED_LOCK_FUNCTION

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))

PHMAP_SHARED_LOCKS_REQUIRED

#define PHMAP_SHARED_LOCKS_REQUIRED

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))

PHMAP_SHARED_TRYLOCK_FUNCTION

#define PHMAP_SHARED_TRYLOCK_FUNCTION

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__

#define PHMAP_THREAD_ANNOTATION_ATTRIBUTE__

(

x

)

PHMAP_TS_FIXME

#define PHMAP_TS_FIXME

(

x

)

""

PHMAP_TS_UNCHECKED

#define PHMAP_TS_UNCHECKED

(

x

)

""

PHMAP_TS_UNCHECKED_READ

#define PHMAP_TS_UNCHECKED_READ

(

x

)

thread_safety_analysis::ts_unchecked_read(x)

PHMAP_UNLOCK_FUNCTION

#define PHMAP_UNLOCK_FUNCTION

(

...

)

PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))