qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode > Class Template Reference

#include <qtree.hpp>

Public Types
using	key_type = Key
using	mapped_type = T
using	value_type = qpair<const Key, T>
using	size_type = typename Tree::size_type
using	difference_type = typename Tree::difference_type
using	key_compare = Compare
using	value_compare = typename Tree::value_compare
using	allocator_policy_type = AllocPolicy
using	reference = value_type &
using	const_reference = value_type const &
using	pointer = value_type *
using	const_pointer = value_type const *
using	iterator = typename Tree::iterator
using	const_iterator = typename Tree::const_iterator
using	reverse_iterator = qiterator_detail::qreverse_iterator<iterator>
using	const_reverse_iterator = qiterator_detail::qreverse_iterator<const_iterator>
using	allocator_type = typename Tree::allocator_type
template<class K>
using	enable_hetero_eq = typename Tree::template enable_hetero_eq<K>
template<class K>
using	enable_hetero_lb = typename Tree::template enable_hetero_lb<K>
template<class K>
using	enable_hetero_ub = typename Tree::template enable_hetero_ub<K>
template<class K>
using	enable_hetero_eqrange = typename Tree::template enable_hetero_eqrange<K>

Public Member Functions
	CXX17_MEMORY_ALLOCATION_FUNCS_USING_POLICY (AllocPolicy) qmap() noexcept
	qmap (std::initializer_list< value_type > init)
	qmap (qmap const &other)
	qmap (qmap &&other) noexcept
	~qmap ()=default
qmap &	operator= (qmap const &other)
qmap &	operator= (qmap &&other) noexcept
void	swap (qmap &other) noexcept(noexcept(tree_.swap(other.tree_)))
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 &k)
template<class K, class = enable_hetero_eq<K>>
const_iterator	find (K const &k) const
bool	contains (key_type const &key) const
template<class K, class = enable_hetero_eq<K>>
bool	contains (K const &k) const
size_type	count (key_type const &key) const
template<class K, class = enable_hetero_eq<K>>
size_type	count (K const &k) 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 &k)
template<class K, class = enable_hetero_lb<K>>
const_iterator	lower_bound (K const &k) 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 &k)
template<class K, class = enable_hetero_ub<K>>
const_iterator	upper_bound (K const &k) 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 &k)
template<class K, class = enable_hetero_eqrange<K>>
qpair< const_iterator, const_iterator >	equal_range (K const &k) const
void	clear () noexcept
template<class InputIt>
void	insert (InputIt first, InputIt last)
void	insert (std::initializer_list< value_type > init)
qpair< iterator, bool >	insert (value_type const &v)
qpair< iterator, bool >	insert (value_type &&v)
iterator	insert (const_iterator hint, value_type const &v)
iterator	insert (const_iterator hint, value_type &&v)
iterator	erase (const_iterator pos)
iterator	erase (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 &k)
template<class Pred>
size_type	erase_if (Pred pred)
key_compare	key_comp () const noexcept
value_compare	value_comp () const noexcept
allocator_type	get_allocator () const noexcept
size_type	max_size () const noexcept
mapped_type &	at (key_type const &key)
mapped_type const &	at (key_type const &key) const
mapped_type &	operator[] (key_type const &key)
mapped_type &	operator[] (key_type &&key)
template<class... Args>
qpair< iterator, bool >	emplace (Args &&...args)
template<class... Args>
iterator	emplace_hint (const_iterator hint, Args &&...args)
template<class... Args>
qpair< iterator, bool >	try_emplace (key_type const &key, Args &&...args)
template<class... Args>
qpair< iterator, bool >	try_emplace (key_type &&key, Args &&...args)
template<class K, class... Args, std::enable_if_t< cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>
qpair< iterator, bool >	try_emplace (K &&k, Args &&...args)
template<class K, class... Args, std::enable_if_t< std::is_constructible_v< key_type, K const & > &&!cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>
qpair< iterator, bool >	try_emplace (K const &k, Args &&...args)
template<class M>
qpair< iterator, bool >	insert_or_assign (key_type const &key, M &&mapped)
template<class M>
qpair< iterator, bool >	insert_or_assign (key_type &&key, M &&mapped)
template<class K, class M, std::enable_if_t< cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>
qpair< iterator, bool >	insert_or_assign (K &&k, M &&mapped)
template<class K, class M, std::enable_if_t< std::is_constructible_v< key_type, K const & > &&!cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>
qpair< iterator, bool >	insert_or_assign (K const &k, M &&mapped)

Friends
class	qtree_tester
void	swap (qmap &a, qmap &b) noexcept(noexcept(a.swap(b)))
bool	operator== (qmap const &a, qmap const &b)
bool	operator!= (qmap const &a, qmap const &b)
bool	operator< (qmap const &a, qmap const &b)
bool	operator> (qmap const &a, qmap const &b)
bool	operator<= (qmap const &a, qmap const &b)
bool	operator>= (qmap const &a, qmap const &b)

Member Typedef Documentation

key_type

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::key_type = Key

mapped_type

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::mapped_type = T

value_type

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::value_type = qpair<const Key, T>

size_type

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::size_type = typename Tree::size_type

difference_type

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::difference_type = typename Tree::difference_type

key_compare

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::key_compare = Compare

value_compare

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::value_compare = typename Tree::value_compare

allocator_policy_type

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::allocator_policy_type = AllocPolicy

reference

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::reference = value_type &

const_reference

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::const_reference = value_type const &

pointer

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::pointer = value_type *

const_pointer

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::const_pointer = value_type const *

iterator

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::iterator = typename Tree::iterator

const_iterator

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::const_iterator = typename Tree::const_iterator

reverse_iterator

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::reverse_iterator = qiterator_detail::qreverse_iterator<iterator>

const_reverse_iterator

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::const_reverse_iterator = qiterator_detail::qreverse_iterator<const_iterator>

allocator_type

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::allocator_type = typename Tree::allocator_type

enable_hetero_eq

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::enable_hetero_eq = typename Tree::template enable_hetero_eq<K>

enable_hetero_lb

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::enable_hetero_lb = typename Tree::template enable_hetero_lb<K>

enable_hetero_ub

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::enable_hetero_ub = typename Tree::template enable_hetero_ub<K>

enable_hetero_eqrange

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K>

using qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::enable_hetero_eqrange = typename Tree::template enable_hetero_eqrange<K>

Constructor & Destructor Documentation

qmap() [1/3]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::qmap ( std::initializer_list< value_type > init )

inline

qmap() [2/3]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::qmap ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & other )

inline

qmap() [3/3]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::qmap ( qmap< Key, T, Compare, AllocPolicy, PackNode > && other )

inlinenoexcept

~qmap()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::~qmap ( )

default

Member Function Documentation

CXX17_MEMORY_ALLOCATION_FUNCS_USING_POLICY()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::CXX17_MEMORY_ALLOCATION_FUNCS_USING_POLICY ( AllocPolicy )

inlinenoexcept

operator=() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qmap & qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::operator= ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & other )

inline

operator=() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qmap & qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::operator= ( qmap< Key, T, Compare, AllocPolicy, PackNode > && other )

inlinenoexcept

swap()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

void qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::swap ( qmap< Key, T, Compare, AllocPolicy, PackNode > & other )

inlinenoexcept

begin() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::begin ( )

inlinenoexcept

begin() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::begin ( ) const

inlinenoexcept

cbegin()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::cbegin ( ) const

inlinenoexcept

end() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::end ( )

inlinenoexcept

end() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::end ( ) const

inlinenoexcept

cend()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::cend ( ) const

inlinenoexcept

rbegin() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

reverse_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::rbegin ( )

inlinenoexcept

rbegin() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_reverse_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::rbegin ( ) const

inlinenoexcept

crbegin()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_reverse_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::crbegin ( ) const

inlinenoexcept

rend() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

reverse_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::rend ( )

inlinenoexcept

rend() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_reverse_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::rend ( ) const

inlinenoexcept

crend()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_reverse_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::crend ( ) const

inlinenoexcept

empty()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::empty ( ) const

inlinenoexcept

size()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

size_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::size ( ) const

inlinenoexcept

find() [1/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::find ( key_type const & key )

inlinenodiscard

find() [2/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::find ( key_type const & key ) const

inlinenodiscard

find() [3/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::find ( K const & k )

inlinenodiscard

find() [4/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::find ( K const & k ) const

inlinenodiscard

contains() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::contains ( key_type const & key ) const

inlinenodiscard

contains() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

bool qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::contains ( K const & k ) const

inlinenodiscard

count() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

size_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::count ( key_type const & key ) const

inlinenodiscard

count() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

size_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::count ( K const & k ) const

inlinenodiscard

lower_bound() [1/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::lower_bound ( key_type const & key )

inlinenodiscard

lower_bound() [2/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::lower_bound ( key_type const & key ) const

inlinenodiscard

lower_bound() [3/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::lower_bound ( K const & k )

inlinenodiscard

lower_bound() [4/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::lower_bound ( K const & k ) const

inlinenodiscard

upper_bound() [1/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::upper_bound ( key_type const & key )

inlinenodiscard

upper_bound() [2/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::upper_bound ( key_type const & key ) const

inlinenodiscard

upper_bound() [3/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::upper_bound ( K const & k )

inlinenodiscard

upper_bound() [4/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

const_iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::upper_bound ( K const & k ) const

inlinenodiscard

equal_range() [1/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qpair< iterator, iterator > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::equal_range ( key_type const & key )

inlinenodiscard

equal_range() [2/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qpair< const_iterator, const_iterator > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::equal_range ( key_type const & key ) const

inlinenodiscard

equal_range() [3/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

qpair< iterator, iterator > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::equal_range ( K const & k )

inlinenodiscard

equal_range() [4/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

qpair< const_iterator, const_iterator > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::equal_range ( K const & k ) const

inlinenodiscard

clear()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

void qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::clear ( )

inlinenoexcept

insert() [1/6]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class InputIt>

void qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert ( InputIt first, InputIt last )

inline

insert() [2/6]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

void qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert ( std::initializer_list< value_type > init )

inline

insert() [3/6]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert ( value_type const & v )

inline

insert() [4/6]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert ( value_type && v )

inline

insert() [5/6]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert ( const_iterator hint, value_type const & v )

inline

insert() [6/6]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert ( const_iterator hint, value_type && v )

inline

erase() [1/5]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::erase ( const_iterator pos )

inline

erase() [2/5]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::erase ( iterator pos )

inline

erase() [3/5]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::erase ( const_iterator first, const_iterator last )

inline

erase() [4/5]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

size_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::erase ( key_type const & key )

inline

erase() [5/5]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

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

size_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::erase ( K const & k )

inline

erase_if()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class Pred>

size_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::erase_if ( Pred pred )

inline

key_comp()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

key_compare qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::key_comp ( ) const

inlinenoexcept

value_comp()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

value_compare qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::value_comp ( ) const

inlinenoexcept

get_allocator()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

allocator_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::get_allocator ( ) const

inlinenoexcept

max_size()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

size_type qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::max_size ( ) const

inlinenoexcept

at() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

mapped_type & qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::at ( key_type const & key )

inline

at() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

mapped_type const & qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::at ( key_type const & key ) const

inline

operator[]() [1/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

mapped_type & qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::operator[] ( key_type const & key )

inline

operator[]() [2/2]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

mapped_type & qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::operator[] ( key_type && key )

inline

emplace()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class... Args>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::emplace ( Args &&... args )

inline

emplace_hint()

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class... Args>

iterator qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::emplace_hint ( const_iterator hint, Args &&... args )

inline

try_emplace() [1/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class... Args>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::try_emplace ( key_type const & key, Args &&... args )

inline

try_emplace() [2/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class... Args>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::try_emplace ( key_type && key, Args &&... args )

inline

try_emplace() [3/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K, class... Args, std::enable_if_t< cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::try_emplace ( K && k, Args &&... args )

inline

try_emplace() [4/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K, class... Args, std::enable_if_t< std::is_constructible_v< key_type, K const & > &&!cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::try_emplace ( K const & k, Args &&... args )

inline

insert_or_assign() [1/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class M>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert_or_assign ( key_type const & key, M && mapped )

inline

insert_or_assign() [2/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class M>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert_or_assign ( key_type && key, M && mapped )

inline

insert_or_assign() [3/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K, class M, std::enable_if_t< cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert_or_assign ( K && k, M && mapped )

inline

insert_or_assign() [4/4]

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

template<class K, class M, std::enable_if_t< std::is_constructible_v< key_type, K const & > &&!cmp_bidir_v< key_compare, key_type, std::decay_t< K > >, int > = 0>

qpair< iterator, bool > qtree_detail::qmap< Key, T, Compare, AllocPolicy, PackNode >::insert_or_assign ( K const & k, M && mapped )

inline

Friends And Related Symbol Documentation

qtree_tester

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

friend class qtree_tester

friend

swap

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

void swap ( qmap< Key, T, Compare, AllocPolicy, PackNode > & a, qmap< Key, T, Compare, AllocPolicy, PackNode > & b )

friend

operator==

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool operator== ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & a, qmap< Key, T, Compare, AllocPolicy, PackNode > const & b )

friend

operator!=

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool operator!= ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & a, qmap< Key, T, Compare, AllocPolicy, PackNode > const & b )

friend

operator<

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool operator< ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & a, qmap< Key, T, Compare, AllocPolicy, PackNode > const & b )

friend

operator>

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool operator> ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & a, qmap< Key, T, Compare, AllocPolicy, PackNode > const & b )

friend

operator<=

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool operator<= ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & a, qmap< Key, T, Compare, AllocPolicy, PackNode > const & b )

friend

operator>=

template<class Key, class T, class Compare, class AllocPolicy, bool PackNode = true>

bool operator>= ( qmap< Key, T, Compare, AllocPolicy, PackNode > const & a, qmap< Key, T, Compare, AllocPolicy, PackNode > const & b )

friend

---

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

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