qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > Class Template Reference

#include <qtree.hpp>

Classes
class	const_iterator
class	mutable_iterator

Public Types
using	value_type = Value
using	key_type = typename key_selector::key_type
using	key_compare = Compare
using	size_type = std::size_t
using	difference_type = ptrdiff_t
using	reference = value_type &
using	const_reference = value_type const &
using	pointer = value_type *
using	const_pointer = value_type const *
using	value_compare = qtree_detail::value_compare_impl<value_type, key_selector, key_compare>
using	allocator_type = qallocator<value_type, AllocPolicy>
using	iterator = typename std::conditional_t<std::is_same_v<KeySelector, qtree_detail::identity_key<Value>>,const_iterator,mutable_iterator>
using	reverse_iterator = qiterator_detail::qreverse_iterator<iterator>
using	const_reverse_iterator = qiterator_detail::qreverse_iterator<const_iterator>
template<class K>
using	enable_hetero_eq = std::enable_if_t<cmp_bidir_v<Compare, key_type, K>, int>
template<class K>
using	enable_hetero_lb = std::enable_if_t<cmp_key_to_k_v<Compare, key_type, K>, int>
template<class K>
using	enable_hetero_ub = std::enable_if_t<cmp_k_to_key_v<Compare, K, key_type>, int>
template<class K>
using	enable_hetero_eqrange = std::enable_if_t<cmp_key_to_k_v<Compare, key_type, K> && cmp_k_to_key_v<Compare, K, key_type>, int>

Public Member Functions
	CXX17_MEMORY_ALLOCATION_FUNCS_USING_POLICY (AllocPolicy) qtree() noexcept
	qtree (std::initializer_list< value_type > init)
	qtree (qtree const &other)
	qtree (qtree &&other) noexcept
	~qtree ()
qtree &	operator= (qtree const &other)
qtree &	operator= (qtree &&other) noexcept
void	swap (qtree &other) noexcept
iterator	begin () noexcept
const_iterator	begin () const noexcept
const_iterator	cbegin () const noexcept
iterator	end () noexcept
const_iterator	end () const noexcept
const_iterator	cend () const noexcept
reverse_iterator	rbegin () noexcept
const_reverse_iterator	rbegin () const noexcept
const_reverse_iterator	crbegin () const noexcept
reverse_iterator	rend () noexcept
const_reverse_iterator	rend () const noexcept
const_reverse_iterator	crend () const noexcept
bool	empty () const noexcept
size_type	size () const noexcept
iterator	find (key_type const &key)
const_iterator	find (key_type const &key) const
template<class K, class = enable_hetero_eq<K>>
iterator	find (K const &key)
template<class K, class = enable_hetero_eq<K>>
const_iterator	find (K const &key) const
bool	contains (key_type const &key) const
template<class K, class = enable_hetero_eq<K>>
bool	contains (K const &key) const
size_type	count (key_type const &key) const
template<class K, class = enable_hetero_eq<K>>
size_type	count (K const &key) const
iterator	lower_bound (key_type const &key)
const_iterator	lower_bound (key_type const &key) const
template<class K, class = enable_hetero_lb<K>>
iterator	lower_bound (K const &key)
template<class K, class = enable_hetero_lb<K>>
const_iterator	lower_bound (K const &key) const
iterator	upper_bound (key_type const &key)
const_iterator	upper_bound (key_type const &key) const
template<class K, class = enable_hetero_ub<K>>
iterator	upper_bound (K const &key)
template<class K, class = enable_hetero_ub<K>>
const_iterator	upper_bound (K const &key) const
qpair< iterator, iterator >	equal_range (key_type const &key)
qpair< const_iterator, const_iterator >	equal_range (key_type const &key) const
template<class K, class = enable_hetero_eqrange<K>>
qpair< iterator, iterator >	equal_range (K const &key)
template<class K, class = enable_hetero_eqrange<K>>
qpair< const_iterator, const_iterator >	equal_range (K const &key) const
template<class InputIt>
void	insert (InputIt first, InputIt last)
void	insert (std::initializer_list< value_type > init)
qpair< iterator, bool >	insert (value_type const &value)
qpair< iterator, bool >	insert (value_type &&value)
iterator	insert (const_iterator hint, value_type const &value)
iterator	insert (const_iterator hint, value_type &&value)
template<class... Args>
qpair< iterator, bool >	emplace (Args &&...args)
template<class... Args>
iterator	emplace_hint (const_iterator hint, Args &&...args)
iterator	erase (const_iterator pos)
iterator	erase (const_iterator first, const_iterator last)
size_type	erase (key_type const &key)
template<class K, class = enable_hetero_eq<K>>
size_type	erase (K const &key)
template<class Pred>
size_type	erase_if (Pred pred)
void	clear () noexcept
key_compare	key_comp () const noexcept
value_compare	value_comp () const noexcept
allocator_type	get_allocator () const noexcept
size_type	max_size () const noexcept

Static Public Attributes
template<class K>
static constexpr bool	supports_heterogeneous_key_v = cmp_bidir_v<Compare, key_type, K>

Friends
class	qtree_detail::qtree_tester
template<class, class, class, class, bool>
class	qmap
void	swap (qtree &a, qtree &b) noexcept(noexcept(a.swap(b)))
bool	operator== (mutable_iterator l, const_iterator r) noexcept
bool	operator== (const_iterator l, mutable_iterator r) noexcept
bool	operator!= (mutable_iterator l, const_iterator r) noexcept
bool	operator!= (const_iterator l, mutable_iterator r) noexcept
bool	operator== (qtree const &a, qtree const &b)
bool	operator!= (qtree const &a, qtree const &b)
bool	operator< (qtree const &a, qtree const &b)
bool	operator> (qtree const &a, qtree const &b)
bool	operator<= (qtree const &a, qtree const &b)
bool	operator>= (qtree const &a, qtree const &b)

Member Typedef Documentation

value_type

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::value_type = Value

key_type

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::key_type = typename key_selector::key_type

key_compare

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::key_compare = Compare

size_type

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::size_type = std::size_t

difference_type

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::difference_type = ptrdiff_t

reference

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::reference = value_type &

const_reference

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::const_reference = value_type const &

pointer

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::pointer = value_type *

const_pointer

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::const_pointer = value_type const *

value_compare

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::value_compare = qtree_detail::value_compare_impl<value_type, key_selector, key_compare>

allocator_type

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::allocator_type = qallocator<value_type, AllocPolicy>

iterator

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::iterator = typename std::conditional_t<std::is_same_v<KeySelector, qtree_detail::identity_key<Value>>,const_iterator,mutable_iterator>

reverse_iterator

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::reverse_iterator = qiterator_detail::qreverse_iterator<iterator>

const_reverse_iterator

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::const_reverse_iterator = qiterator_detail::qreverse_iterator<const_iterator>

enable_hetero_eq

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::enable_hetero_eq = std::enable_if_t<cmp_bidir_v<Compare, key_type, K>, int>

enable_hetero_lb

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::enable_hetero_lb = std::enable_if_t<cmp_key_to_k_v<Compare, key_type, K>, int>

enable_hetero_ub

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::enable_hetero_ub = std::enable_if_t<cmp_k_to_key_v<Compare, K, key_type>, int>

enable_hetero_eqrange

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K>

using qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::enable_hetero_eqrange = std::enable_if_t<cmp_key_to_k_v<Compare, key_type, K> && cmp_k_to_key_v<Compare, K, key_type>, int>

Constructor & Destructor Documentation

qtree() [1/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::qtree ( std::initializer_list< value_type > init )

inline

qtree() [2/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::qtree ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & other )

inline

qtree() [3/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::qtree ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > && other )

inlinenoexcept

~qtree()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::~qtree ( )

inline

Member Function Documentation

CXX17_MEMORY_ALLOCATION_FUNCS_USING_POLICY()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::CXX17_MEMORY_ALLOCATION_FUNCS_USING_POLICY ( AllocPolicy )

inlinenoexcept

operator=() [1/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qtree & qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::operator= ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & other )

inline

operator=() [2/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qtree & qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::operator= ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > && other )

inlinenoexcept

swap()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

void qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::swap ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > & other )

inlinenoexcept

begin() [1/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::begin ( )

inlinenoexcept

begin() [2/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::begin ( ) const

inlinenoexcept

cbegin()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::cbegin ( ) const

inlinenoexcept

end() [1/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::end ( )

inlinenoexcept

end() [2/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::end ( ) const

inlinenoexcept

cend()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::cend ( ) const

inlinenoexcept

rbegin() [1/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

reverse_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::rbegin ( )

inlinenoexcept

rbegin() [2/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_reverse_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::rbegin ( ) const

inlinenoexcept

crbegin()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_reverse_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::crbegin ( ) const

inlinenoexcept

rend() [1/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

reverse_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::rend ( )

inlinenoexcept

rend() [2/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_reverse_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::rend ( ) const

inlinenoexcept

crend()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_reverse_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::crend ( ) const

inlinenoexcept

empty()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::empty ( ) const

inlinenoexcept

size()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

size_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::size ( ) const

inlinenoexcept

find() [1/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::find ( key_type const & key )

inlinenodiscard

find() [2/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::find ( key_type const & key ) const

inlinenodiscard

find() [3/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_eq<K>>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::find ( K const & key )

inlinenodiscard

find() [4/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_eq<K>>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::find ( K const & key ) const

inlinenodiscard

contains() [1/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::contains ( key_type const & key ) const

inlinenodiscard

contains() [2/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_eq<K>>

bool qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::contains ( K const & key ) const

inlinenodiscard

count() [1/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

size_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::count ( key_type const & key ) const

inlinenodiscard

count() [2/2]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_eq<K>>

size_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::count ( K const & key ) const

inlinenodiscard

lower_bound() [1/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::lower_bound ( key_type const & key )

inlinenodiscard

lower_bound() [2/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::lower_bound ( key_type const & key ) const

inlinenodiscard

lower_bound() [3/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_lb<K>>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::lower_bound ( K const & key )

inlinenodiscard

lower_bound() [4/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_lb<K>>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::lower_bound ( K const & key ) const

inlinenodiscard

upper_bound() [1/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::upper_bound ( key_type const & key )

inlinenodiscard

upper_bound() [2/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::upper_bound ( key_type const & key ) const

inlinenodiscard

upper_bound() [3/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_ub<K>>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::upper_bound ( K const & key )

inlinenodiscard

upper_bound() [4/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_ub<K>>

const_iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::upper_bound ( K const & key ) const

inlinenodiscard

equal_range() [1/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qpair< iterator, iterator > qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::equal_range ( key_type const & key )

inlinenodiscard

equal_range() [2/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qpair< const_iterator, const_iterator > qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::equal_range ( key_type const & key ) const

inlinenodiscard

equal_range() [3/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_eqrange<K>>

qpair< iterator, iterator > qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::equal_range ( K const & key )

inlinenodiscard

equal_range() [4/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_eqrange<K>>

qpair< const_iterator, const_iterator > qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::equal_range ( K const & key ) const

inlinenodiscard

insert() [1/6]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class InputIt>

void qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::insert ( InputIt first, InputIt last )

inline

insert() [2/6]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

void qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::insert ( std::initializer_list< value_type > init )

inline

insert() [3/6]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qpair< iterator, bool > qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::insert ( value_type const & value )

inline

insert() [4/6]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

qpair< iterator, bool > qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::insert ( value_type && value )

inline

insert() [5/6]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::insert ( const_iterator hint, value_type const & value )

inline

insert() [6/6]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::insert ( const_iterator hint, value_type && value )

inline

emplace()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class... Args>

qpair< iterator, bool > qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::emplace ( Args &&... args )

inline

emplace_hint()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class... Args>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::emplace_hint ( const_iterator hint, Args &&... args )

inline

erase() [1/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::erase ( const_iterator pos )

inline

erase() [2/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

iterator qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::erase ( const_iterator first, const_iterator last )

inline

erase() [3/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

size_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::erase ( key_type const & key )

inline

erase() [4/4]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K, class = enable_hetero_eq<K>>

size_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::erase ( K const & key )

inline

erase_if()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class Pred>

size_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::erase_if ( Pred pred )

inline

clear()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

void qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::clear ( )

inlinenoexcept

key_comp()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

key_compare qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::key_comp ( ) const

inlinenoexcept

value_comp()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

value_compare qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::value_comp ( ) const

inlinenoexcept

get_allocator()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

allocator_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::get_allocator ( ) const

inlinenoexcept

max_size()

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

size_type qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::max_size ( ) const

inlinenoexcept

Friends And Related Symbol Documentation

qtree_detail::qtree_tester

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

friend class qtree_detail::qtree_tester

friend

qmap

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class, class, class, class, bool>

friend class qmap

friend

swap

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

void swap ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > & a, qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > & b )

friend

operator== [1/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator== ( mutable_iterator l, const_iterator r )

friend

operator== [2/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator== ( const_iterator l, mutable_iterator r )

friend

operator!= [1/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator!= ( mutable_iterator l, const_iterator r )

friend

operator!= [2/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator!= ( const_iterator l, mutable_iterator r )

friend

operator== [3/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator== ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & a, qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & b )

friend

operator!= [3/3]

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator!= ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & a, qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & b )

friend

operator<

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator< ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & a, qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & b )

friend

operator>

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator> ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & a, qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & b )

friend

operator<=

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator<= ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & a, qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & b )

friend

operator>=

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

bool operator>= ( qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & a, qtree< Value, Compare, AllocPolicy, PackNode, KeySelector > const & b )

friend

Member Data Documentation

supports_heterogeneous_key_v

template<class Value, class Compare, class AllocPolicy, bool PackNode, class KeySelector>

template<class K>

bool qtree_detail::qtree< Value, Compare, AllocPolicy, PackNode, KeySelector >::supports_heterogeneous_key_v = cmp_bidir_v<Compare, key_type, K>

staticconstexpr

---

The documentation for this class was generated from the following file:

• /Users/geoffrey/ida-sdk/src/include/qtree.hpp