NIM PC Cross Platform SDK
载入中...
搜索中...
未找到
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>
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)