#include <btree.h>

类
struct	EmptyNodeType

struct	node_stats

Public 类型
using	key_type = typename Params::key_type

using	value_type = typename Params::value_type

using	size_type = typename Params::size_type

using	difference_type = typename Params::difference_type

using	key_compare = typename Params::key_compare

using	value_compare = typename Params::value_compare

using	allocator_type = typename Params::allocator_type

using	reference = typename Params::reference

using	const_reference = typename Params::const_reference

using	pointer = typename Params::pointer

using	const_pointer = typename Params::const_pointer

using	iterator = btree_iterator<node_type, reference, pointer>

using	const_iterator = typename iterator::const_iterator

using	reverse_iterator = std::reverse_iterator<iterator>

using	const_reverse_iterator = std::reverse_iterator<const_iterator>

using	node_handle_type = node_handle<Params, Params, allocator_type>

using	params_type = Params

using	slot_type = typename Params::slot_type

Public 成员函数
	btree (const key_compare &comp, const allocator_type &alloc)

	btree (const btree &x)

	btree (btree &&x) noexcept

	~btree ()

btree &	operator= (const btree &x)

btree &	operator= (btree &&x) noexcept

iterator	begin ()

const_iterator	begin () const

iterator	end ()

const_iterator	end () const

reverse_iterator	rbegin ()

const_reverse_iterator	rbegin () const

reverse_iterator	rend ()

const_reverse_iterator	rend () const

template<typename K >
iterator	lower_bound (const K &key)

template<typename K >
const_iterator	lower_bound (const K &key) const

template<typename K >
iterator	upper_bound (const K &key)

template<typename K >
const_iterator	upper_bound (const K &key) const

template<typename K >
std::pair< iterator, iterator >	equal_range (const K &key)

template<typename K >
std::pair< const_iterator, const_iterator >	equal_range (const K &key) const

template<typename... Args>
std::pair< iterator, bool >	insert_unique (const key_type &key, Args &&... args)

template<typename... Args>
std::pair< iterator, bool >	insert_hint_unique (iterator position, const key_type &key, Args &&... args)

template<typename InputIterator >
void	insert_iterator_unique (InputIterator b, InputIterator e)

template<typename ValueType >
iterator	insert_multi (const key_type &key, ValueType &&v)

template<typename ValueType >
iterator	insert_multi (ValueType &&v)

template<typename ValueType >
iterator	insert_hint_multi (iterator position, ValueType &&v)

template<typename InputIterator >
void	insert_iterator_multi (InputIterator b, InputIterator e)

iterator	erase (iterator iter)

std::pair< size_type, iterator >	erase (iterator begin, iterator end)

template<typename K >
size_type	erase_unique (const K &key)

template<typename K >
size_type	erase_multi (const K &key)

template<typename K >
iterator	find (const K &key)

template<typename K >
const_iterator	find (const K &key) const

template<typename K >
size_type	count_unique (const K &key) const

template<typename K >
size_type	count_multi (const K &key) const

void	clear ()

void	swap (btree &x)

const key_compare &	key_comp () const noexcept

template<typename K , typename LK >
bool	compare_keys (const K &x, const LK &y) const

value_compare	value_comp () const

void	verify () const

size_type	size () const

size_type	max_size () const

bool	empty () const

size_type	height () const

size_type	leaf_nodes () const

size_type	internal_nodes () const

size_type	nodes () const

size_type	bytes_used () const

double	fullness () const

double	overhead () const

allocator_type	get_allocator () const

template<typename... Args>
auto	insert_unique (const key_type &key, Args &&... args) -> std::pair< iterator, bool >

template<typename... Args>
auto	insert_hint_unique (iterator position, const key_type &key, Args &&... args) -> std::pair< iterator, bool >

template<typename ValueType >
auto	insert_multi (const key_type &key, ValueType &&v) -> iterator

template<typename ValueType >
auto	insert_hint_multi (iterator position, ValueType &&v) -> iterator

template<typename K >
auto	erase_unique (const K &key) -> size_type

template<typename K >
auto	erase_multi (const K &key) -> size_type

template<typename... Args>
auto	internal_emplace (iterator iter, Args &&... args) -> iterator

template<typename K >
auto	internal_locate (const K &key) const -> SearchResult< iterator, is_key_compare_to::value >

template<typename K >
auto	internal_locate_impl (const K &key, std::false_type) const -> SearchResult< iterator, false >

template<typename K >
auto	internal_locate_impl (const K &key, std::true_type) const -> SearchResult< iterator, true >

template<typename K >
auto	internal_lower_bound (const K &key) const -> iterator

template<typename K >
auto	internal_upper_bound (const K &key) const -> iterator

template<typename K >
auto	internal_find (const K &key) const -> iterator

静态 Public 成员函数
static double	average_bytes_per_value ()

static bool	testonly_uses_linear_node_search ()

Private 类型
enum	{ kNodeValues = node_type::kNodeValues , kMinNodeValues = kNodeValues / 2 }

using	node_type = btree_node<Params>

using	is_key_compare_to = typename Params::is_key_compare_to

Private 成员函数
const value_type &	maybe_move_from_iterator (const_iterator x)

value_type &&	maybe_move_from_iterator (iterator x)

template<typename Btree >
void	copy_or_move_values_in_order (Btree *x)

node_type *	root ()

const node_type *	root () const

node_type *&	mutable_root () noexcept

key_compare *	mutable_key_comp () noexcept

node_type *	leftmost ()

const node_type *	leftmost () const

allocator_type *	mutable_allocator () noexcept

const allocator_type &	allocator () const noexcept

node_type *	allocate (const size_type sz)

node_type *	new_internal_node (node_type *parent)

node_type *	new_leaf_node (node_type *parent)

node_type *	new_leaf_root_node (const int max_count)

void	erase_same_node (iterator begin, iterator end)

iterator	erase_from_leaf_node (iterator begin, size_type to_erase)

iterator	rebalance_after_delete (iterator iter)

void	deallocate (const size_type sz, node_type *node)

void	delete_internal_node (node_type *node)

void	delete_leaf_node (node_type *node)

void	rebalance_or_split (iterator *iter)

void	merge_nodes (node_type left, node_type right)

bool	try_merge_or_rebalance (iterator *iter)

void	try_shrink ()

iterator	internal_end (iterator iter)

const_iterator	internal_end (const_iterator iter) const

template<typename... Args>
iterator	internal_emplace (iterator iter, Args &&... args)

template<typename K >
SearchResult< iterator, is_key_compare_to::value >	internal_locate (const K &key) const

template<typename K >
SearchResult< iterator, false >	internal_locate_impl (const K &key, std::false_type) const

template<typename K >
SearchResult< iterator, true >	internal_locate_impl (const K &key, std::true_type) const

template<typename K >
iterator	internal_lower_bound (const K &key) const

template<typename K >
iterator	internal_upper_bound (const K &key) const

template<typename K >
iterator	internal_find (const K &key) const

void	internal_clear (node_type *node)

size_type	internal_verify (const node_type node, const key_type lo, const key_type *hi) const

node_stats	internal_stats (const node_type *node) const

静态 Private 成员函数
static node_type *	EmptyNode ()

static constexpr bool	static_assert_validation ()

template<typename IterType >
static IterType	internal_last (IterType iter)

Private 属性
phmap::priv::CompressedTuple< key_compare, allocator_type, node_type * >	root_

node_type *	rightmost_

size_type	size_

成员类型定义说明

◆ allocator_type

template<typename Params >

using phmap::priv::btree< Params >::allocator_type = typename Params::allocator_type

◆ const_iterator

template<typename Params >

using phmap::priv::btree< Params >::const_iterator = typename iterator::const_iterator

◆ const_pointer

template<typename Params >

using phmap::priv::btree< Params >::const_pointer = typename Params::const_pointer

◆ const_reference

template<typename Params >

using phmap::priv::btree< Params >::const_reference = typename Params::const_reference

◆ const_reverse_iterator

template<typename Params >

using phmap::priv::btree< Params >::const_reverse_iterator = std::reverse_iterator<const_iterator>

◆ difference_type

template<typename Params >

using phmap::priv::btree< Params >::difference_type = typename Params::difference_type

◆ is_key_compare_to

template<typename Params >

using phmap::priv::btree< Params >::is_key_compare_to = typename Params::is_key_compare_to

private

◆ iterator

template<typename Params >

using phmap::priv::btree< Params >::iterator = btree_iterator<node_type, reference, pointer>

◆ key_compare

template<typename Params >

using phmap::priv::btree< Params >::key_compare = typename Params::key_compare

◆ key_type

template<typename Params >

using phmap::priv::btree< Params >::key_type = typename Params::key_type

◆ node_handle_type

template<typename Params >

using phmap::priv::btree< Params >::node_handle_type = node_handle<Params, Params, allocator_type>

◆ node_type

template<typename Params >

using phmap::priv::btree< Params >::node_type = btree_node<Params>

private

◆ params_type

template<typename Params >

using phmap::priv::btree< Params >::params_type = Params

◆ pointer

template<typename Params >

using phmap::priv::btree< Params >::pointer = typename Params::pointer

◆ reference

template<typename Params >

using phmap::priv::btree< Params >::reference = typename Params::reference

◆ reverse_iterator

template<typename Params >

using phmap::priv::btree< Params >::reverse_iterator = std::reverse_iterator<iterator>

◆ size_type

template<typename Params >

using phmap::priv::btree< Params >::size_type = typename Params::size_type

◆ slot_type

template<typename Params >

using phmap::priv::btree< Params >::slot_type = typename Params::slot_type

◆ value_compare

template<typename Params >

using phmap::priv::btree< Params >::value_compare = typename Params::value_compare

◆ value_type

template<typename Params >

using phmap::priv::btree< Params >::value_type = typename Params::value_type

成员枚举类型说明

◆ anonymous enum

template<typename Params >

anonymous enum

private

枚举值
kNodeValues
kMinNodeValues

构造及析构函数说明

◆ btree() [1/3]

template<typename P >

phmap::priv::btree< P >::btree	(	const key_compare &	comp,
		const allocator_type &	alloc )

◆ btree() [2/3]

template<typename P >

phmap::priv::btree::btree ( const btree< Params > & x )

◆ btree() [3/3]

template<typename Params >

phmap::priv::btree< Params >::btree ( btree< Params > && x )

inlinenoexcept

◆ ~btree()

template<typename Params >

phmap::priv::btree< Params >::~btree ( )

inline

成员函数说明

◆ allocate()

template<typename Params >

node_type * phmap::priv::btree< Params >::allocate ( const size_type sz )

inlineprivate

◆ allocator()

template<typename Params >

const allocator_type & phmap::priv::btree< Params >::allocator ( ) const

inlineprivatenoexcept

◆ average_bytes_per_value()

template<typename Params >

static double phmap::priv::btree< Params >::average_bytes_per_value ( )

inlinestatic

◆ begin() [1/2]

template<typename Params >

iterator phmap::priv::btree< Params >::begin ( )

inline

◆ begin() [2/2]

template<typename Params >

const_iterator phmap::priv::btree< Params >::begin ( ) const

inline

◆ bytes_used()

template<typename Params >

size_type phmap::priv::btree< Params >::bytes_used ( ) const

inline

◆ clear()

template<typename P >

void phmap::priv::btree::clear ( )

◆ compare_keys()

template<typename Params >

template<typename K , typename LK >

bool phmap::priv::btree< Params >::compare_keys	(	const K &	x,
		const LK &	y ) const

inline

◆ copy_or_move_values_in_order()

template<typename P >

template<typename Btree >

void phmap::priv::btree::copy_or_move_values_in_order ( Btree * x )

private

◆ count_multi()

template<typename Params >

template<typename K >

size_type phmap::priv::btree< Params >::count_multi ( const K & key ) const

inline

◆ count_unique()

template<typename Params >

template<typename K >

size_type phmap::priv::btree< Params >::count_unique ( const K & key ) const

inline

◆ deallocate()

template<typename Params >

void phmap::priv::btree< Params >::deallocate	(	const size_type	sz,
		node_type *	node )

inlineprivate

◆ delete_internal_node()

template<typename Params >

void phmap::priv::btree< Params >::delete_internal_node ( node_type * node )

inlineprivate

◆ delete_leaf_node()

template<typename Params >

void phmap::priv::btree< Params >::delete_leaf_node ( node_type * node )

inlineprivate

◆ empty()

template<typename Params >

bool phmap::priv::btree< Params >::empty ( ) const

inline

◆ EmptyNode()

template<typename Params >

static node_type * phmap::priv::btree< Params >::EmptyNode ( )

inlinestaticprivate

◆ end() [1/2]

template<typename Params >

iterator phmap::priv::btree< Params >::end ( )

inline

◆ end() [2/2]

template<typename Params >

const_iterator phmap::priv::btree< Params >::end ( ) const

inline

◆ equal_range() [1/2]

template<typename Params >

template<typename K >

std::pair< iterator, iterator > phmap::priv::btree< Params >::equal_range ( const K & key )

inline

◆ equal_range() [2/2]

template<typename Params >

template<typename K >

std::pair< const_iterator, const_iterator > phmap::priv::btree< Params >::equal_range ( const K & key ) const

inline

◆ erase() [1/2]

template<typename P >

auto phmap::priv::btree< P >::erase	(	iterator	begin,
		iterator	end )

◆ erase() [2/2]

template<typename P >

auto phmap::priv::btree::erase ( iterator iter )

◆ erase_from_leaf_node()

template<typename P >

auto phmap::priv::btree< P >::erase_from_leaf_node	(	iterator	begin,
		size_type	to_erase )

private

◆ erase_multi() [1/2]

template<typename Params >

template<typename K >

size_type phmap::priv::btree< Params >::erase_multi ( const K & key )

◆ erase_multi() [2/2]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::erase_multi ( const K & key ) -> size_type

◆ erase_same_node()

template<typename P >

void phmap::priv::btree< P >::erase_same_node	(	iterator	begin,
		iterator	end )

private

◆ erase_unique() [1/2]

template<typename Params >

template<typename K >

size_type phmap::priv::btree< Params >::erase_unique ( const K & key )

◆ erase_unique() [2/2]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::erase_unique ( const K & key ) -> size_type

◆ find() [1/2]

template<typename Params >

template<typename K >

iterator phmap::priv::btree< Params >::find ( const K & key )

inline

◆ find() [2/2]

template<typename Params >

template<typename K >

const_iterator phmap::priv::btree< Params >::find ( const K & key ) const

inline

◆ fullness()

template<typename Params >

double phmap::priv::btree< Params >::fullness ( ) const

inline

◆ get_allocator()

template<typename Params >

allocator_type phmap::priv::btree< Params >::get_allocator ( ) const

inline

◆ height()

template<typename Params >

size_type phmap::priv::btree< Params >::height ( ) const

inline

◆ insert_hint_multi() [1/2]

template<typename Params >

template<typename ValueType >

iterator phmap::priv::btree< Params >::insert_hint_multi	(	iterator	position,
		ValueType &&	v )

◆ insert_hint_multi() [2/2]

template<typename Params >

template<typename ValueType >

auto phmap::priv::btree< Params >::insert_hint_multi	(	iterator	position,
		ValueType &&	v ) -> iterator

◆ insert_hint_unique() [1/2]

template<typename Params >

template<typename... Args>

std::pair< iterator, bool > phmap::priv::btree< Params >::insert_hint_unique	(	iterator	position,
		const key_type &	key,
		Args &&...	args )

◆ insert_hint_unique() [2/2]

template<typename Params >

template<typename... Args>

auto phmap::priv::btree< Params >::insert_hint_unique	(	iterator	position,
		const key_type &	key,
		Args &&...	args ) -> std::pair<iterator, bool>

inline

◆ insert_iterator_multi()

template<typename P >

template<typename InputIterator >

void phmap::priv::btree< P >::insert_iterator_multi	(	InputIterator	b,
		InputIterator	e )

◆ insert_iterator_unique()

template<typename P >

template<typename InputIterator >

void phmap::priv::btree< P >::insert_iterator_unique	(	InputIterator	b,
		InputIterator	e )

◆ insert_multi() [1/3]

template<typename Params >

template<typename ValueType >

iterator phmap::priv::btree< Params >::insert_multi	(	const key_type &	key,
		ValueType &&	v )

◆ insert_multi() [2/3]

template<typename Params >

template<typename ValueType >

auto phmap::priv::btree< Params >::insert_multi	(	const key_type &	key,
		ValueType &&	v ) -> iterator

◆ insert_multi() [3/3]

template<typename Params >

template<typename ValueType >

iterator phmap::priv::btree< Params >::insert_multi ( ValueType && v )

inline

◆ insert_unique() [1/2]

template<typename Params >

template<typename... Args>

std::pair< iterator, bool > phmap::priv::btree< Params >::insert_unique	(	const key_type &	key,
		Args &&...	args )

◆ insert_unique() [2/2]

template<typename Params >

template<typename... Args>

auto phmap::priv::btree< Params >::insert_unique	(	const key_type &	key,
		Args &&...	args ) -> std::pair<iterator, bool>

◆ internal_clear()

template<typename P >

void phmap::priv::btree::internal_clear ( node_type * node )

private

◆ internal_emplace() [1/2]

template<typename Params >

template<typename... Args>

iterator phmap::priv::btree< Params >::internal_emplace	(	iterator	iter,
		Args &&...	args )

private

◆ internal_emplace() [2/2]

template<typename Params >

template<typename... Args>

auto phmap::priv::btree< Params >::internal_emplace	(	iterator	iter,
		Args &&...	args ) -> iterator

inline

◆ internal_end() [1/2]

template<typename Params >

const_iterator phmap::priv::btree< Params >::internal_end ( const_iterator iter ) const

inlineprivate

◆ internal_end() [2/2]

template<typename Params >

iterator phmap::priv::btree< Params >::internal_end ( iterator iter )

inlineprivate

◆ internal_find() [1/2]

template<typename Params >

template<typename K >

iterator phmap::priv::btree< Params >::internal_find ( const K & key ) const

private

◆ internal_find() [2/2]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::internal_find ( const K & key ) const -> iterator

◆ internal_last()

template<typename P >

template<typename IterType >

IterType phmap::priv::btree::internal_last ( IterType iter )

inlinestaticprivate

◆ internal_locate() [1/2]

template<typename Params >

template<typename K >

SearchResult< iterator, is_key_compare_to::value > phmap::priv::btree< Params >::internal_locate ( const K & key ) const

private

◆ internal_locate() [2/2]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::internal_locate ( const K & key ) const -> SearchResult<iterator, is_key_compare_to::value>

inline

◆ internal_locate_impl() [1/4]

template<typename Params >

template<typename K >

SearchResult< iterator, false > phmap::priv::btree< Params >::internal_locate_impl	(	const K &	key,
		std::false_type	) const

private

◆ internal_locate_impl() [2/4]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::internal_locate_impl	(	const K &	key,
		std::false_type	) const -> SearchResult<iterator, false>

inline

◆ internal_locate_impl() [3/4]

template<typename Params >

template<typename K >

SearchResult< iterator, true > phmap::priv::btree< Params >::internal_locate_impl	(	const K &	key,
		std::true_type	) const

private

◆ internal_locate_impl() [4/4]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::internal_locate_impl	(	const K &	key,
		std::true_type	) const -> SearchResult<iterator, true>

inline

◆ internal_lower_bound() [1/2]

template<typename Params >

template<typename K >

iterator phmap::priv::btree< Params >::internal_lower_bound ( const K & key ) const

private

◆ internal_lower_bound() [2/2]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::internal_lower_bound ( const K & key ) const -> iterator

◆ internal_nodes()

template<typename Params >

size_type phmap::priv::btree< Params >::internal_nodes ( ) const

inline

◆ internal_stats()

template<typename Params >

node_stats phmap::priv::btree< Params >::internal_stats ( const node_type * node ) const

inlineprivate

◆ internal_upper_bound() [1/2]

template<typename Params >

template<typename K >

iterator phmap::priv::btree< Params >::internal_upper_bound ( const K & key ) const

private

◆ internal_upper_bound() [2/2]

template<typename Params >

template<typename K >

auto phmap::priv::btree< Params >::internal_upper_bound ( const K & key ) const -> iterator

◆ internal_verify()

template<typename P >

btree< P >::size_type phmap::priv::btree< P >::internal_verify	(	const node_type *	node,
		const key_type *	lo,
		const key_type *	hi ) const

private

◆ key_comp()

template<typename Params >

const key_compare & phmap::priv::btree< Params >::key_comp ( ) const

inlinenoexcept

◆ leaf_nodes()

template<typename Params >

size_type phmap::priv::btree< Params >::leaf_nodes ( ) const

inline

◆ leftmost() [1/2]

template<typename Params >

node_type * phmap::priv::btree< Params >::leftmost ( )

inlineprivate

◆ leftmost() [2/2]

template<typename Params >

const node_type * phmap::priv::btree< Params >::leftmost ( ) const

inlineprivate

◆ lower_bound() [1/2]

template<typename Params >

template<typename K >

iterator phmap::priv::btree< Params >::lower_bound ( const K & key )

inline

◆ lower_bound() [2/2]

template<typename Params >

template<typename K >

const_iterator phmap::priv::btree< Params >::lower_bound ( const K & key ) const

inline

◆ max_size()

template<typename Params >

size_type phmap::priv::btree< Params >::max_size ( ) const

inline

◆ maybe_move_from_iterator() [1/2]

template<typename Params >

const value_type & phmap::priv::btree< Params >::maybe_move_from_iterator ( const_iterator x )

inlineprivate

◆ maybe_move_from_iterator() [2/2]

template<typename Params >

value_type && phmap::priv::btree< Params >::maybe_move_from_iterator ( iterator x )

inlineprivate

◆ merge_nodes()

template<typename P >

void phmap::priv::btree< P >::merge_nodes	(	node_type *	left,
		node_type *	right )

private

◆ mutable_allocator()

template<typename Params >

allocator_type * phmap::priv::btree< Params >::mutable_allocator ( )

inlineprivatenoexcept

◆ mutable_key_comp()

template<typename Params >

key_compare * phmap::priv::btree< Params >::mutable_key_comp ( )

inlineprivatenoexcept

◆ mutable_root()

template<typename Params >

node_type *& phmap::priv::btree< Params >::mutable_root ( )

inlineprivatenoexcept

◆ new_internal_node()

template<typename Params >

node_type * phmap::priv::btree< Params >::new_internal_node ( node_type * parent )

inlineprivate

◆ new_leaf_node()

template<typename Params >

node_type * phmap::priv::btree< Params >::new_leaf_node ( node_type * parent )

inlineprivate

◆ new_leaf_root_node()

template<typename Params >

node_type * phmap::priv::btree< Params >::new_leaf_root_node ( const int max_count )

inlineprivate

◆ nodes()

template<typename Params >

size_type phmap::priv::btree< Params >::nodes ( ) const

inline

◆ operator=() [1/2]

template<typename P >

auto phmap::priv::btree::operator= ( btree< Params > && x )

noexcept

◆ operator=() [2/2]

template<typename P >

auto phmap::priv::btree::operator= ( const btree< Params > & x )

◆ overhead()

template<typename Params >

double phmap::priv::btree< Params >::overhead ( ) const

inline

◆ rbegin() [1/2]

template<typename Params >

reverse_iterator phmap::priv::btree< Params >::rbegin ( )

inline

◆ rbegin() [2/2]

template<typename Params >

const_reverse_iterator phmap::priv::btree< Params >::rbegin ( ) const

inline

◆ rebalance_after_delete()

template<typename P >

auto phmap::priv::btree::rebalance_after_delete ( iterator iter )

private

◆ rebalance_or_split()

template<typename P >

void phmap::priv::btree::rebalance_or_split ( iterator * iter )

private

◆ rend() [1/2]

template<typename Params >

reverse_iterator phmap::priv::btree< Params >::rend ( )

inline

◆ rend() [2/2]

template<typename Params >

const_reverse_iterator phmap::priv::btree< Params >::rend ( ) const

inline

◆ root() [1/2]

template<typename Params >

node_type * phmap::priv::btree< Params >::root ( )

inlineprivate

◆ root() [2/2]

template<typename Params >

const node_type * phmap::priv::btree< Params >::root ( ) const

inlineprivate

◆ size()

template<typename Params >

size_type phmap::priv::btree< Params >::size ( ) const

inline

◆ static_assert_validation()

template<typename P >

constexpr bool phmap::priv::btree::static_assert_validation ( )

staticconstexprprivate

◆ swap()

template<typename P >

void phmap::priv::btree::swap ( btree< Params > & x )

◆ testonly_uses_linear_node_search()

template<typename Params >

static bool phmap::priv::btree< Params >::testonly_uses_linear_node_search ( )

inlinestatic

◆ try_merge_or_rebalance()

template<typename P >

bool phmap::priv::btree::try_merge_or_rebalance ( iterator * iter )

private

◆ try_shrink()

template<typename P >

void phmap::priv::btree::try_shrink ( )

private

◆ upper_bound() [1/2]

template<typename Params >

template<typename K >

iterator phmap::priv::btree< Params >::upper_bound ( const K & key )

inline

◆ upper_bound() [2/2]

template<typename Params >

template<typename K >

const_iterator phmap::priv::btree< Params >::upper_bound ( const K & key ) const

inline

◆ value_comp()

template<typename Params >

value_compare phmap::priv::btree< Params >::value_comp ( ) const

inline

◆ verify()

template<typename P >

void phmap::priv::btree::verify ( ) const

类成员变量说明

◆ rightmost_

template<typename Params >

node_type* phmap::priv::btree< Params >::rightmost_

private

◆ root_

template<typename Params >

phmap::priv::CompressedTuple<key_compare, allocator_type, node_type *> phmap::priv::btree< Params >::root_

private

◆ size_

template<typename Params >

size_type phmap::priv::btree< Params >::size_

private

该类的文档由以下文件生成:

D:/GitLab/builds/wydSYb3b/0/nim-pc/california/nim-cross-platform-sdk/exports/include/btree.h

类

Public 类型

Public 成员函数

静态 Public 成员函数

Private 类型

Private 成员函数

静态 Private 成员函数

Private 属性

成员类型定义说明

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ difference_type

◆ is_key_compare_to

◆ iterator

◆ key_compare

◆ key_type

◆ node_handle_type

◆ node_type

◆ params_type

◆ pointer

◆ reference

◆ reverse_iterator

◆ size_type

◆ slot_type

◆ value_compare

◆ value_type

成员枚举类型说明

◆ anonymous enum

构造及析构函数说明

◆ btree() [1/3]

◆ btree() [2/3]

◆ btree() [3/3]

◆ ~btree()

成员函数说明

◆ allocate()

◆ allocator()

◆ average_bytes_per_value()

◆ begin() [1/2]

◆ begin() [2/2]

◆ bytes_used()

◆ clear()

◆ compare_keys()

◆ copy_or_move_values_in_order()

◆ count_multi()

◆ count_unique()

◆ deallocate()

◆ delete_internal_node()

◆ delete_leaf_node()

◆ empty()

◆ EmptyNode()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range() [1/2]

◆ equal_range() [2/2]

◆ erase() [1/2]

◆ erase() [2/2]

◆ erase_from_leaf_node()

◆ erase_multi() [1/2]

◆ erase_multi() [2/2]

◆ erase_same_node()

◆ erase_unique() [1/2]

◆ erase_unique() [2/2]

◆ find() [1/2]

◆ find() [2/2]

◆ fullness()

◆ get_allocator()

◆ height()

◆ insert_hint_multi() [1/2]

◆ insert_hint_multi() [2/2]

◆ insert_hint_unique() [1/2]

◆ insert_hint_unique() [2/2]

◆ insert_iterator_multi()

◆ insert_iterator_unique()

◆ insert_multi() [1/3]

◆ insert_multi() [2/3]

◆ insert_multi() [3/3]

◆ insert_unique() [1/2]