cliext::impl::list_impl< _Value_t, _Is_ref > Class Template Reference

Inheritance diagram for cliext::impl::list_impl< _Value_t, _Is_ref >:

Public Types
typedef list_impl< _Value_t, _Is_ref >	_Mytype_t
typedef _STLCLR IList< _Value_t >	_Mycont_it
typedef list_node< _Value_t >	_Mynode_t
typedef cli::array< _Value_t >	_Myarray_t
typedef System::Collections::Generic::IEnumerable< _Value_t >	_Myenum_it
typedef _Cont_make_value< _Value_t, _Is_ref >	_Mymake_t
typedef list_node< _Value_t >	node_type
typedef BidirectionalIterator< _Mytype_t >	iterator
typedef ConstBidirectionalIterator< _Mytype_t >	const_iterator
typedef ReverseBidirectionalIterator< _Mytype_t >	reverse_iterator
typedef ReverseBidirectionalIterator< _Mytype_t >	const_reverse_iterator
typedef int	size_type
typedef int	difference_type
typedef _Value_t	value_type
typedef value_type	reference
typedef value_type	const_reference
typedef _Mycont_it	generic_container
typedef value_type	generic_value
typedef _STLCLR Generic::ContainerBidirectionalIterator< _Value_t >	generic_iterator
typedef _STLCLR Generic::ReverseBidirectionalIterator< _Value_t >	generic_reverse_iterator
typedef _STLCLR BinaryDelegate< value_type, value_type, bool >	_Valcomp_dt
typedef _STLCLR UnaryDelegate< value_type, bool >	_Valtest_dt

Public Member Functions
	list_impl ()
list_impl	operator= (list_impl%_Right)
	list_impl (_Mytype_t%_Right)
	list_impl (size_type _Count)
	list_impl (size_type _Count, value_type _Val)
template<typename _InIt_t >
	list_impl (_InIt_t _First, _InIt_t _Last)
template<typename _InIt_t >
void	_Construct (_InIt_t _Count, _InIt_t _Val, _Int_iterator_tag%)
template<typename _InIt_t >
void	_Construct (_InIt_t _First, _InIt_t _Last, input_iterator_tag%)
template<typename _InIt_t >
void	_Construct (_InIt_t _First, _InIt_t _Last, random_access_iterator_tag%)
	list_impl (_Myenum_it^_Right)
	~list_impl ()
unsigned long	get_generation ()
node_type	get_node (iterator _Where)
node_type	front_node ()
node_type	back_node ()
node_type	head_node ()
reference	front ()
reference	back ()
_Myarray_t	to_array ()
iterator	make_iterator (node_type^_Node)
iterator	begin ()
iterator	end ()
reverse_iterator	rbegin ()
reverse_iterator	rend ()
virtual void	resize (size_type _Newsize)
void	resize (size_type _Newsize, value_type _Val)
size_type	size ()
bool	empty ()
void	push_front (value_type _Val)
void	pop_front ()
void	push_back (value_type _Val)
void	pop_back ()
void	assign (size_type _Count, value_type _Val)
void	assign (_STLCLR Generic::IInputIterator< _Value_t >^_First, _STLCLR Generic::IInputIterator< _Value_t >^_Last)
void	assign (_Myenum_it^_Right)
void	assign (System::Collections::IEnumerable^_Right)
iterator	insert (iterator _Where, value_type _Val)
void	insert (iterator _Where, size_type _Count, value_type _Val)
void	insert (iterator _Where_iter, _STLCLR Generic::IInputIterator< _Value_t >^_First, _STLCLR Generic::IInputIterator< _Value_t >^_Last)
void	insert (iterator _Where_iter, _Myenum_it^_Right)
void	insert (iterator _Where_iter, System::Collections::IEnumerable^_Right)
void	_Insert_safe (_Mynode_t^_Where, _STLCLR Generic::IInputIterator< _Value_t >^_First, _STLCLR Generic::IInputIterator< _Value_t >^_Last)
template<typename _InIt_t >
void	_Insert_safe (_Mynode_t^_Where, _InIt_t _First, _InIt_t _Last)
void	insert_node (node_type^_Where, size_type _Count, value_type _Val)
node_type	insert_node (node_type^_Where, node_type^_First, node_type^_Last)
iterator	erase (iterator _Where)
iterator	erase (iterator _First, iterator _Last)
node_type	erase_node (node_type^_Where)
iterator	erase_node (node_type^_First, node_type^_Last)
void	clear ()
void	swap (_Mytype_t%_Right)
void	splice (iterator _Where, _Mytype_t%_Right)
void	splice (iterator _Where, _Mytype_t%_Right, iterator _First)
void	splice (iterator _Where, _Mytype_t%_Right, iterator _First, iterator _Last)
void	splice_node (node_type^_Where, _Mytype_t^_Right, node_type^_First, node_type^_Last)
size_type	unsplice_node (_Mytype_t^_Left, node_type^_First, node_type^_Last)
void	remove (value_type _Val)
void	remove_if (_Valtest_dt^_Pred)
template<typename _Pr1_t >
void	remove_if (_Pr1_t _Pred)
void	unique ()
void	unique (_Valcomp_dt^_Pred)
template<typename _Pr2_t >
void	unique (_Pr2_t _Pred)
template<typename _Pr2_t >
void	_Unique (_Pr2_t _Pred)
void	merge (_Mytype_t%_Right)
void	merge (_Mytype_t%_Right, _Valcomp_dt^_Pred)
template<typename _Pr3_t >
void	merge (_Mytype_t%_Right, _Pr3_t _Pred)
template<typename _Pr3_t >
void	_Merge (_Mytype_t%_Right, _Pr3_t _Pred)
void	sort ()
void	sort (_Valcomp_dt^_Pred)
template<typename _Pr3_t >
void	sort (_Pr3_t _Pred)
template<typename _Pr3_t >
void	_Sort (_Pr3_t _Pred)
void	reverse ()
	return (_Node)
node_type	_Buynode (node_type^_Next, node_type^_Prev, value_type _Val)
virtual System::Object	Clone ()

Public Attributes
property value_type	front_item
property value_type	back_item
_STLCLR_FIELD_ACCESS	__pad0__: node_type^ _Buynode() { node_type^ _Node = gcnew node_type(this)
_Node	_Head = _Node
_Node	_Next = _Node
_Node	_Prev = _Node
node_type	_Myhead
size_type	_Mysize
unsigned long	_Mygen

Static Public Attributes
static const int	_Maxsize = MAX_CONTAINER_SIZE

Private Attributes
property size_type	Count
property bool	IsSynchronized
property System::Object	SyncRoot

Member Typedef Documentation

template<typename _Value_t, bool _Is_ref>

typedef cli::array<_Value_t> cliext::impl::list_impl< _Value_t, _Is_ref >::_Myarray_t

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR IList<_Value_t> cliext::impl::list_impl< _Value_t, _Is_ref >::_Mycont_it

template<typename _Value_t, bool _Is_ref>

typedef System::Collections::Generic::IEnumerable<_Value_t> cliext::impl::list_impl< _Value_t, _Is_ref >::_Myenum_it

template<typename _Value_t, bool _Is_ref>

typedef _Cont_make_value<_Value_t, _Is_ref> cliext::impl::list_impl< _Value_t, _Is_ref >::_Mymake_t

template<typename _Value_t, bool _Is_ref>

typedef list_node<_Value_t> cliext::impl::list_impl< _Value_t, _Is_ref >::_Mynode_t

template<typename _Value_t, bool _Is_ref>

typedef list_impl<_Value_t, _Is_ref> cliext::impl::list_impl< _Value_t, _Is_ref >::_Mytype_t

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR BinaryDelegate<value_type, value_type, bool> cliext::impl::list_impl< _Value_t, _Is_ref >::_Valcomp_dt

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR UnaryDelegate<value_type, bool> cliext::impl::list_impl< _Value_t, _Is_ref >::_Valtest_dt

template<typename _Value_t, bool _Is_ref>

typedef ConstBidirectionalIterator<_Mytype_t> cliext::impl::list_impl< _Value_t, _Is_ref >::const_iterator

template<typename _Value_t, bool _Is_ref>

typedef value_type cliext::impl::list_impl< _Value_t, _Is_ref >::const_reference

template<typename _Value_t, bool _Is_ref>

typedef ReverseBidirectionalIterator<_Mytype_t> cliext::impl::list_impl< _Value_t, _Is_ref >::const_reverse_iterator

template<typename _Value_t, bool _Is_ref>

typedef int cliext::impl::list_impl< _Value_t, _Is_ref >::difference_type

template<typename _Value_t, bool _Is_ref>

typedef _Mycont_it cliext::impl::list_impl< _Value_t, _Is_ref >::generic_container

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR Generic::ContainerBidirectionalIterator<_Value_t> cliext::impl::list_impl< _Value_t, _Is_ref >::generic_iterator

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR Generic::ReverseBidirectionalIterator<_Value_t> cliext::impl::list_impl< _Value_t, _Is_ref >::generic_reverse_iterator

template<typename _Value_t, bool _Is_ref>

typedef value_type cliext::impl::list_impl< _Value_t, _Is_ref >::generic_value

template<typename _Value_t, bool _Is_ref>

typedef BidirectionalIterator<_Mytype_t> cliext::impl::list_impl< _Value_t, _Is_ref >::iterator

template<typename _Value_t, bool _Is_ref>

typedef list_node<_Value_t> cliext::impl::list_impl< _Value_t, _Is_ref >::node_type

template<typename _Value_t, bool _Is_ref>

typedef value_type cliext::impl::list_impl< _Value_t, _Is_ref >::reference

template<typename _Value_t, bool _Is_ref>

typedef ReverseBidirectionalIterator<_Mytype_t> cliext::impl::list_impl< _Value_t, _Is_ref >::reverse_iterator

template<typename _Value_t, bool _Is_ref>

typedef int cliext::impl::list_impl< _Value_t, _Is_ref >::size_type

template<typename _Value_t, bool _Is_ref>

typedef _Value_t cliext::impl::list_impl< _Value_t, _Is_ref >::value_type

Constructor & Destructor Documentation

template<typename _Value_t, bool _Is_ref>

cliext::impl::list_impl< _Value_t, _Is_ref >::list_impl ( )

inline

        :   _Mysize(0), _Mygen(0)
        {   // construct empty list
        _Myhead = _Buynode();
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::list_impl< _Value_t, _Is_ref >::list_impl ( _Mytype_t%  _Right )

inline

        :   _Mysize(0), _Mygen(0)
        {   // construct by copying _Right
        _Myhead = _Buynode();
        insert_node(head_node(), _Right.front_node(), _Right.head_node());
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::list_impl< _Value_t, _Is_ref >::list_impl ( size_type  _Count )

inlineexplicit

        :   _Mysize(0), _Mygen(0)
        {   // construct from _Count * value_type()
        _Myhead = _Buynode();
        insert_node(head_node(), _Count, value_type());
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::list_impl< _Value_t, _Is_ref >::list_impl ( size_type  _Count, value_type  _Val  )

inline

        :   _Mysize(0), _Mygen(0)
        {   // construct from _Count * _Val
        _Myhead = _Buynode();
        insert_node(head_node(), _Count, _Val);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

cliext::impl::list_impl< _Value_t, _Is_ref >::list_impl ( _InIt_t  _First, _InIt_t  _Last  )

inline

        :   _Mysize(0), _Mygen(0)
        {   // construct from [_First, _Last)
        _Myhead = _Buynode();
        _Construct(_First, _Last, _Iter_category(_First));
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::list_impl< _Value_t, _Is_ref >::list_impl ( _Myenum_it^  _Right )

inline

        :   _Mysize(0), _Mygen(0)
        {   // initialize with enumeration
        _Myhead = _Buynode();
        for each (value_type _Val in _Right)
            push_back(_Val);
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::list_impl< _Value_t, _Is_ref >::~list_impl ( )

inline

        {   // destroy the object
        clear();
        _Myhead = nullptr;
        _Mysize = 0;
        ++_Mygen;
        }

Member Function Documentation

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::_Buynode ( node_type^  _Next, node_type^  _Prev, value_type  _Val  )

inline

        {   // allocate a node and set links
        node_type^ _Node = gcnew node_type(nullptr);

        _Node->_Head = _Myhead;
        _Node->_Next = _Next;
        _Node->_Prev = _Prev;
        _Node->_Myval = _Mymake_t::make_value(_Val);
        return (_Node);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Construct ( _InIt_t  _Count, _InIt_t  _Val, _Int_iterator_tag%    )

inline

        {   // initialize with _Count * _Val
        insert_node(head_node(), (size_type)_Count, (value_type)_Val);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Construct ( _InIt_t  _First, _InIt_t  _Last, input_iterator_tag%    )

inline

        {   // initialize with [_First, _Last), input iterators
        for (; _First != _Last; ++_First)
            push_back((value_type)*_First);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Construct ( _InIt_t  _First, _InIt_t  _Last, random_access_iterator_tag%    )

inline

        {   // initialize with [_First, _Last), random-access iterators
        if (_Last < _First)
            throw gcnew System::ArgumentOutOfRangeException();
        for (; _First != _Last; ++_First)
            push_back((value_type)*_First);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Insert_safe ( _Mynode_t^  _Where, _STLCLR Generic::IInputIterator< _Value_t >^  _First, _STLCLR Generic::IInputIterator< _Value_t >^  _Last  )

inline

        {   // insert [_First, _Last] at _Where, possibly from this container
        node_type^ _Oldfirst = front_node();

        try
            {   // try to build insert list
            for (; !_First->equal_to(_Last); _First->next())
                insert_node(_Oldfirst,
                    1, (value_type)_First->get_cref()); // insert at beginning
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; front_node() != _Oldfirst; )
                pop_front();
            throw;
            }
        splice_node(_Where, this,
            front_node(), _Oldfirst);   // splice new into place
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Insert_safe ( _Mynode_t^  _Where, _InIt_t  _First, _InIt_t  _Last  )

inline

        {   // insert [_First, _Last] at _Where, possibly from this container
        node_type^ _Oldfirst = front_node();

        try
            {   // try to build insert list
            for (; _First != _Last; ++_First)
                insert_node(_Oldfirst,
                    1, (value_type)*_First);    // insert new at beginning
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; front_node() != _Oldfirst; )
                pop_front();
            throw;
            }
        splice_node(_Where, this,
            front_node(), _Oldfirst);   // splice new into place
        }

template<typename _Value_t, bool _Is_ref>

template<typename _Pr3_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Merge ( _Mytype_t%  _Right, _Pr3_t  _Pred  )

inline

        {   // merge in elements from _Right, both ordered by _Pred
        if ((Object^)this != %_Right)
            {   // safe to merge, do it
            node_type^ _First1 = front_node();
            node_type^ _First2 = _Right.front_node();

            for (; _First1 != head_node() && _First2 != _Right.head_node(); )
                if (_Pred(_First2->_Myval, _First1->_Myval))
                    {   // splice in an element from _Right
                    _First2 = _First2->next_node();
                    splice_node(_First1, %_Right,
                        _First2->prev_node(), _First2);
                    }
                else
                    _First1 = _First1->next_node();

            splice_node(head_node(), %_Right, _First2,
                _Right.head_node());
            }
        }

template<typename _Value_t, bool _Is_ref>

template<typename _Pr3_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Sort ( _Pr3_t  _Pred )

inline

        {   // order sequence, using _Pred
        if (2 <= size())
            {   // worth sorting, do it
            const size_type _Maxbins = 30;
            typedef cli::array<list_impl^> _Myarray_t;

            list_impl^ _Templist = gcnew list_impl;
            _Myarray_t^ _Binlist = gcnew _Myarray_t(_Maxbins);
            int _Maxbin = 0;
            int _Bin;
            for (; !empty(); )
                {   // sort another element, using bins
                _Templist->splice_node(_Templist->front_node(), this,
                    front_node(),
                    front_node()->next_node()); // pick an element
                for (_Bin = 0; _Bin < _Maxbin && !_Binlist[_Bin]->empty();
                    ++_Bin)
                    {   // merge into ever larger bins
                    _Binlist[_Bin]->merge(*_Templist, _Pred);
                    _Binlist[_Bin]->swap(*_Templist);
                    }
                if (_Bin == _Maxbins)
                    _Binlist[_Bin - 1]->merge(*_Templist, _Pred);
                else
                    {   // spill to empty or new bin, while they last
                    if (_Bin == _Maxbin)
                        {   // start a new bin
                        _Binlist[_Bin] = gcnew list_impl;
                        ++_Maxbin;
                        }
                    _Binlist[_Bin]->swap(*_Templist);
                    }
                }
            for (_Bin = 1; _Bin < _Maxbin; ++_Bin)
                _Binlist[_Bin]->merge(*_Binlist[_Bin - 1], _Pred);
            splice_node(head_node(), _Binlist[_Maxbin - 1],
                _Binlist[_Maxbin - 1]->front_node(),
                _Binlist[_Maxbin - 1]->head_node());
            }
        }

template<typename _Value_t, bool _Is_ref>

template<typename _Pr2_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::_Unique ( _Pr2_t  _Pred )

inline

        {   // erase each element satisfying _Pred with previous
        if (2 <= size())
            {   // worth doing, do it
            for (node_type^ _First = front_node();
                _First->next_node() != head_node(); )
                if (_Pred(_First->_Myval, _First->next_node()->_Myval))
                    erase_node(_First->next_node());
                else
                    _First = _First->next_node();
            }
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::assign ( size_type  _Count, value_type  _Val  )

inline

        {   // assign _Count * _Val
        clear();
        insert_node(head_node(), _Count, _Val);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::assign ( _STLCLR Generic::IInputIterator< _Value_t >^  _First, _STLCLR Generic::IInputIterator< _Value_t >^  _Last  )

inline

        {   // assign [_First, _Last)
        if (_First->container() != this)
            clear();

        size_type _Oldsize = size();

        _Insert_safe(front_node(), _First, _Last);
        for (; 0 < _Oldsize; --_Oldsize)
            pop_back(); // discard old stuff
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::assign ( _Myenum_it^  _Right )

inline

        {   // initialize with enumeration
        node_type^ _Oldfirst = front_node();

        try
            {   // try to build insert list
            for each (value_type _Val in _Right)
                insert_node(_Oldfirst,  // insert new at beginning
                    1, _Val);
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; front_node() != _Oldfirst; )
                pop_front();
            throw;
            }
        for (; _Oldfirst != head_node(); )
            _Oldfirst = erase_node(_Oldfirst);  // discard old stuff
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::assign ( System::Collections::IEnumerable^  _Right )

inline

        {   // initialize with enumeration
        node_type^ _Oldfirst = front_node();

        try
            {   // try to build insert list
            for each (value_type _Val in _Right)
                insert_node(_Oldfirst,  // insert new at beginning
                    1, _Val);
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; front_node() != _Oldfirst; )
                pop_front();
            throw;
            }
        for (; _Oldfirst != head_node(); )
            _Oldfirst = erase_node(_Oldfirst);  // discard old stuff
        }

template<typename _Value_t, bool _Is_ref>

reference cliext::impl::list_impl< _Value_t, _Is_ref >::back ( )

inline

        {   // get last element of mutable sequence
        if (empty())
            throw gcnew System::NullReferenceException();
        return (back_node()->_Myval);
        }

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::back_node ( )

inline

        {   // return rightmost node in tree
        return (head_node()->_Prev);    // avoid usual check
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::list_impl< _Value_t, _Is_ref >::begin ( )

inline

        {   // return iterator for beginning of mutable sequence
        return (make_iterator(front_node()));
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::clear ( )

inline

        {   // erase all
        for (; front_node() != head_node(); )
            erase_node(front_node());
        }

template<typename _Value_t, bool _Is_ref>

virtual System::Object cliext::impl::list_impl< _Value_t, _Is_ref >::Clone ( )

inlinevirtual

Reimplemented in cliext::list< _Value_t >.

        {   // clone the list
        return (gcnew list_impl(*this));
        }

template<typename _Value_t, bool _Is_ref>

bool cliext::impl::list_impl< _Value_t, _Is_ref >::empty ( )

inline

        {   // test if sequence is empty
        return (size() == 0);
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::list_impl< _Value_t, _Is_ref >::end ( )

inline

        {   // return iterator for end of mutable sequence
        return (make_iterator(head_node()));
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::list_impl< _Value_t, _Is_ref >::erase ( iterator  _Where )

inline

        {   // erase element at _Where
        node_type^ _Node = get_node(_Where);

        return (make_iterator(erase_node(_Node)));
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::list_impl< _Value_t, _Is_ref >::erase ( iterator  _First, iterator  _Last  )

inline

        {   // erase [_First, _Last)
        return (erase_node(get_node(_First), get_node(_Last)));
        }

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::erase_node ( node_type^  _Where )

inline

        {   // erase node at _Where
        if (_Where->container() != this || _Where->is_head())
            throw gcnew System::InvalidOperationException();

        _Mymake_t::unmake_value(_Where->_Myval);
        _Where->_Head = nullptr;    // orphan corresponding iterators
        _Where->_Prev->_Next = _Where->_Next;
        _Where = _Where->_Next;
        _Where->_Prev = _Where->_Prev->_Prev;
        --_Mysize;
        ++_Mygen;
        return (_Where);
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::list_impl< _Value_t, _Is_ref >::erase_node ( node_type^  _First, node_type^  _Last  )

inline

        {   // erase nodes in [_First, _Last)
        if (_First == nullptr || _First->container() != this)
            throw gcnew System::ArgumentException();

        for (; _First != _Last; )
            _First = erase_node(_First);
        return (make_iterator(_First));
        }

template<typename _Value_t, bool _Is_ref>

reference cliext::impl::list_impl< _Value_t, _Is_ref >::front ( )

inline

        {   // get first element of mutable sequence
        if (empty())
            throw gcnew System::NullReferenceException();
        return (front_node()->_Myval);
        }

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::front_node ( )

inline

        {   // return leftmost node in tree
        return (head_node()->_Next);    // avoid usual check
        }

template<typename _Value_t, bool _Is_ref>

unsigned long cliext::impl::list_impl< _Value_t, _Is_ref >::get_generation ( )

inline

        {   // get underlying container generation
        return (_Mygen);
        }

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::get_node ( iterator  _Where )

inline

        {   // get node from valid iterator
        node_type^ _Node = (node_type^)_Where.get_node();

        if (_Node->container() != (System::Object^)this)
            throw gcnew System::InvalidOperationException();
        return (_Node);
        }

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::head_node ( )

inline

        {   // get head node
        return (_Myhead);
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::list_impl< _Value_t, _Is_ref >::insert ( iterator  _Where, value_type  _Val  )

inline

        {   // insert _Val at _Where
        insert_node(get_node(_Where), 1, _Val);
        return (--_Where);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::insert ( iterator  _Where, size_type  _Count, value_type  _Val  )

inline

        {   // insert _Count * _Val at _Where
        insert_node(get_node(_Where), _Count, _Val);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::insert ( iterator  _Where_iter, _STLCLR Generic::IInputIterator< _Value_t >^  _First, _STLCLR Generic::IInputIterator< _Value_t >^  _Last  )

inline

        {   // insert [_First, _Last) at _Where, input iterators
        node_type^ _Where = get_node(_Where_iter);

        if (_First->container() == this)
            _Insert_safe(_Where, _First, _Last);
        else
            for (; !_First->equal_to(_Last); _First->next())
                insert_node(_Where, 1, (value_type)_First->get_cref());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::insert ( iterator  _Where_iter, _Myenum_it^  _Right  )

inline

        {   // insert enumeration at _Where, possibly from this container
        node_type^ _Where = get_node(_Where_iter);
        node_type^ _Oldfirst = front_node();

        try
            {   // try to build insert list
            for each (value_type _Val in _Right)
                insert_node(_Oldfirst,  // insert new at beginning
                    1, _Val);
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; front_node() != _Oldfirst; )
                pop_front();
            throw;
            }
        splice_node(_Where, this,
            front_node(), _Oldfirst);   // splice new into place
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::insert ( iterator  _Where_iter, System::Collections::IEnumerable^  _Right  )

inline

        {   // insert enumeration at _Where, possibly from this container
        node_type^ _Where = get_node(_Where_iter);
        node_type^ _Oldfirst = front_node();

        try
            {   // try to build insert list
            for each (value_type _Val in _Right)
                insert_node(_Oldfirst,  // insert new at beginning
                    1, _Val);
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; front_node() != _Oldfirst; )
                pop_front();
            throw;
            }
        splice_node(_Where, this,
            front_node(), _Oldfirst);   // splice new into place
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::insert_node ( node_type^  _Where, size_type  _Count, value_type  _Val  )

inline

        {   // insert _Count * _Val at _Where
        size_type _Added = 0;

        if ((System::Object^)_Where->container() != this)
            throw gcnew System::ArgumentException();

        if (_Count < 0 || _Maxsize - size() < _Count)
            throw gcnew System::ArgumentOutOfRangeException();
        try
            {   // try to insert _Count copies
            for (; _Added < _Count; ++_Added)
                {   // insert a node at _Where
                node_type^ _Node = _Buynode(_Where, _Where->_Prev, _Val);

                _Where->_Prev = _Node;
                _Node->_Prev->_Next = _Node;
                ++_Mysize;
                }
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; 0 < _Added; --_Added)
                erase_node(_Where->prev_node());
            }

        if (0 < _Added)
            ++_Mygen;
        }

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::insert_node ( node_type^  _Where, node_type^  _First, node_type^  _Last  )

inline

        {   // insert copy of list subrange
        size_type _Added = 0;

        if (_Where->container() != this)
            throw gcnew System::ArgumentException();

        try
            {   // try to insert _Count copies
            for (; _First != _Last; _First = _First->next_node(), ++_Added)
                insert_node(_Where, 1, _First->_Myval);
            }
        catch (System::Object^)
            {   // failed, discard new stuff
            for (; 0 < _Added; --_Added)
                erase_node(_Where->prev_node());
            }

        if (0 < _Added)
            ++_Mygen;
        return (_Where);
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::list_impl< _Value_t, _Is_ref >::make_iterator ( node_type^  _Node )

inline

        {   // return iterator for node
        return (iterator(_Node));
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::merge ( _Mytype_t%  _Right )

inline

        {   // merge in elements from _Right, both ordered by operator<
        _Merge(_Right, less<value_type>());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::merge ( _Mytype_t%  _Right, _Valcomp_dt^  _Pred  )

inline

        {   // merge in elements from _Right, both ordered by _Pred
        _Merge(_Right, _Pred);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _Pr3_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::merge ( _Mytype_t%  _Right, _Pr3_t  _Pred  )

inline

        {   // merge in elements from _Right, both ordered by _Pred
        _Merge(_Right, _Pred);
        }

template<typename _Value_t, bool _Is_ref>

list_impl cliext::impl::list_impl< _Value_t, _Is_ref >::operator= ( list_impl< _Value_t, _Is_ref >%  _Right )

inline

        {   // assign
        if ((Object^)this != %_Right)
            {   // worth doing, do it
            clear();
            insert_node(head_node(),
                _Right.front_node(), _Right.head_node());
            }
        return (*this);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::pop_back ( )

inline

        {   // erase element at end
        if (empty())
            throw gcnew System::InvalidOperationException();
        erase_node(back_node());    // discard from end
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::pop_front ( )

inline

        {   // erase element at beginning
        if (empty())
            throw gcnew System::InvalidOperationException();
        erase_node(front_node());   // discard from beginning
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::push_back ( value_type  _Val )

inline

        {   // insert element at end
        insert_node(head_node(), 1, _Val);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::push_front ( value_type  _Val )

inline

        {   // insert element at beginning
        insert_node(front_node(), 1, _Val);
        }

template<typename _Value_t, bool _Is_ref>

reverse_iterator cliext::impl::list_impl< _Value_t, _Is_ref >::rbegin ( )

inline

        {   // return reverse iterator for beginning of mutable sequence
        return (reverse_iterator(end()));
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::remove ( value_type  _Val )

inline

        {   // erase each element matching _Val
        for (node_type^ _First = front_node(); _First != head_node(); )
            {   // point past element and test it
            _First = _First->next_node();
            if (_First->prev_node()->_Myval == _Val)
                erase_node(_First->prev_node());
            }
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::remove_if ( _Valtest_dt^  _Pred )

inline

        {   // erase each element satisfying _Pred
        for (node_type^ _First = front_node(); _First != head_node(); )
            {   // point past element and test it
            _First = _First->next_node();
            if (_Pred(_First->prev_node()->_Myval))
                erase_node(_First->prev_node());
            }
        }

template<typename _Value_t, bool _Is_ref>

template<typename _Pr1_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::remove_if ( _Pr1_t  _Pred )

inline

        {   // erase each element satisfying _Pred
        for (node_type^ _First = front_node(); _First != head_node(); )
            {   // point past element and test it
            _First = _First->next_node();
            if (_Pred(_First->prev_node()->_Myval))
                erase_node(_First->prev_node());
            }
        }

template<typename _Value_t, bool _Is_ref>

reverse_iterator cliext::impl::list_impl< _Value_t, _Is_ref >::rend ( )

inline

        {   // return reverse iterator for end of mutable sequence
        return (reverse_iterator(begin()));
        }

template<typename _Value_t, bool _Is_ref>

virtual void cliext::impl::list_impl< _Value_t, _Is_ref >::resize ( size_type  _Newsize )

inlinevirtual

        {   // determine new length, padding with value_type elements
        resize(_Newsize, value_type());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::resize ( size_type  _Newsize, value_type  _Val  )

inline

        {   // determine new length, padding with _Val elements
        if (_Newsize < 0)
            throw gcnew System::ArgumentOutOfRangeException();

        if (size() < _Newsize)
            insert_node(head_node(), _Newsize - size(), _Val);
        else
            for (; _Newsize < size(); )
                pop_back(); // discard from end
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::list_impl< _Value_t, _Is_ref >::return

(

_Node

)

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::reverse ( )

inline

        {   // reverse sequence
        if (2 <= size())
            for (node_type^ _Node = front_node()->next_node();
                _Node != head_node(); )
                {   // move next element to beginning
                _Node = _Node->_Next;
                splice_node(front_node(), this, _Node->_Prev, _Node);
                }
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::list_impl< _Value_t, _Is_ref >::size ( )

inline

        {   // return length of sequence
        return (_Mysize);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::sort ( )

inline

        {   // order sequence, using operator<
        _Sort(less<value_type>());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::sort ( _Valcomp_dt^  _Pred )

inline

        {   // order sequence, using _Pred
        _Sort(_Pred);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _Pr3_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::sort ( _Pr3_t  _Pred )

inline

        {   // order sequence, using _Pred
        _Sort(_Pred);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::splice ( iterator  _Where, _Mytype_t%  _Right  )

inline

        {   // splice all of _Right at _Where
        splice_node(get_node(_Where), %_Right,
            _Right.front_node(), _Right.head_node());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::splice ( iterator  _Where, _Mytype_t%  _Right, iterator  _First  )

inline

        {   // splice _Right [_First, _First + 1) at _Where
        node_type^ _Node = _Right.get_node(_First);

        splice_node(get_node(_Where), %_Right,
            _Node, _Node->next_node());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::splice ( iterator  _Where, _Mytype_t%  _Right, iterator  _First, iterator  _Last  )

inline

        {   // splice _Right [_First, _First + 1) at _Where
        splice_node(get_node(_Where), %_Right,
            _Right.get_node(_First), _Right.get_node(_Last));
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::splice_node ( node_type^  _Where, _Mytype_t^  _Right, node_type^  _First, node_type^  _Last  )

inline

        {   // splice _Right [_First, _Last) before _Where
        if (_Where->container() != this
            || _First->container() != _Right)
            throw gcnew System::ArgumentException();

        if (_First == _Last)
            ;   // nothing to do
        else if ((Object^)this != _Right)
            {   // get sublist from another list
            node_type^ _Nlast = _Last->_Prev;

            _Mysize += _Right->unsplice_node(this, _First, _Last);
            _Nlast->_Next = _Where;
            _Where->_Prev->_Next = _First;
            _First->_Prev = _Where->_Prev;
            _Where->_Prev = _Nlast;
            ++_Mygen;
            }
        else if (_First != _Where && _Where != _Last)
            {   // worth splicing, do it
            node_type^ _Node = _Where->_Prev;

            _First->_Prev->_Next = _Last;
            _Last->_Prev->_Next = _Where;
            _Where->_Prev->_Next = _First;
            _Where->_Prev = _Last->_Prev;
            _Last->_Prev = _First->_Prev;
            _First->_Prev = _Node;
            ++_Mygen;
            }
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::swap ( _Mytype_t%  _Right )

inline

        {   // exchange contents with _Right
        if ((Object^)this != %_Right)
            {   // worth doing, swap
            node_type^ _Oldfirst = front_node();

            splice_node(_Oldfirst, %_Right,
                _Right.front_node(), _Right.head_node());
            _Right.splice_node(_Right.head_node(), this,
                _Oldfirst, head_node());

            ++_Mygen;
            ++_Right._Mygen;
            }
        }

template<typename _Value_t, bool _Is_ref>

_Myarray_t cliext::impl::list_impl< _Value_t, _Is_ref >::to_array ( )

inline

        {   // convert to array
        _Myarray_t^ _Ans = gcnew _Myarray_t(size());
        node_type^ _Node = head_node();

        for (int _Idx = size(); 0 <= --_Idx; )
            {   // copy back to front
            _Node = _Node->prev_node();
            _Ans[_Idx] = _Mymake_t::make_value(_Node->_Myval);
            }
        return (_Ans);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::unique ( )

inline

        {   // erase each element matching previous
        _Unique(equal_to<value_type>());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::list_impl< _Value_t, _Is_ref >::unique ( _Valcomp_dt^  _Pred )

inline

        {   // erase each element satisfying _Pred with previous
        _Unique(_Pred);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _Pr2_t >

void cliext::impl::list_impl< _Value_t, _Is_ref >::unique ( _Pr2_t  _Pred )

inline

        {   // erase each element satisfying _Pred with previous
        _Unique(_Pred);
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::list_impl< _Value_t, _Is_ref >::unsplice_node ( _Mytype_t^  _Left, node_type^  _First, node_type^  _Last  )

inline

        {   // unsplice [_First, _Last) to give to _Left
        if (_First->container() != this)
            throw gcnew System::InvalidOperationException();

        size_type _Count = 0;
        node_type^ _Node = _First;

        for (; _Node != _Last && !_Node->is_head();
            _Node = _Node->_Next, ++_Count)
            _Node->_Head = _Left->head_node();  // change ownership

        if (_Node != _Last || _Maxsize - _Left->size() < _Count)
            {   // invalid splice, back out
            for (; _First != _Node; _First = _First->_Next)
                _Node->_Head = _Myhead; // revert ownership

            if (_Node != _Last)
                throw gcnew System::InvalidOperationException();
            else
                throw gcnew System::ArgumentOutOfRangeException();
            }

        _First->_Prev->_Next = _Last;   // remove sublist
        _Last->_Prev = _First->_Prev;
        _Mysize -= _Count;
        ++_Mygen;
        return (_Count);
        }

Member Data Documentation

template<typename _Value_t, bool _Is_ref>

_STLCLR_FIELD_ACCESS cliext::impl::list_impl< _Value_t, _Is_ref >::__pad0__

template<typename _Value_t, bool _Is_ref>

_Node cliext::impl::list_impl< _Value_t, _Is_ref >::_Head = _Node

template<typename _Value_t, bool _Is_ref>

const int cliext::impl::list_impl< _Value_t, _Is_ref >::_Maxsize = MAX_CONTAINER_SIZE

static

template<typename _Value_t, bool _Is_ref>

unsigned long cliext::impl::list_impl< _Value_t, _Is_ref >::_Mygen

template<typename _Value_t, bool _Is_ref>

node_type cliext::impl::list_impl< _Value_t, _Is_ref >::_Myhead

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::list_impl< _Value_t, _Is_ref >::_Mysize

template<typename _Value_t, bool _Is_ref>

_Node cliext::impl::list_impl< _Value_t, _Is_ref >::_Next = _Node

template<typename _Value_t, bool _Is_ref>

_Node cliext::impl::list_impl< _Value_t, _Is_ref >::_Prev = _Node

template<typename _Value_t, bool _Is_ref>

property value_type cliext::impl::list_impl< _Value_t, _Is_ref >::back_item

Initial value:

{   
        virtual value_type get()
            {   
            return (back());
            }

        virtual void set(value_type _Val)
            {   
            back() = _Mymake_t::make_value(_Val);
            }
        }

template<typename _Value_t, bool _Is_ref>

property size_type cliext::impl::list_impl< _Value_t, _Is_ref >::Count

private

Initial value:

{   
        virtual size_type get() sealed
            = System::Collections::ICollection::Count::get
            {   
            return (size());
            }
        }

template<typename _Value_t, bool _Is_ref>

property value_type cliext::impl::list_impl< _Value_t, _Is_ref >::front_item

Initial value:

{   
        virtual value_type get()
            {   
            return (front());
            }

        virtual void set(value_type _Val)
            {   
            front() = _Mymake_t::make_value(_Val);
            }
        }

template<typename _Value_t, bool _Is_ref>

property bool cliext::impl::list_impl< _Value_t, _Is_ref >::IsSynchronized

private

Initial value:

{   
        virtual bool get() sealed
            = System::Collections::ICollection::IsSynchronized::get
            {   
            return (false);
            }
        }

template<typename _Value_t, bool _Is_ref>

property System::Object cliext::impl::list_impl< _Value_t, _Is_ref >::SyncRoot

private

Initial value:

{   
        virtual System::Object^ get() sealed
            = System::Collections::ICollection::SyncRoot::get
            {   
            return (this);
            }
        }

---

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

• VS2017/inc/cliext/list