btree.h 文件参考

#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <limits>
#include <new>
#include "phmap_fwd_decl.h"
#include "phmap_base.h"

浏览源代码.

类
union	phmap::type_traits_internal::SingleMemberUnion< T >
struct	phmap::type_traits_internal::IsTriviallyMoveConstructibleObject< T >
struct	phmap::type_traits_internal::IsTriviallyCopyConstructibleObject< T >
struct	phmap::type_traits_internal::IsTriviallyMoveAssignableReference< T >
struct	phmap::type_traits_internal::IsTriviallyMoveAssignableReference< T & >
struct	phmap::type_traits_internal::IsTriviallyMoveAssignableReference< T && >
struct	phmap::is_function< T >
class	phmap::type_traits_internal::is_trivially_copyable_impl< T >
struct	phmap::type_traits_internal::is_trivially_copyable< T >
struct	phmap::swap_internal::IsSwappable< T >
struct	phmap::swap_internal::IsNothrowSwappable< T >
struct	phmap::compare_internal::Fail< T >
struct	phmap::compare_internal::OnlyLiteralZero< NullPtrT >
struct	phmap::compare_internal::weak_equality_base< T >
struct	phmap::compare_internal::strong_equality_base< T >
struct	phmap::compare_internal::partial_ordering_base< T >
struct	phmap::compare_internal::weak_ordering_base< T >
struct	phmap::compare_internal::strong_ordering_base< T >
class	phmap::weak_equality
class	phmap::strong_equality
class	phmap::partial_ordering
class	phmap::weak_ordering
class	phmap::strong_ordering
struct	phmap::priv::StringBtreeDefaultLess
struct	phmap::priv::StringBtreeDefaultGreater
struct	phmap::priv::key_compare_to_adapter< Compare >
struct	phmap::priv::key_compare_to_adapter< std::less< std::string > >
struct	phmap::priv::key_compare_to_adapter< phmap::Less< std::string > >
struct	phmap::priv::key_compare_to_adapter< std::greater< std::string > >
struct	phmap::priv::common_params< Key, Compare, Alloc, TargetNodeSize, Multi, SlotPolicy >
struct	phmap::priv::map_params< Key, Data, Compare, Alloc, TargetNodeSize, Multi >
struct	phmap::priv::map_params< Key, Data, Compare, Alloc, TargetNodeSize, Multi >::value_compare
struct	phmap::priv::set_slot_policy< Key >
struct	phmap::priv::set_params< Key, Compare, Alloc, TargetNodeSize, Multi >
struct	phmap::priv::upper_bound_adapter< Compare >
struct	phmap::priv::SearchResult< V, IsCompareTo >
struct	phmap::priv::SearchResult< V, false >
class	phmap::priv::btree_node< Params >
struct	phmap::priv::btree_iterator< Node, Reference, Pointer >
class	phmap::priv::btree< Params >
struct	phmap::priv::btree< Params >::EmptyNodeType
struct	phmap::priv::btree< Params >::node_stats
class	phmap::priv::btree_container< Tree >
class	phmap::priv::btree_set_container< Tree >
class	phmap::priv::btree_map_container< Tree >
class	phmap::priv::btree_multiset_container< Tree >
class	phmap::priv::btree_multimap_container< Tree >
class	phmap::btree_set< Key, Compare, Alloc >
class	phmap::btree_multiset< Key, Compare, Alloc >
class	phmap::btree_map< Key, Value, Compare, Alloc >
class	phmap::btree_multimap< Key, Value, Compare, Alloc >

命名空间
namespace	phmap
namespace	phmap::type_traits_internal
namespace	phmap::swap_internal
namespace	phmap::compare_internal
namespace	phmap::priv

宏定义
#define	PHMAP_COMPARE_INLINE_BASECLASS_DECL(name)    static const T name;
#define	PHMAP_COMPARE_INLINE_SUBCLASS_DECL(type, name)
#define	PHMAP_COMPARE_INLINE_INIT(type, name, init)

类型定义
template<typename... Ts>
using	phmap::void_t = typename type_traits_internal::VoidTImpl<Ts...>::type
template<class T >
using	phmap::swap_internal::IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>()))
template<class T , class IsNoexcept = std::integral_constant< bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
using	phmap::swap_internal::IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type
using	phmap::swap_internal::StdSwapIsUnconstrained = IsSwappable<void()>
using	phmap::compare_internal::value_type = int8_t
template<typename Compare , typename T >
using	phmap::priv::btree_is_key_compare_to

枚举
enum class	phmap::compare_internal::eq : value_type { phmap::compare_internal::equal = 0 , phmap::compare_internal::equivalent = equal , phmap::compare_internal::nonequal = 1 , phmap::compare_internal::nonequivalent = nonequal }
enum class	phmap::compare_internal::ord : value_type { phmap::compare_internal::less = -1 , phmap::compare_internal::greater = 1 }
enum class	phmap::compare_internal::ncmp : value_type { phmap::compare_internal::unordered = -127 }
enum class	phmap::priv::MatchKind : uint8_t { phmap::priv::kEq , phmap::priv::kNe }

函数
void	phmap::swap_internal::swap ()
template<class T , phmap::enable_if_t< IsSwappable< T >::value, int > = 0>
void	phmap::swap_internal::Swap (T &lhs, T &rhs) noexcept(IsNothrowSwappable< T >::value)
	phmap::PHMAP_COMPARE_INLINE_INIT (weak_equality, equivalent, compare_internal::eq::equivalent)
	phmap::PHMAP_COMPARE_INLINE_INIT (weak_equality, nonequivalent, compare_internal::eq::nonequivalent)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_equality, equal, compare_internal::eq::equal)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_equality, nonequal, compare_internal::eq::nonequal)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_equality, equivalent, compare_internal::eq::equivalent)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_equality, nonequivalent, compare_internal::eq::nonequivalent)
	phmap::PHMAP_COMPARE_INLINE_INIT (partial_ordering, less, compare_internal::ord::less)
	phmap::PHMAP_COMPARE_INLINE_INIT (partial_ordering, equivalent, compare_internal::eq::equivalent)
	phmap::PHMAP_COMPARE_INLINE_INIT (partial_ordering, greater, compare_internal::ord::greater)
	phmap::PHMAP_COMPARE_INLINE_INIT (partial_ordering, unordered, compare_internal::ncmp::unordered)
	phmap::PHMAP_COMPARE_INLINE_INIT (weak_ordering, less, compare_internal::ord::less)
	phmap::PHMAP_COMPARE_INLINE_INIT (weak_ordering, equivalent, compare_internal::eq::equivalent)
	phmap::PHMAP_COMPARE_INLINE_INIT (weak_ordering, greater, compare_internal::ord::greater)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_ordering, less, compare_internal::ord::less)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_ordering, equal, compare_internal::eq::equal)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_ordering, equivalent, compare_internal::eq::equivalent)
	phmap::PHMAP_COMPARE_INLINE_INIT (strong_ordering, greater, compare_internal::ord::greater)
template<typename BoolType , phmap::enable_if_t< std::is_same< bool, BoolType >::value, int > = 0>
constexpr bool	phmap::compare_internal::compare_result_as_less_than (const BoolType r)
constexpr bool	phmap::compare_internal::compare_result_as_less_than (const phmap::weak_ordering r)
template<typename Compare , typename K , typename LK >
constexpr bool	phmap::compare_internal::do_less_than_comparison (const Compare &compare, const K &x, const LK &y)
template<typename Int , phmap::enable_if_t< std::is_same< int, Int >::value, int > = 0>
constexpr phmap::weak_ordering	phmap::compare_internal::compare_result_as_ordering (const Int c)
constexpr phmap::weak_ordering	phmap::compare_internal::compare_result_as_ordering (const phmap::weak_ordering c)
template<typename Compare , typename K , typename LK , phmap::enable_if_t<!std::is_same< bool, phmap::invoke_result_t< Compare, const K &, const LK & > >::value, int > = 0>
constexpr phmap::weak_ordering	phmap::compare_internal::do_three_way_comparison (const Compare &compare, const K &x, const LK &y)
template<typename K , typename C , typename A >
void	phmap::swap (btree_set< K, C, A > &x, btree_set< K, C, A > &y)
template<typename K , typename C , typename A , typename Pred >
void	phmap::erase_if (btree_set< K, C, A > &set, Pred pred)
template<typename K , typename C , typename A >
void	phmap::swap (btree_multiset< K, C, A > &x, btree_multiset< K, C, A > &y)
template<typename K , typename C , typename A , typename Pred >
void	phmap::erase_if (btree_multiset< K, C, A > &set, Pred pred)
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)
template<typename K , typename V , typename C , typename A , typename Pred >
void	phmap::erase_if (btree_map< K, V, C, A > &map, Pred pred)
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)
template<typename K , typename V , typename C , typename A , typename Pred >
void	phmap::erase_if (btree_multimap< K, V, C, A > &map, Pred pred)

宏定义说明

PHMAP_COMPARE_INLINE_BASECLASS_DECL

#define PHMAP_COMPARE_INLINE_BASECLASS_DECL

(

name

)

static const T name;

PHMAP_COMPARE_INLINE_INIT

#define PHMAP_COMPARE_INLINE_INIT	(		type,
			name,
			init )

值:

        template <typename T>                                   \
        const T compare_internal::type##_base<T>::name(init)

PHMAP_COMPARE_INLINE_SUBCLASS_DECL

#define PHMAP_COMPARE_INLINE_SUBCLASS_DECL	(		type,
			name )