_Tree_comp_alloc< _Traits > Class Template Reference

Inheritance diagram for _Tree_comp_alloc< _Traits >:

Public Types
enum	_Redbl { _Red, _Black }
typedef _Tree_comp_alloc< _Traits >	_Myt
typedef _Traits::allocator_type	allocator_type
typedef _Traits::key_compare	key_compare
typedef _Tree_base_types< typename _Traits::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
	_Tree_comp_alloc (const key_compare &_Parg)
template<class _Any_alloc , class = enable_if_t<!is_same<decay_t<_Any_alloc>, _Myt>::value>>
	_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)
template<class... _Valty>
_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

Static Public Member Functions
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)

Private Attributes
_Compressed_pair< key_compare, _Compressed_pair< _Alty, _Tree_val< _Val_types > > >	_Mypair

Member Typedef Documentation

template<class _Traits>

typedef _Alloc_types::_Alloc _Tree_comp_alloc< _Traits >::_Alloc

template<class _Traits>

typedef _Tree_base_types<typename _Traits::value_type, allocator_type> _Tree_comp_alloc< _Traits >::_Alloc_types

template<class _Traits>

typedef _Alloc_types::_Alnod_type _Tree_comp_alloc< _Traits >::_Alty

template<class _Traits>

typedef _Tree_comp_alloc<_Traits> _Tree_comp_alloc< _Traits >::_Myt

template<class _Traits>

typedef _Alloc_types::_Node _Tree_comp_alloc< _Traits >::_Node

template<class _Traits>

typedef _Nodeptr& _Tree_comp_alloc< _Traits >::_Nodepref

template<class _Traits>

typedef _Alloc_types::_Nodeptr _Tree_comp_alloc< _Traits >::_Nodeptr

template<class _Traits>

typedef _Alloc_types::_Val_types _Tree_comp_alloc< _Traits >::_Val_types

template<class _Traits>

typedef _Traits::allocator_type _Tree_comp_alloc< _Traits >::allocator_type

template<class _Traits>

typedef _Tree_const_iterator<_Tree_val<_Val_types> > _Tree_comp_alloc< _Traits >::const_iterator

template<class _Traits>

typedef _Val_types::const_pointer _Tree_comp_alloc< _Traits >::const_pointer

template<class _Traits>

typedef _Val_types::const_reference _Tree_comp_alloc< _Traits >::const_reference

template<class _Traits>

typedef _Val_types::difference_type _Tree_comp_alloc< _Traits >::difference_type

template<class _Traits>

typedef _Tree_iterator<_Tree_val<_Val_types> > _Tree_comp_alloc< _Traits >::iterator

template<class _Traits>

typedef _Traits::key_compare _Tree_comp_alloc< _Traits >::key_compare

template<class _Traits>

typedef _Val_types::pointer _Tree_comp_alloc< _Traits >::pointer

template<class _Traits>

typedef _Val_types::reference _Tree_comp_alloc< _Traits >::reference

template<class _Traits>

typedef _Val_types::size_type _Tree_comp_alloc< _Traits >::size_type

template<class _Traits>

typedef _Val_types::value_type _Tree_comp_alloc< _Traits >::value_type

Member Enumeration Documentation

template<class _Traits>

enum _Tree_comp_alloc::_Redbl

Enumerator
_Red
_Black

        {   // colors for link to parent
        _Red, _Black
        };

Constructor & Destructor Documentation

template<class _Traits>

_Tree_comp_alloc< _Traits >::_Tree_comp_alloc ( const key_compare &  _Parg )

inline

        : _Mypair(_One_then_variadic_args_t(), _Parg,
            _Zero_then_variadic_args_t())
        {   // construct from comparator
        _Construct();
        }

template<class _Traits>

template<class _Any_alloc , class = enable_if_t<!is_same<decay_t<_Any_alloc>, _Myt>::value>>

_Tree_comp_alloc< _Traits >::_Tree_comp_alloc ( const key_compare &  _Parg, _Any_alloc &&  _Al  )

inline

        : _Mypair(_One_then_variadic_args_t(), _Parg,
            _One_then_variadic_args_t(),
            _STD forward<_Any_alloc>(_Al))
        {   // construct from comparator, allocator
        _Construct();
        }

template<class _Traits>

_Tree_comp_alloc< _Traits >::~_Tree_comp_alloc ( )

inline

        {   // destroy head node
        _Freeheadnode(_Myhead());
        }

Member Function Documentation

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Alloc_proxy ( )

inline

        {   // do nothing
        }

template<class _Traits>

_Nodeptr _Tree_comp_alloc< _Traits >::_Buyheadnode ( )

inline

        {   // get head node using current allocator
        _Nodeptr _Pnode = _Getal().allocate(1);

        _TRY_BEGIN
        _Getal().construct(
            _STD addressof(_Left(_Pnode)), _Pnode);
        _Getal().construct(
            _STD addressof(_Parent(_Pnode)), _Pnode);
        _Getal().construct(
            _STD addressof(_Right(_Pnode)), _Pnode);
        _CATCH_ALL
        _Getal().deallocate(_Pnode, 1);
        _RERAISE;
        _CATCH_END

        _Color(_Pnode) = _Black;
        _Isnil(_Pnode) = true;
        return (_Pnode);
        }

template<class _Traits>

template<class... _Valty>

_Nodeptr _Tree_comp_alloc< _Traits >::_Buynode ( _Valty &&...  _Val )

inline

        {   // allocate a node with defaults and set links and value
        _Nodeptr _Pnode = _Buynode0();

        this->_Color(_Pnode) = _Red;
        this->_Isnil(_Pnode) = false;

        _TRY_BEGIN
        this->_Getal().construct(
            _STD addressof(_Myval(_Pnode)),
                _STD forward<_Valty>(_Val)...);
        _CATCH_ALL
        _Freenode0(_Pnode);
        _RERAISE;
        _CATCH_END

        return (_Pnode);
        }

template<class _Traits>

_Nodeptr _Tree_comp_alloc< _Traits >::_Buynode0 ( )

inline

        {   // allocate a non-value node
        _Nodeptr _Pnode = _Getal().allocate(1);

        _TRY_BEGIN
        _Getal().construct(
            _STD addressof(_Left(_Pnode)), _Myhead());
        _Getal().construct(
            _STD addressof(_Parent(_Pnode)), _Myhead());
        _Getal().construct(
            _STD addressof(_Right(_Pnode)), _Myhead());
        _CATCH_ALL
        _Getal().deallocate(_Pnode, 1);
        _RERAISE;
        _CATCH_END

        return (_Pnode);
        }

template<class _Traits>

static char& _Tree_comp_alloc< _Traits >::_Color ( _Nodeptr  _Pnode )

inlinestatic

        {   // return reference to color in node
        return (_Tree_val<_Val_types>::_Color(_Pnode));
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Construct ( )

inline

        {   // construct head node
        _Myhead() = _Buyheadnode();
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Copy_alloc ( const _Alty &  _Al )

inline

        {   // replace old allocator
        const bool _Reload = _Alty::propagate_on_container_copy_assignment::value && _Getal() != _Al;

        if (_Reload)
            {
            _Free_proxy();
            _Freeheadnode(_Myhead());
            }

        _Pocca(_Getal(), _Al);

        if (_Reload)
            {
            _Myhead() = _Buyheadnode();
            _Alloc_proxy();
            }
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Free_proxy ( )

inline

        {   // do nothing
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Freeheadnode ( _Nodeptr  _Pnode )

inline

        {   // free head node using current allocator
        _Getal().destroy(
            _STD addressof(_Left(_Pnode)));
        _Getal().destroy(
            _STD addressof(_Parent(_Pnode)));
        _Getal().destroy(
            _STD addressof(_Right(_Pnode)));
        _Getal().deallocate(_Pnode, 1);
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Freenode0 ( _Nodeptr  _Pnode )

inline

        {   // free non-value node using current allocator
        _Getal().destroy(
            _STD addressof(_Left(_Pnode)));
        _Getal().destroy(
            _STD addressof(_Parent(_Pnode)));
        _Getal().destroy(
            _STD addressof(_Right(_Pnode)));
        _Getal().deallocate(_Pnode, 1);
        }

template<class _Traits>

_Tree_val<_Val_types>& _Tree_comp_alloc< _Traits >::_Get_data ( )

inline

        {   // return reference to _Tree_val
        return (_Mypair._Get_second()._Get_second());
        }

template<class _Traits>

const _Tree_val<_Val_types>& _Tree_comp_alloc< _Traits >::_Get_data ( ) const

inline

        {   // return const reference to _Tree_val
        return (_Mypair._Get_second()._Get_second());
        }

template<class _Traits>

_Alty& _Tree_comp_alloc< _Traits >::_Getal ( )

inline

        {   // return reference to allocator
        return (_Mypair._Get_second()._Get_first());
        }

template<class _Traits>

const _Alty& _Tree_comp_alloc< _Traits >::_Getal ( ) const

inline

        {   // return const reference to allocator
        return (_Mypair._Get_second()._Get_first());
        }

template<class _Traits>

key_compare& _Tree_comp_alloc< _Traits >::_Getcomp ( )

inline

        {   // return reference to ordering predicate
        return (_Mypair._Get_first());
        }

template<class _Traits>

const key_compare& _Tree_comp_alloc< _Traits >::_Getcomp ( ) const

inline

        {   // return const reference to ordering predicate
        return (_Mypair._Get_first());
        }

template<class _Traits>

static char& _Tree_comp_alloc< _Traits >::_Isnil ( _Nodeptr  _Pnode )

inlinestatic

        {   // return reference to nil flag in node
        return (_Tree_val<_Val_types>::_Isnil(_Pnode));
        }

template<class _Traits>

static _Nodepref _Tree_comp_alloc< _Traits >::_Left ( _Nodeptr  _Pnode )

inlinestatic

        {   // return reference to left pointer in node
        return (_Tree_val<_Val_types>::_Left(_Pnode));
        }

template<class _Traits>

static _Nodeptr _Tree_comp_alloc< _Traits >::_Max ( _Nodeptr  _Pnode )

inlinestatic

        {   // return rightmost node in subtree at _Pnode
        return (_Tree_val<_Val_types>::_Max(_Pnode));
        }

template<class _Traits>

static _Nodeptr _Tree_comp_alloc< _Traits >::_Min ( _Nodeptr  _Pnode )

inlinestatic

        {   // return leftmost node in subtree at _Pnode
        return (_Tree_val<_Val_types>::_Min(_Pnode));
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Move_alloc ( _Alty &  _Al )

inline

        {   // replace old allocator
        const bool _Reload = _Alty::propagate_on_container_move_assignment::value && _Getal() != _Al;

        if (_Reload)
            {
            _Free_proxy();
            _Freeheadnode(_Myhead());
            }

        _Pocma(_Getal(), _Al);

        if (_Reload)
            {
            _Myhead() = _Buyheadnode();
            _Alloc_proxy();
            }
        }

template<class _Traits>

_Nodeptr& _Tree_comp_alloc< _Traits >::_Myhead ( )

inline

        {   // return reference to _Myhead
        return (_Get_data()._Myhead);
        }

template<class _Traits>

const _Nodeptr& _Tree_comp_alloc< _Traits >::_Myhead ( ) const

inline

        {   // return const reference to _Myhead
        return (_Get_data()._Myhead);
        }

template<class _Traits>

size_type& _Tree_comp_alloc< _Traits >::_Mysize ( )

inline

        {   // return reference to _Mysize
        return (_Get_data()._Mysize);
        }

template<class _Traits>

const size_type& _Tree_comp_alloc< _Traits >::_Mysize ( ) const

inline

        {   // return const reference to _Mysize
        return (_Get_data()._Mysize);
        }

template<class _Traits>

static reference _Tree_comp_alloc< _Traits >::_Myval ( _Nodeptr  _Pnode )

inlinestatic

        {   // return reference to value in node
        return (_Tree_val<_Val_types>::_Myval(_Pnode));
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Orphan_all ( )

inline

        {   // orphan all iterators
        _Get_data()._Orphan_all();
        }

template<class _Traits>

static _Nodepref _Tree_comp_alloc< _Traits >::_Parent ( _Nodeptr  _Pnode )

inlinestatic

        {   // return reference to parent pointer in node
        return (_Tree_val<_Val_types>::_Parent(_Pnode));
        }

template<class _Traits>

static _Nodepref _Tree_comp_alloc< _Traits >::_Right ( _Nodeptr  _Pnode )

inlinestatic

        {   // return reference to right pointer in node
        return (_Tree_val<_Val_types>::_Right(_Pnode));
        }

template<class _Traits>

void _Tree_comp_alloc< _Traits >::_Swap_all ( _Myt &  _Right )

inline

        {   // swap all iterators
        _Get_data()._Swap_all(_Right._Get_data());
        }

Member Data Documentation

template<class _Traits>

_Compressed_pair<key_compare, _Compressed_pair<_Alty, _Tree_val<_Val_types> > > _Tree_comp_alloc< _Traits >::_Mypair

private

---

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

• VS2017/inc/xtree