map< _Kty, _Ty, _Pr, _Alloc > Class Template Reference

Inheritance diagram for map< _Kty, _Ty, _Pr, _Alloc >:

Public Types
typedef map< _Kty, _Ty, _Pr, _Alloc >	_Myt
typedef _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >	_Mybase
typedef _Kty	key_type
typedef _Ty	mapped_type
typedef _Pr	key_compare
typedef _Mybase::value_compare	value_compare
typedef _Mybase::allocator_type	allocator_type
typedef _Mybase::size_type	size_type
typedef _Mybase::difference_type	difference_type
typedef _Mybase::pointer	pointer
typedef _Mybase::const_pointer	const_pointer
typedef _Mybase::reference	reference
typedef _Mybase::const_reference	const_reference
typedef _Mybase::iterator	iterator
typedef _Mybase::const_iterator	const_iterator
typedef _Mybase::reverse_iterator	reverse_iterator
typedef _Mybase::const_reverse_iterator	const_reverse_iterator
typedef _Mybase::value_type	value_type
typedef _Mybase::_Alty	_Alty
typedef _Mybase::_Pairib	_Pairib
Public Types inherited from _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >
enum
typedef _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >	_Myt
typedef _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >	_Mybase
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false >::key_type	key_type
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false >::value_compare	value_compare
typedef _Mybase::_Node	_Node
typedef _Mybase::_Nodeptr	_Nodeptr
typedef _Mybase::_Alty	_Alty
typedef _Mybase::key_compare	key_compare
typedef _Mybase::allocator_type	allocator_type
typedef _Mybase::value_type	value_type
typedef _Mybase::size_type	size_type
typedef _Mybase::difference_type	difference_type
typedef _Mybase::pointer	pointer
typedef _Mybase::const_pointer	const_pointer
typedef _Mybase::reference	reference
typedef _Mybase::const_reference	const_reference
typedef _Mybase::const_iterator	const_iterator
typedef _If< is_same< key_type, value_type >::value, typename _Mybase::const_iterator, typename _Mybase::iterator >::type	iterator
typedef _STD reverse_iterator< iterator >	reverse_iterator
typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator
typedef pair< iterator, bool >	_Pairib
typedef pair< iterator, iterator >	_Pairii
typedef pair< const_iterator, const_iterator >	_Paircc
Public Types inherited from _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >
enum	_Redbl
typedef _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >	_Myt
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false >::allocator_type	allocator_type
typedef _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false >::key_compare	key_compare
typedef _Tree_base_types< typename _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false >::value_type, allocator_type >	_Alloc_types
typedef _Alloc_types::_Alloc	_Alloc
typedef _Alloc_types::_Alnod_type	_Alty
typedef _Alloc_types::_Node	_Node
typedef _Alloc_types::_Nodeptr	_Nodeptr
typedef _Alloc_types::_Val_types	_Val_types
typedef _Nodeptr &	_Nodepref
typedef _Val_types::value_type	value_type
typedef _Val_types::size_type	size_type
typedef _Val_types::difference_type	difference_type
typedef _Val_types::pointer	pointer
typedef _Val_types::const_pointer	const_pointer
typedef _Val_types::reference	reference
typedef _Val_types::const_reference	const_reference
typedef _Tree_const_iterator< _Tree_val< _Val_types > >	const_iterator
typedef _Tree_iterator< _Tree_val< _Val_types > >	iterator

Public Member Functions
	map ()
	map (const allocator_type &_Al)
	map (const _Myt &_Right)
	map (const _Myt &_Right, const allocator_type &_Al)
	map (const key_compare &_Pred)
	map (const key_compare &_Pred, const allocator_type &_Al)
template<class _Iter >
	map (_Iter _First, _Iter _Last)
template<class _Iter >
	map (_Iter _First, _Iter _Last, const key_compare &_Pred)
template<class _Iter >
	map (_Iter _First, _Iter _Last, const allocator_type &_Al)
template<class _Iter >
	map (_Iter _First, _Iter _Last, const key_compare &_Pred, const allocator_type &_Al)
_Myt &	operator= (const _Myt &_Right)
	map (_Myt &&_Right)
	map (_Myt &&_Right, const allocator_type &_Al)
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP(_Alty
mapped_type &	operator[] (key_type &&_Keyval)
void	swap (_Myt &_Right) _NOEXCEPT_OP(_Alty
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
_Pairib	insert (_Valty &&_Val)
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator	insert (const_iterator _Where, _Valty &&_Val)
template<class _Keyty , class... _Mappedty>
_Pairib	_Try_emplace (_Keyty &&_Keyval, _Mappedty &&..._Mapval)
template<class... _Mappedty>
_Pairib	try_emplace (const key_type &_Keyval, _Mappedty &&..._Mapval)
template<class... _Mappedty>
iterator	try_emplace (const_iterator, const key_type &_Keyval, _Mappedty &&..._Mapval)
template<class... _Mappedty>
_Pairib	try_emplace (key_type &&_Keyval, _Mappedty &&..._Mapval)
template<class... _Mappedty>
iterator	try_emplace (const_iterator, key_type &&_Keyval, _Mappedty &&..._Mapval)
template<class _Keyty , class _Mappedty >
_Pairib	_Insert_or_assign (_Keyty &&_Keyval, _Mappedty &&_Mapval)
template<class _Mappedty >
_Pairib	insert_or_assign (const key_type &_Keyval, _Mappedty &&_Mapval)
template<class _Mappedty >
iterator	insert_or_assign (const_iterator, const key_type &_Keyval, _Mappedty &&_Mapval)
template<class _Mappedty >
_Pairib	insert_or_assign (key_type &&_Keyval, _Mappedty &&_Mapval)
template<class _Mappedty >
iterator	insert_or_assign (const_iterator, key_type &&_Keyval, _Mappedty &&_Mapval)
	map (initializer_list< value_type > _Ilist)
	map (initializer_list< value_type > _Ilist, const key_compare &_Pred)
	map (initializer_list< value_type > _Ilist, const allocator_type &_Al)
	map (initializer_list< value_type > _Ilist, const key_compare &_Pred, const allocator_type &_Al)
_Myt &	operator= (initializer_list< value_type > _Ilist)
mapped_type &	operator[] (const key_type &_Keyval)
mapped_type &	at (const key_type &_Keyval)
const mapped_type &	at (const key_type &_Keyval) const
Public Member Functions inherited from _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >
	_Tree (const key_compare &_Parg)
	_Tree (const key_compare &_Parg, const allocator_type &_Al)
	_Tree (const _Myt &_Right, _Any_alloc &&_Al)
	_Tree (_Myt &&_Right)
	_Tree (_Myt &&_Right, const allocator_type &_Al)
_Myt &	operator= (_Myt &&_Right)
_Myt &	operator= (const _Myt &_Right)
void	_Assign_rv (_Myt &&_Right, true_type)
void	_Assign_rv (_Myt &&_Right, false_type)
_Pairib	emplace (_Valty &&..._Val)
iterator	emplace_hint (const_iterator _Where, _Valty &&..._Val)
	~_Tree () _NOEXCEPT
iterator	begin () _NOEXCEPT
const_iterator	begin () const _NOEXCEPT
iterator	end () _NOEXCEPT
const_iterator	end () const _NOEXCEPT
reverse_iterator	rbegin () _NOEXCEPT
const_reverse_iterator	rbegin () const _NOEXCEPT
reverse_iterator	rend () _NOEXCEPT
const_reverse_iterator	rend () const _NOEXCEPT
const_iterator	cbegin () const _NOEXCEPT
const_iterator	cend () const _NOEXCEPT
const_reverse_iterator	crbegin () const _NOEXCEPT
const_reverse_iterator	crend () const _NOEXCEPT
size_type	size () const _NOEXCEPT
size_type	max_size () const _NOEXCEPT
bool	empty () const _NOEXCEPT
allocator_type	get_allocator () const _NOEXCEPT
key_compare	key_comp () const
value_compare	value_comp () const
_Pairib	insert (const value_type &_Val)
iterator	insert (const value_type &_Val)
_Pairib	insert (value_type &&_Val)
iterator	insert (value_type &&_Val)
iterator	insert (const_iterator _Where, const value_type &_Val)
iterator	insert (const_iterator _Where, value_type &&_Val)
void	insert (_Iter _First, _Iter _Last)
void	insert (initializer_list< value_type > _Ilist)
iterator	erase (const_iterator _Where)
iterator	erase (const_iterator _First, const_iterator _Last)
size_type	erase (const key_type &_Keyval)
void	clear () _NOEXCEPT
iterator	find (const key_type &_Keyval)
const_iterator	find (const key_type &_Keyval) const
iterator	find (const _Other &_Keyval)
const_iterator	find (const _Other &_Keyval) const
size_type	count (const key_type &_Keyval) const
size_type	count (const _Other &_Keyval) const
iterator	lower_bound (const key_type &_Keyval)
const_iterator	lower_bound (const key_type &_Keyval) const
iterator	lower_bound (const _Other &_Keyval)
const_iterator	lower_bound (const _Other &_Keyval) const
iterator	upper_bound (const key_type &_Keyval)
const_iterator	upper_bound (const key_type &_Keyval) const
iterator	upper_bound (const _Other &_Keyval)
const_iterator	upper_bound (const _Other &_Keyval) const
_Pairii	equal_range (const key_type &_Keyval)
_Paircc	equal_range (const key_type &_Keyval) const
_Pairii	equal_range (const _Other &_Keyval)
_Paircc	equal_range (const _Other &_Keyval) const
void	swap (_Myt &_Right)
Public Member Functions inherited from _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >
	_Tree_comp_alloc (const key_compare &_Parg)
	_Tree_comp_alloc (const key_compare &_Parg, _Any_alloc &&_Al)
void	_Construct ()
	~_Tree_comp_alloc () _NOEXCEPT
void	_Alloc_proxy ()
void	_Free_proxy ()
void	_Copy_alloc (const _Alty &_Al)
void	_Move_alloc (_Alty &_Al)
void	_Orphan_all ()
void	_Swap_all (_Myt &_Right)
_Nodeptr	_Buyheadnode ()
void	_Freeheadnode (_Nodeptr _Pnode)
_Nodeptr	_Buynode0 ()
void	_Freenode0 (_Nodeptr _Pnode)
_Nodeptr	_Buynode (_Valty &&..._Val)
key_compare &	_Getcomp () _NOEXCEPT
const key_compare &	_Getcomp () const _NOEXCEPT
_Alty &	_Getal () _NOEXCEPT
const _Alty &	_Getal () const _NOEXCEPT
_Tree_val< _Val_types > &	_Get_data () _NOEXCEPT
const _Tree_val< _Val_types > &	_Get_data () const _NOEXCEPT
_Nodeptr &	_Myhead () _NOEXCEPT
const _Nodeptr &	_Myhead () const _NOEXCEPT
size_type &	_Mysize () _NOEXCEPT
const size_type &	_Mysize () const _NOEXCEPT

Additional Inherited Members
Static Public Member Functions inherited from _Tree_comp_alloc< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >
static char &	_Color (_Nodeptr _Pnode)
static char &	_Isnil (_Nodeptr _Pnode)
static _Nodepref	_Left (_Nodeptr _Pnode)
static _Nodepref	_Parent (_Nodeptr _Pnode)
static _Nodepref	_Right (_Nodeptr _Pnode)
static reference	_Myval (_Nodeptr _Pnode)
static _Nodeptr	_Max (_Nodeptr _Pnode)
static _Nodeptr	_Min (_Nodeptr _Pnode)
Protected Member Functions inherited from _Tree< _Tmap_traits< _Kty, _Ty, _Pr, _Alloc, false > >
_Nodeptr	_Buynode_if_nil (_Nodeptr _Node, _Valty &&)
_Nodeptr	_Buynode_if_nil (_Nil, _Valty &&_Val)
void	_Destroy_if_not_nil (_Nodeptr _Newnode)
void	_Destroy_if_not_nil (_Nil)
iterator	_Insert_hint (const_iterator _Where, _Valty &&_Val, _Nodety _Newnode)
_Pairib	_Insert_nohint (bool _Leftish, _Valty &&_Val, _Nodety _Newnode)
iterator	_Insert_at (bool _Addleft, _Nodeptr _Wherenode, _Valty &&_Val, _Nodety _Node)
void	_Copy (const _Myt &_Right, _Moveit _Movefl)
_Nodeptr	_Copy_or_move (_Ty &_Val, _Copy_tag, _Is_set)
_Nodeptr	_Copy_or_move (_Ty &_Val, _Move_tag, true_type)
_Nodeptr	_Copy_or_move (_Ty &_Val, _Move_tag, false_type)
_Nodeptr	_Copy_nodes (_Nodeptr _Rootnode, _Nodeptr _Wherenode, _Moveit _Movefl)
_Paircc	_Eqrange (const _Other &_Keyval) const
_Pairii	_Eqrange (const _Other &_Keyval)
void	_Erase (_Nodeptr _Rootnode)
bool	_Compare (const key_type &_Left, const key_type &_Right) const
bool	_Compare (const _Ty1 &_Left, const _Ty2 &_Right) const
_Nodeptr	_Lbound (const _Other &_Keyval) const
_Nodeptr &	_Lmost () const
void	_Lrotate (_Nodeptr _Wherenode)
_Nodeptr &	_Rmost () const
_Nodeptr &	_Root () const
void	_Rrotate (_Nodeptr _Wherenode)
_Nodeptr	_Ubound (const _Other &_Keyval) const
void	_Tidy ()
const key_type &	_Kfn (const value_type &_Val) const
const key_type &	_Key (_Nodeptr _Pnode) const

Member Typedef Documentation

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::_Alty map< _Kty, _Ty, _Pr, _Alloc >::_Alty

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> > map< _Kty, _Ty, _Pr, _Alloc >::_Mybase

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef map<_Kty, _Ty, _Pr, _Alloc> map< _Kty, _Ty, _Pr, _Alloc >::_Myt

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::_Pairib map< _Kty, _Ty, _Pr, _Alloc >::_Pairib

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::allocator_type map< _Kty, _Ty, _Pr, _Alloc >::allocator_type

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_iterator map< _Kty, _Ty, _Pr, _Alloc >::const_iterator

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_pointer map< _Kty, _Ty, _Pr, _Alloc >::const_pointer

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_reference map< _Kty, _Ty, _Pr, _Alloc >::const_reference

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_reverse_iterator map< _Kty, _Ty, _Pr, _Alloc >::const_reverse_iterator

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::difference_type map< _Kty, _Ty, _Pr, _Alloc >::difference_type

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::iterator map< _Kty, _Ty, _Pr, _Alloc >::iterator

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Pr map< _Kty, _Ty, _Pr, _Alloc >::key_compare

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Kty map< _Kty, _Ty, _Pr, _Alloc >::key_type

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Ty map< _Kty, _Ty, _Pr, _Alloc >::mapped_type

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::pointer map< _Kty, _Ty, _Pr, _Alloc >::pointer

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::reference map< _Kty, _Ty, _Pr, _Alloc >::reference

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::reverse_iterator map< _Kty, _Ty, _Pr, _Alloc >::reverse_iterator

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::size_type map< _Kty, _Ty, _Pr, _Alloc >::size_type

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::value_compare map< _Kty, _Ty, _Pr, _Alloc >::value_compare

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::value_type map< _Kty, _Ty, _Pr, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( )

inline

        : _Mybase(key_compare())
        {   // construct empty map from defaults
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( const allocator_type &  _Al )

inlineexplicit

        : _Mybase(key_compare(), _Al)
        {   // construct empty map from defaults, allocator
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( const _Myt &  _Right )

inline

        : _Mybase(_Right,
            _Right._Getal().select_on_container_copy_construction())
        {   // construct map by copying _Right
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( const _Myt &  _Right, const allocator_type &  _Al  )

inline

        : _Mybase(_Right, _Al)
        {   // construct map by copying _Right, allocator
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( const key_compare &  _Pred )

inlineexplicit

        : _Mybase(_Pred)
        {   // construct empty map from comparator
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( const key_compare &  _Pred, const allocator_type &  _Al  )

inline

        : _Mybase(_Pred, _Al)
        {   // construct empty map from comparator and allocator
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

map< _Kty, _Ty, _Pr, _Alloc >::map ( _Iter  _First, _Iter  _Last  )

inline

        : _Mybase(key_compare())
        {   // construct map from [_First, _Last), defaults
        insert(_First, _Last);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

map< _Kty, _Ty, _Pr, _Alloc >::map ( _Iter  _First, _Iter  _Last, const key_compare &  _Pred  )

inline

        : _Mybase(_Pred)
        {   // construct map from [_First, _Last), comparator
        insert(_First, _Last);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

map< _Kty, _Ty, _Pr, _Alloc >::map ( _Iter  _First, _Iter  _Last, const allocator_type &  _Al  )

inline

        : _Mybase(key_compare(), _Al)
        {   // construct map from [_First, _Last), allocator
        insert(_First, _Last);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

map< _Kty, _Ty, _Pr, _Alloc >::map ( _Iter  _First, _Iter  _Last, const key_compare &  _Pred, const allocator_type &  _Al  )

inline

        : _Mybase(_Pred, _Al)
        {   // construct map from [_First, _Last), comparator, and allocator
        insert(_First, _Last);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( _Myt &&  _Right )

inline

        : _Mybase(_STD move(_Right))
        {   // construct map by moving _Right
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( _Myt &&  _Right, const allocator_type &  _Al  )

inline

        : _Mybase(_STD move(_Right), _Al)
        {   // construct map by moving _Right, allocator
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( initializer_list< value_type >  _Ilist )

inline

        : _Mybase(key_compare())
        {   // construct from initializer_list, defaults
        insert(_Ilist);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( initializer_list< value_type >  _Ilist, const key_compare &  _Pred  )

inline

        : _Mybase(_Pred)
        {   // construct from initializer_list, comparator
        insert(_Ilist);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( initializer_list< value_type >  _Ilist, const allocator_type &  _Al  )

inline

        : _Mybase(key_compare(), _Al)
        {   // construct from initializer_list, allocator
        insert(_Ilist);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

map< _Kty, _Ty, _Pr, _Alloc >::map ( initializer_list< value_type >  _Ilist, const key_compare &  _Pred, const allocator_type &  _Al  )

inline

        : _Mybase(_Pred, _Al)
        {   // construct from initializer_list, comparator, and allocator
        insert(_Ilist);
        }

Member Function Documentation

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Keyty , class _Mappedty >

_Pairib map< _Kty, _Ty, _Pr, _Alloc >::_Insert_or_assign ( _Keyty &&  _Keyval, _Mappedty &&  _Mapval  )

inline

        {   // assign if _Keyval present, else insert
        iterator _Where = _Mybase::lower_bound(_Keyval);
        if (_Where == _Mybase::end()
            || _DEBUG_LT_PRED(_Mybase::_Getcomp(),
                _Keyval, _Mybase::_Key(_Where._Mynode())))
            return (_Pairib(
                _Mybase::emplace_hint(_Where,
                    _STD forward<_Keyty>(_Keyval),
                    _STD forward<_Mappedty>(_Mapval)),
                true));
        else
            {   // _Keyval present, assign new value
            _Where->second = _STD forward<_Mappedty>(_Mapval);
            return (_Pairib(_Where, false));
            }
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Keyty , class... _Mappedty>

_Pairib map< _Kty, _Ty, _Pr, _Alloc >::_Try_emplace ( _Keyty &&  _Keyval, _Mappedty &&...  _Mapval  )

inline

        {   // fail if _Keyval present, else emplace
        iterator _Where = _Mybase::lower_bound(_Keyval);
        if (_Where == _Mybase::end()
            || _DEBUG_LT_PRED(_Mybase::_Getcomp(),
                _Keyval, _Mybase::_Key(_Where._Mynode())))
            return (_Pairib(
                _Mybase::emplace_hint(_Where,
                    piecewise_construct,
                    _STD forward_as_tuple(
                        _STD forward<_Keyty>(_Keyval)),
                    _STD forward_as_tuple(
                        _STD forward<_Mappedty>(_Mapval)...)),
                true));
        else
            return (_Pairib(_Where, false));
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

mapped_type& map< _Kty, _Ty, _Pr, _Alloc >::at ( const key_type &  _Keyval )

inline

        {   // find element matching _Keyval
        iterator _Where = _Mybase::lower_bound(_Keyval);
        if (_Where == _Mybase::end()
            || _Mybase::_Getcomp()(_Keyval, _Mybase::_Key(_Where._Mynode())))
            _Xout_of_range("invalid map<K, T> key");
        return (_Where->second);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

const mapped_type& map< _Kty, _Ty, _Pr, _Alloc >::at ( const key_type &  _Keyval ) const

inline

        {   // find element matching _Keyval
        const_iterator _Where = _Mybase::lower_bound(_Keyval);
        if (_Where == _Mybase::end()
            || _Mybase::_Getcomp()(_Keyval, _Mybase::_Key(_Where._Mynode())))
            _Xout_of_range("invalid map<K, T> key");
        return (_Where->second);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>

_Pairib map< _Kty, _Ty, _Pr, _Alloc >::insert ( _Valty &&  _Val )

inline

        {   // insert _Val
        return (this->emplace(_STD forward<_Valty>(_Val)));
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>

iterator map< _Kty, _Ty, _Pr, _Alloc >::insert ( const_iterator  _Where, _Valty &&  _Val  )

inline

        {   // insert _Val with hint
        return (this->emplace_hint(_Where, _STD forward<_Valty>(_Val)));
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Mappedty >

_Pairib map< _Kty, _Ty, _Pr, _Alloc >::insert_or_assign ( const key_type &  _Keyval, _Mappedty &&  _Mapval  )

inline

        {   // assign if _Keyval present, else insert
        return (_Insert_or_assign(_Keyval,
            _STD forward<_Mappedty>(_Mapval)));
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Mappedty >

iterator map< _Kty, _Ty, _Pr, _Alloc >::insert_or_assign ( const_iterator  , const key_type &  _Keyval, _Mappedty &&  _Mapval  )

inline

        {   // assign if _Keyval present, else insert, ignore hint
        return (_Insert_or_assign(_Keyval,
            _STD forward<_Mappedty>(_Mapval)).first);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Mappedty >

_Pairib map< _Kty, _Ty, _Pr, _Alloc >::insert_or_assign ( key_type &&  _Keyval, _Mappedty &&  _Mapval  )

inline

        {   // assign if _Keyval present, else insert
        return (_Insert_or_assign(_STD move(_Keyval),
            _STD forward<_Mappedty>(_Mapval)));
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Mappedty >

iterator map< _Kty, _Ty, _Pr, _Alloc >::insert_or_assign ( const_iterator  , key_type &&  _Keyval, _Mappedty &&  _Mapval  )

inline

        {   // assign if _Keyval present, else insert, ignore hint
        return (_Insert_or_assign(_STD move(_Keyval),
            _STD forward<_Mappedty>(_Mapval)).first);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& map< _Kty, _Ty, _Pr, _Alloc >::operator= ( const _Myt &  _Right )

inline

        {   // assign by copying _Right
        _Mybase::operator=(_Right);
        return (*this);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& map< _Kty, _Ty, _Pr, _Alloc >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        _Mybase::operator=(_STD move(_Right));
        return (*this);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& map< _Kty, _Ty, _Pr, _Alloc >::operator= ( initializer_list< value_type >  _Ilist )

inline

        {   // assign initializer_list
        _Mybase::clear();
        insert(_Ilist);
        return (*this);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

mapped_type& map< _Kty, _Ty, _Pr, _Alloc >::operator[] ( key_type &&  _Keyval )

inline

        {   // find element matching _Keyval or insert with default mapped
        return (try_emplace(_STD move(_Keyval)).first->second);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

mapped_type& map< _Kty, _Ty, _Pr, _Alloc >::operator[] ( const key_type &  _Keyval )

inline

        {   // find element matching _Keyval or insert with default mapped
        return (try_emplace(_Keyval).first->second);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

void map< _Kty, _Ty, _Pr, _Alloc >::swap ( _Myt &  _Right )

inline

        {   // exchange contents with non-movable _Right
        _Mybase::swap(_Right);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class... _Mappedty>

_Pairib map< _Kty, _Ty, _Pr, _Alloc >::try_emplace ( const key_type &  _Keyval, _Mappedty &&...  _Mapval  )

inline

        {   // fail if _Keyval present, else emplace
        return (_Try_emplace(_Keyval, _STD forward<_Mappedty>(_Mapval)...));
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class... _Mappedty>

iterator map< _Kty, _Ty, _Pr, _Alloc >::try_emplace ( const_iterator  , const key_type &  _Keyval, _Mappedty &&...  _Mapval  )

inline

        {   // fail if _Keyval present, else emplace, ignore hint
        return (_Try_emplace(_Keyval,
            _STD forward<_Mappedty>(_Mapval)...).first);
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class... _Mappedty>

_Pairib map< _Kty, _Ty, _Pr, _Alloc >::try_emplace ( key_type &&  _Keyval, _Mappedty &&...  _Mapval  )

inline

        {   // fail if _Keyval present, else emplace
        return (_Try_emplace(_STD move(_Keyval),
            _STD forward<_Mappedty>(_Mapval)...));
        }

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class... _Mappedty>

iterator map< _Kty, _Ty, _Pr, _Alloc >::try_emplace ( const_iterator  , key_type &&  _Keyval, _Mappedty &&...  _Mapval  )

inline

        {   // fail if _Keyval present, else emplace, ignore hint
        return (_Try_emplace(_STD move(_Keyval),
            _STD forward<_Mappedty>(_Mapval)...).first);
        }

---

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

• VS2017/inc/map