phmap 命名空间参考

命名空间
namespace	base_internal
namespace	big_endian
namespace	bits
namespace	compare_internal
namespace	internal
namespace	little_endian
namespace	macros_internal
namespace	memory_internal
namespace	optional_internal
namespace	priv
namespace	span_internal
namespace	swap_internal
namespace	thread_safety_analysis
namespace	type_traits_internal
namespace	utility_internal

类
struct	adopt_lock_t
struct	allocator_is_nothrow
struct	allocator_traits
class	bad_optional_access
class	BinaryInputArchive
class	BinaryOutputArchive
class	btree_map
class	btree_multimap
class	btree_multiset
class	btree_set
struct	Combiner
struct	Combiner< H, 4 >
struct	Combiner< H, 8 >
struct	conjunction
struct	conjunction< T >
struct	conjunction< T, Ts... >
struct	conjunction<>
struct	default_allocator_is_nothrow
struct	defer_lock_t
struct	disjunction
struct	disjunction< T >
struct	disjunction< T, Ts... >
struct	disjunction<>
struct	EqualTo
class	flat_hash_map
class	flat_hash_set
struct	fold_if_needed
struct	fold_if_needed< 4 >
struct	fold_if_needed< 8 >
struct	has_hash_value
struct	Hash
struct	Hash< bool >
struct	Hash< char >
struct	Hash< double >
struct	Hash< float >
struct	Hash< int16_t >
struct	Hash< int32_t >
struct	Hash< int64_t >
struct	Hash< signed char >
struct	Hash< std::pair< T1, T2 > >
struct	Hash< std::tuple< T... > >
struct	Hash< T * >
struct	Hash< uint16_t >
struct	Hash< uint32_t >
struct	Hash< uint64_t >
struct	Hash< unsigned char >
struct	Hash< wchar_t >
class	HashStateBase
struct	in_place_index_t
struct	in_place_t
struct	in_place_type_t
struct	integer_sequence
struct	is_copy_assignable
struct	is_function
struct	is_move_assignable
struct	is_trivially_copy_assignable
struct	is_trivially_copy_constructible
struct	is_trivially_default_constructible
struct	is_trivially_destructible
struct	is_trivially_move_assignable
struct	Less
class	LockableBaseImpl
class	LockableImpl
class	LockableImpl< phmap::NullMutex >
struct	negation
class	node_hash_map
class	node_hash_set
class	NullMutex
struct	nullopt_t
class	optional
class	parallel_flat_hash_map
class	parallel_flat_hash_set
class	parallel_node_hash_map
class	parallel_node_hash_set
class	partial_ordering
struct	phmap_mix
struct	phmap_mix< 4 >
struct	phmap_mix< 8 >
struct	phmap_unary_function
struct	pointer_traits
struct	pointer_traits< T * >
class	Span
class	strong_equality
class	strong_ordering
struct	try_to_lock_t
class	weak_equality
class	weak_ordering

类型定义
template<typename... Ts>
using	void_t = typename type_traits_internal::VoidTImpl< Ts... >::type
template<class T >
using	Allocator = typename std::allocator< T >
template<class T1 , class T2 >
using	Pair = typename std::pair< T1, T2 >
template<typename T >
using	remove_cv_t = typename std::remove_cv< T >::type
template<typename T >
using	remove_const_t = typename std::remove_const< T >::type
template<typename T >
using	remove_volatile_t = typename std::remove_volatile< T >::type
template<typename T >
using	add_cv_t = typename std::add_cv< T >::type
template<typename T >
using	add_const_t = typename std::add_const< T >::type
template<typename T >
using	add_volatile_t = typename std::add_volatile< T >::type
template<typename T >
using	remove_reference_t = typename std::remove_reference< T >::type
template<typename T >
using	add_lvalue_reference_t = typename std::add_lvalue_reference< T >::type
template<typename T >
using	add_rvalue_reference_t = typename std::add_rvalue_reference< T >::type
template<typename T >
using	remove_pointer_t = typename std::remove_pointer< T >::type
template<typename T >
using	add_pointer_t = typename std::add_pointer< T >::type
template<typename T >
using	make_signed_t = typename std::make_signed< T >::type
template<typename T >
using	make_unsigned_t = typename std::make_unsigned< T >::type
template<typename T >
using	remove_extent_t = typename std::remove_extent< T >::type
template<typename T >
using	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	aligned_storage_t = typename std::aligned_storage< Len, Align >::type
template<typename T >
using	decay_t = typename std::decay< T >::type
template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
template<bool B, typename T , typename F >
using	conditional_t = typename std::conditional< B, T, F >::type
template<typename... T>
using	common_type_t = typename std::common_type< T... >::type
template<typename T >
using	underlying_type_t = typename std::underlying_type< T >::type
template<class F , class... ArgTypes>
using	invoke_result_t = typename std::result_of< F(ArgTypes...)>::type
template<size_t... Ints>
using	index_sequence = integer_sequence< size_t, Ints... >
template<typename T , T N>
using	make_integer_sequence = typename utility_internal::Gen< T, N >::type
template<size_t N>
using	make_index_sequence = make_integer_sequence< size_t, N >
template<typename... Ts>
using	index_sequence_for = make_index_sequence< sizeof...(Ts)>
using	HashState = HashStateBase< size_t >

函数
	PHMAP_COMPARE_INLINE_INIT (weak_equality, equivalent, compare_internal::eq::equivalent)
	PHMAP_COMPARE_INLINE_INIT (weak_equality, nonequivalent, compare_internal::eq::nonequivalent)
	PHMAP_COMPARE_INLINE_INIT (strong_equality, equal, compare_internal::eq::equal)
	PHMAP_COMPARE_INLINE_INIT (strong_equality, nonequal, compare_internal::eq::nonequal)
	PHMAP_COMPARE_INLINE_INIT (strong_equality, equivalent, compare_internal::eq::equivalent)
	PHMAP_COMPARE_INLINE_INIT (strong_equality, nonequivalent, compare_internal::eq::nonequivalent)
	PHMAP_COMPARE_INLINE_INIT (partial_ordering, less, compare_internal::ord::less)
	PHMAP_COMPARE_INLINE_INIT (partial_ordering, equivalent, compare_internal::eq::equivalent)
	PHMAP_COMPARE_INLINE_INIT (partial_ordering, greater, compare_internal::ord::greater)
	PHMAP_COMPARE_INLINE_INIT (partial_ordering, unordered, compare_internal::ncmp::unordered)
	PHMAP_COMPARE_INLINE_INIT (weak_ordering, less, compare_internal::ord::less)
	PHMAP_COMPARE_INLINE_INIT (weak_ordering, equivalent, compare_internal::eq::equivalent)
	PHMAP_COMPARE_INLINE_INIT (weak_ordering, greater, compare_internal::ord::greater)
	PHMAP_COMPARE_INLINE_INIT (strong_ordering, less, compare_internal::ord::less)
	PHMAP_COMPARE_INLINE_INIT (strong_ordering, equal, compare_internal::eq::equal)
	PHMAP_COMPARE_INLINE_INIT (strong_ordering, equivalent, compare_internal::eq::equivalent)
	PHMAP_COMPARE_INLINE_INIT (strong_ordering, greater, compare_internal::ord::greater)
template<typename K , typename C , typename A >
void	swap (btree_set< K, C, A > &x, btree_set< K, C, A > &y)
template<typename K , typename C , typename A , typename Pred >
void	erase_if (btree_set< K, C, A > &set, Pred pred)
template<typename K , typename C , typename A >
void	swap (btree_multiset< K, C, A > &x, btree_multiset< K, C, A > &y)
template<typename K , typename C , typename A , typename Pred >
void	erase_if (btree_multiset< K, C, A > &set, Pred pred)
template<typename K , typename V , typename C , typename A >
void	swap (btree_map< K, V, C, A > &x, btree_map< K, V, C, A > &y)
template<typename K , typename V , typename C , typename A , typename Pred >
void	erase_if (btree_map< K, V, C, A > &map, Pred pred)
template<typename K , typename V , typename C , typename A >
void	swap (btree_multimap< K, V, C, A > &x, btree_multimap< K, V, C, A > &y)
template<typename K , typename V , typename C , typename A , typename Pred >
void	erase_if (btree_multimap< K, V, C, A > &map, Pred pred)
template<class T , class Hash , class Eq , class Alloc , class Pred >
std::size_t	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	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	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	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	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	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	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	erase_if (phmap::parallel_node_hash_map< K, V, Hash, Eq, Alloc, N, Mtx_ > &c, Pred pred)
	PHMAP_INTERNAL_INLINE_CONSTEXPR (in_place_t, in_place, {})
template<typename T >
constexpr phmap::remove_reference_t< T > &&	move (T &&t) noexcept
template<typename T >
constexpr T &&	forward (phmap::remove_reference_t< T > &t) noexcept
template<typename Functor , typename Tuple >
auto	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	exchange (T &obj, U &&new_value)
template<typename T >
std::unique_ptr< T >	WrapUnique (T *ptr)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult< T >::scalar	make_unique (Args &&... args)
template<typename T >
memory_internal::MakeUniqueResult< T >::array	make_unique (size_t n)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult< T >::invalid	make_unique (Args &&...)=delete
template<typename T >
auto	RawPtr (T &&ptr) -> decltype(std::addressof(*ptr))
std::nullptr_t	RawPtr (std::nullptr_t)
template<typename T , typename D >
std::shared_ptr< T >	ShareUniquePtr (std::unique_ptr< T, D > &&ptr)
template<typename T >
std::weak_ptr< T >	WeakenPtr (const std::shared_ptr< T > &ptr)
constexpr nullopt_t	nullopt (nullopt_t::init)
template<typename T , typename std::enable_if< std::is_move_constructible< T >::value, bool >::type = false>
void	swap (optional< T > &a, optional< T > &b) noexcept(noexcept(a.swap(b)))
template<typename T >
constexpr optional< typename std::decay< T >::type >	make_optional (T &&v)
template<typename T , typename... Args>
constexpr optional< T >	make_optional (Args &&... args)
template<typename T , typename U , typename... Args>
constexpr optional< T >	make_optional (std::initializer_list< U > il, Args &&... args)
template<typename T , typename U >
constexpr auto	operator== (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x== *y))
template<typename T , typename U >
constexpr auto	operator!= (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x != *y))
template<typename T , typename U >
constexpr auto	operator< (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x< *y))
template<typename T , typename U >
constexpr auto	operator> (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x > *y))
template<typename T , typename U >
constexpr auto	operator<= (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x<= *y))
template<typename T , typename U >
constexpr auto	operator>= (const optional< T > &x, const optional< U > &y) -> decltype(optional_internal::convertible_to_bool(*x >= *y))
template<typename T >
constexpr bool	operator== (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator== (nullopt_t, const optional< T > &x) noexcept
template<typename T >
constexpr bool	operator!= (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator!= (nullopt_t, const optional< T > &x) noexcept
template<typename T >
constexpr bool	operator< (const optional< T > &, nullopt_t) noexcept
template<typename T >
constexpr bool	operator< (nullopt_t, const optional< T > &x) noexcept
template<typename T >
constexpr bool	operator<= (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator<= (nullopt_t, const optional< T > &) noexcept
template<typename T >
constexpr bool	operator> (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator> (nullopt_t, const optional< T > &) noexcept
template<typename T >
constexpr bool	operator>= (const optional< T > &, nullopt_t) noexcept
template<typename T >
constexpr bool	operator>= (nullopt_t, const optional< T > &x) noexcept
template<typename T , typename U >
constexpr auto	operator== (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x==v))
template<typename T , typename U >
constexpr auto	operator== (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v== *x))
template<typename T , typename U >
constexpr auto	operator!= (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x !=v))
template<typename T , typename U >
constexpr auto	operator!= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v != *x))
template<typename T , typename U >
constexpr auto	operator< (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x< v))
template<typename T , typename U >
constexpr auto	operator< (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v< *x))
template<typename T , typename U >
constexpr auto	operator<= (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x<=v))
template<typename T , typename U >
constexpr auto	operator<= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v<= *x))
template<typename T , typename U >
constexpr auto	operator> (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x > v))
template<typename T , typename U >
constexpr auto	operator> (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v > *x))
template<typename T , typename U >
constexpr auto	operator>= (const optional< T > &x, const U &v) -> decltype(optional_internal::convertible_to_bool(*x >=v))
template<typename T , typename U >
constexpr auto	operator>= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v >= *x))
template<typename T >
bool	operator== (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator== (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator== (Span< T > a, const U &b)
template<typename T >
bool	operator!= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator!= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator!= (Span< T > a, const U &b)
template<typename T >
bool	operator< (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator< (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator< (Span< T > a, const U &b)
template<typename T >
bool	operator> (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator> (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator> (Span< T > a, const U &b)
template<typename T >
bool	operator<= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator<= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator<= (Span< T > a, const U &b)
template<typename T >
bool	operator>= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator>= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
bool	operator>= (Span< T > a, const U &b)
template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span< T >	MakeSpan (T *ptr, size_t size) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
Span< T >	MakeSpan (T *begin, T *end) noexcept
template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto	MakeSpan (C &c) noexcept -> decltype(phmap::MakeSpan(span_internal::GetData(c), c.size()))
template<int &... ExplicitArgumentBarrier, typename T , size_t N>
constexpr Span< T >	MakeSpan (T(&array)[N]) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span< const T >	MakeConstSpan (T *ptr, size_t size) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
Span< const T >	MakeConstSpan (T *begin, T *end) noexcept
template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto	MakeConstSpan (const C &c) noexcept -> decltype(MakeSpan(c))
template<int &... ExplicitArgumentBarrier, typename T , size_t N>
constexpr Span< const T >	MakeConstSpan (const T(&array)[N]) noexcept
uint64_t	gbswap_64 (uint64_t host_int)
uint32_t	gbswap_32 (uint32_t host_int)
uint16_t	gbswap_16 (uint16_t host_int)
uint16_t	gntohs (uint16_t x)
uint32_t	gntohl (uint32_t x)
uint64_t	gntohll (uint64_t x)

类型定义说明

add_const_t

template<typename T >

using phmap::add_const_t = typedef typename std::add_const<T>::type

add_cv_t

template<typename T >

using phmap::add_cv_t = typedef typename std::add_cv<T>::type

add_lvalue_reference_t

template<typename T >

using phmap::add_lvalue_reference_t = typedef typename std::add_lvalue_reference<T>::type

add_pointer_t

template<typename T >

using phmap::add_pointer_t = typedef typename std::add_pointer<T>::type

add_rvalue_reference_t

template<typename T >

using phmap::add_rvalue_reference_t = typedef typename std::add_rvalue_reference<T>::type

add_volatile_t

template<typename T >

using phmap::add_volatile_t = typedef typename std::add_volatile<T>::type

aligned_storage_t

template<size_t Len, size_t Align = type_traits_internal:: default_alignment_of_aligned_storage<Len>::value>

using phmap::aligned_storage_t = typedef typename std::aligned_storage<Len, Align>::type

Allocator

template<class T >

using phmap::Allocator = typedef typename std::allocator<T>

common_type_t

template<typename... T>

using phmap::common_type_t = typedef typename std::common_type<T...>::type

conditional_t

template<bool B, typename T , typename F >

using phmap::conditional_t = typedef typename std::conditional<B, T, F>::type

decay_t

template<typename T >

using phmap::decay_t = typedef typename std::decay<T>::type

enable_if_t

template<bool B, typename T = void>

using phmap::enable_if_t = typedef typename std::enable_if<B, T>::type

HashState

using phmap::HashState = typedef HashStateBase<size_t>

index_sequence

template<size_t... Ints>

using phmap::index_sequence = typedef integer_sequence<size_t, Ints...>

index_sequence_for

template<typename... Ts>

using phmap::index_sequence_for = typedef make_index_sequence<sizeof...(Ts)>

invoke_result_t

template<class F , class... ArgTypes>

using phmap::invoke_result_t = typedef typename std::result_of<F(ArgTypes...)>::type

make_index_sequence

template<size_t N>

using phmap::make_index_sequence = typedef make_integer_sequence<size_t, N>

make_integer_sequence

template<typename T , T N>

using phmap::make_integer_sequence = typedef typename utility_internal::Gen<T, N>::type

make_signed_t

template<typename T >

using phmap::make_signed_t = typedef typename std::make_signed<T>::type

make_unsigned_t

template<typename T >

using phmap::make_unsigned_t = typedef typename std::make_unsigned<T>::type

Pair

template<class T1 , class T2 >

using phmap::Pair = typedef typename std::pair<T1, T2>

remove_all_extents_t

template<typename T >

using phmap::remove_all_extents_t = typedef typename std::remove_all_extents<T>::type

remove_const_t

template<typename T >

using phmap::remove_const_t = typedef typename std::remove_const<T>::type

remove_cv_t

template<typename T >

using phmap::remove_cv_t = typedef typename std::remove_cv<T>::type

remove_extent_t

template<typename T >

using phmap::remove_extent_t = typedef typename std::remove_extent<T>::type

remove_pointer_t

template<typename T >

using phmap::remove_pointer_t = typedef typename std::remove_pointer<T>::type

remove_reference_t

template<typename T >

using phmap::remove_reference_t = typedef typename std::remove_reference<T>::type

remove_volatile_t

template<typename T >

using phmap::remove_volatile_t = typedef typename std::remove_volatile<T>::type

underlying_type_t

template<typename T >

using phmap::underlying_type_t = typedef typename std::underlying_type<T>::type

void_t

template<typename... Ts>

using phmap::void_t = typedef typename type_traits_internal::VoidTImpl<Ts...>::type

函数说明

apply()

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>{}))

erase_if() [1/12]

template<typename K , typename V , typename C , typename A , typename Pred >

void phmap::erase_if	(	btree_map< K, V, C, A > &	map,
		Pred	pred
	)

erase_if() [2/12]

template<typename K , typename V , typename C , typename A , typename Pred >

void phmap::erase_if	(	btree_multimap< K, V, C, A > &	map,
		Pred	pred
	)

erase_if() [3/12]

template<typename K , typename C , typename A , typename Pred >

void phmap::erase_if	(	btree_multiset< K, C, A > &	set,
		Pred	pred
	)

erase_if() [4/12]

template<typename K , typename C , typename A , typename Pred >

void phmap::erase_if	(	btree_set< K, C, A > &	set,
		Pred	pred
	)

erase_if() [5/12]

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
	)

erase_if() [6/12]

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
	)

erase_if() [7/12]

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
	)

erase_if() [8/12]

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
	)

erase_if() [9/12]

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
	)

erase_if() [10/12]

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
	)

erase_if() [11/12]

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
	)

erase_if() [12/12]

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
	)

exchange()

template<typename T , typename U = T>

T phmap::exchange	(	T &	obj,
		U &&	new_value
	)

forward()

template<typename T >

constexpr T && phmap::forward ( phmap::remove_reference_t< T > &  t )

constexprnoexcept

gbswap_16()

uint16_t phmap::gbswap_16 ( uint16_t  host_int )

inline

gbswap_32()

uint32_t phmap::gbswap_32 ( uint32_t  host_int )

inline

gbswap_64()

uint64_t phmap::gbswap_64 ( uint64_t  host_int )

inline

gntohl()

uint32_t phmap::gntohl ( uint32_t  x )

inline

gntohll()

uint64_t phmap::gntohll ( uint64_t  x )

inline

gntohs()

uint16_t phmap::gntohs ( uint16_t  x )

inline

make_optional() [1/3]

template<typename T , typename... Args>

constexpr optional< T > phmap::make_optional ( Args &&...  args )

constexpr

make_optional() [2/3]

template<typename T , typename U , typename... Args>

constexpr optional< T > phmap::make_optional ( std::initializer_list< U >  il, Args &&...  args  )

constexpr

make_optional() [3/3]

template<typename T >

constexpr optional< typename std::decay< T >::type > phmap::make_optional ( T &&  v )

constexpr

make_unique() [1/3]

template<typename T , typename... Args>

memory_internal::MakeUniqueResult< T >::scalar phmap::make_unique

(

Args &&...

args

)

make_unique() [2/3]

template<typename T , typename... Args>

memory_internal::MakeUniqueResult< T >::invalid phmap::make_unique ( Args &&  ... )

delete

make_unique() [3/3]

template<typename T >

memory_internal::MakeUniqueResult< T >::array phmap::make_unique

(

size_t

n

)

MakeConstSpan() [1/4]

template<int &... ExplicitArgumentBarrier, typename C >

constexpr auto phmap::MakeConstSpan ( const C &  c ) -> decltype(MakeSpan(c))

constexprnoexcept

MakeConstSpan() [2/4]

template<int &... ExplicitArgumentBarrier, typename T , size_t N>

constexpr Span< const T > phmap::MakeConstSpan ( const T(&)  array[N] )

constexprnoexcept

MakeConstSpan() [3/4]

template<int &... ExplicitArgumentBarrier, typename T >

Span< const T > phmap::MakeConstSpan ( T *  begin, T *  end  )

noexcept

MakeConstSpan() [4/4]

template<int &... ExplicitArgumentBarrier, typename T >

constexpr Span< const T > phmap::MakeConstSpan ( T *  ptr, size_t  size  )

constexprnoexcept

MakeSpan() [1/4]

template<int &... ExplicitArgumentBarrier, typename C >

constexpr auto phmap::MakeSpan ( C &  c ) -> decltype(phmap::MakeSpan(span_internal::GetData(c), c.size()))

constexprnoexcept

MakeSpan() [2/4]

template<int &... ExplicitArgumentBarrier, typename T >

Span< T > phmap::MakeSpan ( T *  begin, T *  end  )

noexcept

MakeSpan() [3/4]

template<int &... ExplicitArgumentBarrier, typename T >

constexpr Span< T > phmap::MakeSpan ( T *  ptr, size_t  size  )

constexprnoexcept

MakeSpan() [4/4]

template<int &... ExplicitArgumentBarrier, typename T , size_t N>

constexpr Span< T > phmap::MakeSpan ( T(&)  array[N] )

constexprnoexcept

move()

template<typename T >

constexpr phmap::remove_reference_t< T > && phmap::move ( T &&  t )

constexprnoexcept

nullopt()

constexpr nullopt_t phmap::nullopt ( nullopt_t::init  )

constexpr

operator!=() [1/8]

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

constexpr

operator!=() [2/8]

template<typename T , typename U >

constexpr auto phmap::operator!= ( const optional< T > &  x, const U &  v  ) -> decltype(optional_internal::convertible_to_bool(*x != v))

constexpr

operator!=() [3/8]

template<typename T >

constexpr bool phmap::operator!= ( const optional< T > &  x, nullopt_t    )

constexprnoexcept

operator!=() [4/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator!=	(	const U &	a,
		Span< T >	b
	)

operator!=() [5/8]

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

operator!=() [6/8]

template<typename T >

constexpr bool phmap::operator!= ( nullopt_t  , const optional< T > &  x  )

constexprnoexcept

operator!=() [7/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator!=	(	Span< T >	a,
		const U &	b
	)

operator!=() [8/8]

template<typename T >

bool phmap::operator!=	(	Span< T >	a,
		Span< T >	b
	)

operator<() [1/8]

template<typename T >

constexpr bool phmap::operator< ( const optional< T > &  , nullopt_t    )

constexprnoexcept

operator<() [2/8]

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

constexpr

operator<() [3/8]

template<typename T , typename U >

constexpr auto phmap::operator< ( const optional< T > &  x, const U &  v  ) -> decltype(optional_internal::convertible_to_bool(*x < v))

constexpr

operator<() [4/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator<	(	const U &	a,
		Span< T >	b
	)

operator<() [5/8]

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

operator<() [6/8]

template<typename T >

constexpr bool phmap::operator< ( nullopt_t  , const optional< T > &  x  )

constexprnoexcept

operator<() [7/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator<	(	Span< T >	a,
		const U &	b
	)

operator<() [8/8]

template<typename T >

bool phmap::operator<	(	Span< T >	a,
		Span< T >	b
	)

operator<=() [1/8]

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

constexpr

operator<=() [2/8]

template<typename T , typename U >

constexpr auto phmap::operator<= ( const optional< T > &  x, const U &  v  ) -> decltype(optional_internal::convertible_to_bool(*x <= v))

constexpr

operator<=() [3/8]

template<typename T >

constexpr bool phmap::operator<= ( const optional< T > &  x, nullopt_t    )

constexprnoexcept

operator<=() [4/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator<=	(	const U &	a,
		Span< T >	b
	)

operator<=() [5/8]

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

operator<=() [6/8]

template<typename T >

constexpr bool phmap::operator<= ( nullopt_t  , const optional< T > &    )

constexprnoexcept

operator<=() [7/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator<=	(	Span< T >	a,
		const U &	b
	)

operator<=() [8/8]

template<typename T >

bool phmap::operator<=	(	Span< T >	a,
		Span< T >	b
	)

operator==() [1/8]

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

constexpr

operator==() [2/8]

template<typename T , typename U >

constexpr auto phmap::operator== ( const optional< T > &  x, const U &  v  ) -> decltype(optional_internal::convertible_to_bool(*x == v))

constexpr

operator==() [3/8]

template<typename T >

constexpr bool phmap::operator== ( const optional< T > &  x, nullopt_t    )

constexprnoexcept

operator==() [4/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator==	(	const U &	a,
		Span< T >	b
	)

operator==() [5/8]

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

operator==() [6/8]

template<typename T >

constexpr bool phmap::operator== ( nullopt_t  , const optional< T > &  x  )

constexprnoexcept

operator==() [7/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator==	(	Span< T >	a,
		const U &	b
	)

operator==() [8/8]

template<typename T >

bool phmap::operator==	(	Span< T >	a,
		Span< T >	b
	)

operator>() [1/8]

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

constexpr

operator>() [2/8]

template<typename T , typename U >

constexpr auto phmap::operator> ( const optional< T > &  x, const U &  v  ) -> decltype(optional_internal::convertible_to_bool(*x > v))

constexpr

operator>() [3/8]

template<typename T >

constexpr bool phmap::operator> ( const optional< T > &  x, nullopt_t    )

constexprnoexcept

operator>() [4/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator>	(	const U &	a,
		Span< T >	b
	)

operator>() [5/8]

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

operator>() [6/8]

template<typename T >

constexpr bool phmap::operator> ( nullopt_t  , const optional< T > &    )

constexprnoexcept

operator>() [7/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator>	(	Span< T >	a,
		const U &	b
	)

operator>() [8/8]

template<typename T >

bool phmap::operator>	(	Span< T >	a,
		Span< T >	b
	)

operator>=() [1/8]

template<typename T >

constexpr bool phmap::operator>= ( const optional< T > &  , nullopt_t    )

constexprnoexcept

operator>=() [2/8]

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

constexpr

operator>=() [3/8]

template<typename T , typename U >

constexpr auto phmap::operator>= ( const optional< T > &  x, const U &  v  ) -> decltype(optional_internal::convertible_to_bool(*x >= v))

constexpr

operator>=() [4/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator>=	(	const U &	a,
		Span< T >	b
	)

operator>=() [5/8]

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

operator>=() [6/8]

template<typename T >

constexpr bool phmap::operator>= ( nullopt_t  , const optional< T > &  x  )

constexprnoexcept

operator>=() [7/8]

template<typename T , typename U , typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>

bool phmap::operator>=	(	Span< T >	a,
		const U &	b
	)

operator>=() [8/8]

template<typename T >

bool phmap::operator>=	(	Span< T >	a,
		Span< T >	b
	)

PHMAP_COMPARE_INLINE_INIT() [1/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	partial_ordering	,
		equivalent	,
		compare_internal::eq::equivalent
	)

PHMAP_COMPARE_INLINE_INIT() [2/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	partial_ordering	,
		greater	,
		compare_internal::ord::greater
	)

PHMAP_COMPARE_INLINE_INIT() [3/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	partial_ordering	,
		less	,
		compare_internal::ord::less
	)

PHMAP_COMPARE_INLINE_INIT() [4/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	partial_ordering	,
		unordered	,
		compare_internal::ncmp::unordered
	)

PHMAP_COMPARE_INLINE_INIT() [5/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_equality	,
		equal	,
		compare_internal::eq::equal
	)

PHMAP_COMPARE_INLINE_INIT() [6/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_equality	,
		equivalent	,
		compare_internal::eq::equivalent
	)

PHMAP_COMPARE_INLINE_INIT() [7/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_equality	,
		nonequal	,
		compare_internal::eq::nonequal
	)

PHMAP_COMPARE_INLINE_INIT() [8/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_equality	,
		nonequivalent	,
		compare_internal::eq::nonequivalent
	)

PHMAP_COMPARE_INLINE_INIT() [9/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_ordering	,
		equal	,
		compare_internal::eq::equal
	)

PHMAP_COMPARE_INLINE_INIT() [10/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_ordering	,
		equivalent	,
		compare_internal::eq::equivalent
	)

PHMAP_COMPARE_INLINE_INIT() [11/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_ordering	,
		greater	,
		compare_internal::ord::greater
	)

PHMAP_COMPARE_INLINE_INIT() [12/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	strong_ordering	,
		less	,
		compare_internal::ord::less
	)

PHMAP_COMPARE_INLINE_INIT() [13/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	weak_equality	,
		equivalent	,
		compare_internal::eq::equivalent
	)

PHMAP_COMPARE_INLINE_INIT() [14/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	weak_equality	,
		nonequivalent	,
		compare_internal::eq::nonequivalent
	)

PHMAP_COMPARE_INLINE_INIT() [15/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	weak_ordering	,
		equivalent	,
		compare_internal::eq::equivalent
	)

PHMAP_COMPARE_INLINE_INIT() [16/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	weak_ordering	,
		greater	,
		compare_internal::ord::greater
	)

PHMAP_COMPARE_INLINE_INIT() [17/17]

phmap::PHMAP_COMPARE_INLINE_INIT	(	weak_ordering	,
		less	,
		compare_internal::ord::less
	)

PHMAP_INTERNAL_INLINE_CONSTEXPR()

phmap::PHMAP_INTERNAL_INLINE_CONSTEXPR	(	in_place_t	,
		in_place	,
		{}
	)

RawPtr() [1/2]

std::nullptr_t phmap::RawPtr ( std::nullptr_t  )

inline

RawPtr() [2/2]

template<typename T >

auto phmap::RawPtr

(

T &&

ptr

)

-> decltype(std::addressof(*ptr))

ShareUniquePtr()

template<typename T , typename D >

std::shared_ptr< T > phmap::ShareUniquePtr

(

std::unique_ptr< T, D > &&

ptr

)

swap() [1/5]

template<typename K , typename V , typename C , typename A >

void phmap::swap	(	btree_map< K, V, C, A > &	x,
		btree_map< K, V, C, A > &	y
	)

swap() [2/5]

template<typename K , typename V , typename C , typename A >

void phmap::swap	(	btree_multimap< K, V, C, A > &	x,
		btree_multimap< K, V, C, A > &	y
	)

swap() [3/5]

template<typename K , typename C , typename A >

void phmap::swap	(	btree_multiset< K, C, A > &	x,
		btree_multiset< K, C, A > &	y
	)

swap() [4/5]

template<typename K , typename C , typename A >

void phmap::swap	(	btree_set< K, C, A > &	x,
		btree_set< K, C, A > &	y
	)

swap() [5/5]

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

WeakenPtr()

template<typename T >

std::weak_ptr< T > phmap::WeakenPtr

(

const std::shared_ptr< T > &

ptr

)

WrapUnique()

template<typename T >

std::unique_ptr< T > phmap::WrapUnique

(

T *

ptr

)