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

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

Public Types
typedef deque_impl< _Value_t, _Is_ref >	_Mytype_t
typedef _STLCLR IDeque< _Value_t >	_Mycont_it
typedef System::Collections::Generic::IEnumerable< _Value_t >	_Myenum_it
typedef cli::array< _Value_t >	_Myarray_t
typedef cli::array< _Myarray_t^>	_Mymap_t
typedef _Cont_make_value< _Value_t, _Is_ref >	_Mymake_t
typedef RandomAccessIterator< _Mytype_t >	iterator
typedef ConstRandomAccessIterator< _Mytype_t >	const_iterator
typedef ReverseRandomAccessIterator< _Mytype_t >	reverse_iterator
typedef ReverseRandomAccessIterator< _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::ContainerRandomAccessIterator< _Value_t >	generic_iterator
typedef _STLCLR Generic::ReverseRandomAccessIterator< _Value_t >	generic_reverse_iterator

Public Member Functions
	deque_impl ()
	deque_impl (_Mytype_t%_Right)
	deque_impl (size_type _Count)
	deque_impl (size_type _Count, value_type _Val)
template<typename _InIt_t >
	deque_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, forward_iterator_tag)
	deque_impl (System::Collections::Generic::IEnumerable< _Value_t >^_Right)
	~deque_impl ()
unsigned long	get_generation ()
size_type	get_bias (iterator _Where)
bool	valid_bias (size_type _Bias)
reference	at (size_type _Pos)
reference	at_bias (size_type _Bias)
int	begin_bias ()
int	end_bias ()
reference	front ()
reference	back ()
_Myarray_t	to_array ()
iterator	make_iterator (size_type _Bias)
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, System::Collections::Generic::IEnumerable< _Value_t >^_Right)
void	insert (iterator _Where_iter, System::Collections::IEnumerable^_Right)
size_type	insert_n (size_type _Where, size_type _Count, value_type _Val)
iterator	erase (iterator _Where)
iterator	erase (iterator _First, iterator _Last)
size_type	erase_n (size_type _First, size_type _Last)
void	reverse_n (size_type _First, size_type _Last)
void	clear ()
void	swap (_Mytype_t%_Right)
deque_impl	operator= (deque_impl%_Right)
	for (;_Dequesize< _Capacity &&_Maxsize-_Dequesize< _Dequesize;_Mapsize<<=1, _Dequesize<<=1)
void	_Growmap ()
virtual System::Object	Clone ()

Public Attributes
property value_type	default [size_type]
property value_type	front_item
property value_type	back_item
_STLCLR_FIELD_ACCESS	__pad0__: void _Buy(size_type _Capacity) { size_type _Valsize = _Get_sizeof<value_type>::value()
	_Blockshift
	_Mymap = nullptr
	_Mybias = 0
	_Mysize = 0
	_Mygen = 0
if(_Capacity< 0) throw gcnew System size_type	_Mapsize = 1 << _Mapshift
size_type	_Dequesize = _Mapsize << _Blockshift
_Mymap_t	_Mymap
int	_Blockshift
int	_Mybias
size_type	_Mysize
unsigned long	_Mygen

Static Public Attributes
static const int	_Maxsize = MAX_CONTAINER_SIZE
static const int	_Mapshift = 5

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::deque_impl< _Value_t, _Is_ref >::_Myarray_t

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR IDeque<_Value_t> cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mycont_it

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

typedef cli::array<_Myarray_t^> cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mymap_t

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

typedef ConstRandomAccessIterator<_Mytype_t> cliext::impl::deque_impl< _Value_t, _Is_ref >::const_iterator

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

typedef ReverseRandomAccessIterator<_Mytype_t> cliext::impl::deque_impl< _Value_t, _Is_ref >::const_reverse_iterator

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR Generic::ContainerRandomAccessIterator<_Value_t> cliext::impl::deque_impl< _Value_t, _Is_ref >::generic_iterator

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR Generic::ReverseRandomAccessIterator<_Value_t> cliext::impl::deque_impl< _Value_t, _Is_ref >::generic_reverse_iterator

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

typedef RandomAccessIterator<_Mytype_t> cliext::impl::deque_impl< _Value_t, _Is_ref >::iterator

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

typedef ReverseRandomAccessIterator<_Mytype_t> cliext::impl::deque_impl< _Value_t, _Is_ref >::reverse_iterator

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

Constructor & Destructor Documentation

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // construct empty deque
        _Buy(0);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // construct by copying _Right
        size_type _Count = _Right.size();
        size_type _Idx = 0;

        for (_Buy(_Count); _Idx < _Count; ++_Idx)
            push_back(_Right.at(_Idx));
        }

template<typename _Value_t, bool _Is_ref>

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

inlineexplicit

        {   // construct from _Count * value_type()
        for (_Buy(_Count); 0 < _Count; --_Count)
            push_back(value_type());
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // construct from _Count * _Val
        for (_Buy(_Count); 0 < _Count; --_Count)
            push_back(_Val);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

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

inline

        {   // construct from [_First, _Last)
        _Construct(_First, _Last, _Iter_category(_First));
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::deque_impl< _Value_t, _Is_ref >::deque_impl ( System::Collections::Generic::IEnumerable< _Value_t >^  _Right )

inline

        {   // initialize with enumeration
        _Buy(0);
        for each (value_type _Val in _Right)
            push_back(_Val);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

Member Function Documentation

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

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

inline

        {   // initialize with _Count * _Val
        if (_Count < 0)
            throw gcnew System::ArgumentOutOfRangeException();
        for (_Buy((size_type)_Count); 0 < _Count; --_Count)
            push_back((value_type)_Val);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

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

inline

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

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

void cliext::impl::deque_impl< _Value_t, _Is_ref >::_Construct ( _InIt_t  _First, _InIt_t  _Last, forward_iterator_tag    )

inline

        {   // initialize with [_First, _Last), forward iterators
        size_type _Size = cliext::distance(_First, _Last);

        if (_Size < 0)
            throw gcnew System::ArgumentOutOfRangeException();
        for (_Buy(_Size); 0 < _Size; --_Size, ++_First)
            push_back((value_type)*_First);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::deque_impl< _Value_t, _Is_ref >::_Growmap ( )

inline

        {   // grow map by doubling its size
        if (_Maxsize - (_Mymap->Length << _Blockshift)
            < (_Mymap->Length << _Blockshift))  // can't double map size
            throw gcnew System::ArgumentOutOfRangeException();

        _Mymap_t^ _Newmap = gcnew _Mymap_t(2 * _Mymap->Length);
        size_type _Count = _Mymap->Length;
        size_type _Block = _Mybias >> _Blockshift;

        for (; 0 < _Count; --_Count, ++_Block)
            _Newmap[_Block % _Newmap->Length] =
                _Mymap[_Block % _Mymap->Length];
        _Mymap = _Newmap;
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // assign _Count * _Val
        if (_Count < 0)
            throw gcnew System::ArgumentOutOfRangeException();
        clear();
        for (; 0 < _Count; --_Count)
            push_back(_Val);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // initialize with [_First, _Last), input iterators
        if (_Iter_container(_First) != this)
            clear();

        size_type _Oldsize = size();

        for (; !_First->equal_to(_Last); _First->next())
            push_back((value_type)_First->get_cref());  // append new stuff
        for (; 0 < _Oldsize; --_Oldsize)
            pop_front();    // erase any leftover old stuff
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // initialize with enumeration
        size_type _Oldsize = size();

        for each (value_type _Val in _Right)
            push_back(_Val);    // append new stuff
        for (; 0 < _Oldsize; --_Oldsize)
            pop_front();    // erase any leftover old stuff
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // initialize with enumeration
        size_type _Oldsize = size();

        for each (value_type _Val in _Right)
            push_back(_Val);    // append new stuff
        for (; 0 < _Oldsize; --_Oldsize)
            pop_front();    // erase any leftover old stuff
        }

template<typename _Value_t, bool _Is_ref>

reference cliext::impl::deque_impl< _Value_t, _Is_ref >::at ( size_type  _Pos )

inline

        {   // subscript mutable sequence with checking
        return (at_bias(begin_bias() + _Pos));
        }

template<typename _Value_t, bool _Is_ref>

reference cliext::impl::deque_impl< _Value_t, _Is_ref >::at_bias ( size_type  _Bias )

inline

        {   // subscript mutable sequence with checking, biased
        if ((unsigned int)size() <= (unsigned int)_Bias - begin_bias())
            throw gcnew System::ArgumentOutOfRangeException();

        int _Blocksize = 1 << _Blockshift;

        _Bias &= (_Mymap->Length << _Blockshift) - 1;
        return (_Mymap[_Bias >> _Blockshift][_Bias & (_Blocksize - 1)]);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // get last element of mutable sequence
        if (empty())
            throw gcnew System::NullReferenceException();
        return (at(size() - 1));
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

template<typename _Value_t, bool _Is_ref>

int cliext::impl::deque_impl< _Value_t, _Is_ref >::begin_bias ( )

inline

        {   // get bias of beginning of current sequence
        return (_Mybias);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // erase all
        for (; !empty(); )
            pop_back();
        }

template<typename _Value_t, bool _Is_ref>

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

inlinevirtual

Reimplemented in cliext::deque< _Value_t >.

        {   // clone the deque
        return (gcnew deque_impl(*this));
        }

template<typename _Value_t, bool _Is_ref>

bool cliext::impl::deque_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::deque_impl< _Value_t, _Is_ref >::end ( )

inline

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

template<typename _Value_t, bool _Is_ref>

int cliext::impl::deque_impl< _Value_t, _Is_ref >::end_bias ( )

inline

        {   // get bias of end of current sequence
        return (begin_bias() + size());
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // erase element at _Where
        size_type _Bias = get_bias(_Where);

        return (make_iterator(erase_n(_Bias, _Bias + 1)));
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // erase [_First, _Last)
        return (make_iterator(
            erase_n(get_bias(_First), get_bias(_Last))));
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::deque_impl< _Value_t, _Is_ref >::erase_n ( size_type  _First, size_type  _Last  )

inline

        {   // erase [_First, _Last)
        if (!valid_bias(_First)
            || !valid_bias(_Last)
            || _Last < _First)
            throw gcnew System::InvalidOperationException();

        if (_First == _Last)
            return (_First);
        else if (_First - begin_bias() < end_bias() - _Last)
            {   // erase finite sequence closer to front
            size_type _Count = _First - begin_bias();
            size_type _Stride = _Last - _First;

            for (_First = _Last - 1; 0 < _Count; --_Count, --_First)
                at_bias(_First) = at_bias(_First - _Stride);    // copy up
            for (; 0 < _Stride; --_Stride)
                pop_front();
            return (_Last);
            }
        else
            {   // erase finite sequence closer to back
            size_type _Count = end_bias() - _Last;
            size_type _Stride = _Last - _First;

            for (; 0 < _Count; --_Count, ++_Last)
                at_bias(_Last - _Stride) = at_bias(_Last);  // copy down
            for (; 0 < _Stride; --_Stride)
                pop_back();
            return (_First);
            }
        }

template<typename _Value_t, bool _Is_ref>

cliext::impl::deque_impl< _Value_t, _Is_ref >::for

(

)

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // get first element of mutable sequence
        if (empty())
            throw gcnew System::NullReferenceException();
        return (at(0));
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::deque_impl< _Value_t, _Is_ref >::get_bias ( iterator  _Where )

inline

        {   // get offset from valid iterator
        if (_Where.container() != this)
            throw gcnew System::ArgumentException();
        return (_Where.get_bias());
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // insert _Val at _Where
        return (make_iterator(
            insert_n(get_bias(_Where), 1, _Val)));
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // insert _Count * _Val at _Where
        insert_n(get_bias(_Where), _Count, _Val);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::deque_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
        size_type _Where = get_bias(_Where_iter);

        if (!valid_bias(_Where))
            throw gcnew System::InvalidOperationException();

        if (_First->equal_to(_Last))
            ;
        else if (_Where - begin_bias() < end_bias() - _Where)
            {   // add elements near beginning
            size_type _Oldfirst = begin_bias();

            for (; !_First->equal_to(_Last); _First->next())
                push_front((value_type)_First->get_cref()); // prepend flipped

            if (_Oldfirst != _Where)
                {   // insert not at beginning, flip new stuff into place
                reverse_n(_Oldfirst, _Where);
                reverse_n(begin_bias(), _Where);
                }
            else
                reverse_n(begin_bias(), _Oldfirst); // flip new stuff in place
            }
        else
            {   // add elements near end
            size_type _Oldlast = end_bias();

            for (; !_First->equal_to(_Last); _First->next())
                push_back((value_type)_First->get_cref());  // append
            if (_Oldlast != _Where)
                {   // insert not at end, flip new stuff into place
                reverse_n(_Where, _Oldlast);
                reverse_n(_Oldlast, end_bias());
                reverse_n(_Where, end_bias());
                }
            }
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // insert enumeration at _Where, possibly from this container
        size_type _Where = get_bias(_Where_iter);

        if (!valid_bias(_Where))
            throw gcnew System::InvalidOperationException();

        if (_Where - begin_bias() < end_bias() - _Where)
            {   // add elements near beginning
            size_type _Oldfirst = begin_bias();

            for each (value_type _Val in _Right)
                push_front(_Val);   // flipped
            if (_Oldfirst != _Where)
                {   // insert not at beginning, flip new stuff into place
                reverse_n(_Oldfirst, _Where);
                reverse_n(begin_bias(), _Where);
                }
            else
                reverse_n(begin_bias(), _Oldfirst); // flip new stuff in place
            }
        else
            {   // add elements near end
            size_type _Oldlast = end_bias();

            for each (value_type _Val in _Right)
                push_back(_Val);    // not flipped
            if (_Oldlast != _Where)
                {   // insert not at end, flip new stuff into place
                reverse_n(_Where, _Oldlast);
                reverse_n(_Oldlast, end_bias());
                reverse_n(_Where, end_bias());
                }
            }
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // insert enumeration at _Where, possibly from this container
        size_type _Where = get_bias(_Where_iter);

        if (!valid_bias(_Where))
            throw gcnew System::InvalidOperationException();

        if (_Where - begin_bias() < end_bias() - _Where)
            {   // add elements near beginning
            size_type _Oldfirst = begin_bias();

            for each (value_type _Val in _Right)
                push_front(_Val);   // flipped
            if (_Oldfirst != _Where)
                {   // insert not at beginning, flip new stuff into place
                reverse_n(_Oldfirst, _Where);
                reverse_n(begin_bias(), _Where);
                }
            else
                reverse_n(begin_bias(), _Oldfirst); // flip new stuff in place
            }
        else
            {   // add elements near end
            size_type _Oldlast = end_bias();

            for each (value_type _Val in _Right)
                push_back(_Val);    // not flipped
            if (_Oldlast != _Where)
                {   // insert not at end, flip new stuff into place
                reverse_n(_Where, _Oldlast);
                reverse_n(_Oldlast, end_bias());
                reverse_n(_Where, end_bias());
                }
            }
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::deque_impl< _Value_t, _Is_ref >::insert_n ( size_type  _Where, size_type  _Count, value_type  _Val  )

inline

        {   // insert _Count * _Val at _Where
        if (_Count < 0 || !valid_bias(_Where))
            throw gcnew System::ArgumentOutOfRangeException();

        if (_Count == 0)
            return (_Where);
        else if (_Where - begin_bias() < end_bias() - _Where)
            {   // add elements near beginning
            size_type _Oldfirst = begin_bias();

            for (; 0 < _Count; --_Count)
                push_front(_Val);
            if (_Oldfirst != _Where)
                {   // insert not at beginning, flip new stuff into place
                reverse_n(_Oldfirst, _Where);
                reverse_n(begin_bias(), _Where);
                }
            return (_Where - 1);
            }
        else
            {   // add elements near end
            size_type _Oldlast = end_bias();
            size_type _Ans = _Where + _Count - 1;

            for (; 0 < _Count; --_Count)
                push_back(_Val);
            if (_Oldlast != _Where)
                {   // insert not at end, flip new stuff into place
                reverse_n(_Where, _Oldlast);
                reverse_n(_Where, end_bias());
                }
            return (_Ans);
            }
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::deque_impl< _Value_t, _Is_ref >::make_iterator ( size_type  _Bias )

inline

        {   // return iterator for offset
        return (iterator(this, _Bias));
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // assign
        if ((Object^)this != %_Right)
            {   // worth assigning, do it
            clear();
            for (size_type _Idx = 0; _Idx < _Right.size(); ++_Idx)
                push_back(_Right.at(_Idx));
            }
        return (*this);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // erase element at end
        if (empty())
            throw gcnew System::InvalidOperationException();

        _Mymake_t::unmake_value(back());
        --_Mysize;
        ++_Mygen;
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // erase element at beginning
        if (empty())
            throw gcnew System::InvalidOperationException();

        _Mymake_t::unmake_value(front());
        ++_Mybias;
        --_Mysize;
        ++_Mygen;
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // insert element at end
        int _Blocksize = 1 << _Blockshift;

        if (((_Mybias + _Mysize) & (_Blocksize - 1)) == 0
            && _Mymap->Length <= (_Mysize + _Blocksize) / _Blocksize)
            _Growmap(); // starting new block and no spare block

        size_type _Newoff = (_Mybias + _Mysize)
            & ((_Mymap->Length << _Blockshift) - 1);
        size_type _Block = _Newoff >> _Blockshift;

        if (_Mymap[_Block] == nullptr)
            _Mymap[_Block] = gcnew _Myarray_t(_Blocksize);
        _Mymap[_Block][_Newoff & (_Blocksize - 1)] =
            _Mymake_t::make_value(_Val);
        ++_Mysize;
        ++_Mygen;
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // insert element at beginning
        int _Blocksize = 1 << _Blockshift;

        if ((_Mybias & (_Blocksize - 1)) == 0
            && _Mymap->Length <= (_Mysize + _Blocksize) / _Blocksize)
            _Growmap(); // starting new block and no spare block
        --_Mybias;

        size_type _Newoff = _Mybias
            & ((_Mymap->Length << _Blockshift) - 1);
        size_type _Block = _Newoff >> _Blockshift;

        if (_Mymap[_Block] == nullptr)
            _Mymap[_Block] = gcnew _Myarray_t(_Blocksize);
        _Mymap[_Block][_Newoff & (_Blocksize - 1)] =
            _Mymake_t::make_value(_Val);
        ++_Mysize;
        ++_Mygen;
        }

template<typename _Value_t, bool _Is_ref>

reverse_iterator cliext::impl::deque_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>

reverse_iterator cliext::impl::deque_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::deque_impl< _Value_t, _Is_ref >::resize ( size_type  _Newsize )

inlinevirtual

Reimplemented in cliext::impl::deque_select< _Value_t, true >.

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

template<typename _Value_t, bool _Is_ref>

void cliext::impl::deque_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();

        difference_type _Count = _Newsize - size();

        for (; 0 < _Count; --_Count)
            push_back(_Val);
        for (; _Count < 0; ++_Count)
            pop_back();
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::deque_impl< _Value_t, _Is_ref >::reverse_n ( size_type  _First, size_type  _Last  )

inline

        {   // reverse a subrange
        if (!valid_bias(_First)
            || !valid_bias(_Last)
            || _Last < _First)
            throw gcnew System::InvalidOperationException();

        for (; _First != _Last && _First != --_Last; ++_First)
            {   // swap distinct _First and _Last
            value_type _Temp = at_bias(_First);

            at_bias(_First) = at_bias(_Last);
            at_bias(_Last) = _Temp;
            }
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // exchange contents with _Right
        if ((Object^)this != %_Right)
            {   // worth doing, swap
            _Mymap_t^ _Tmap = _Mymap;
            size_type _Tbias = _Mybias;
            size_type _Tsize = _Mysize;

            _Mymap = _Right._Mymap;
            _Right._Mymap = _Tmap;

            _Mybias = _Right._Mybias;
            _Right._Mybias = _Tbias;

            _Mysize = _Right._Mysize;
            _Right._Mysize = _Tsize;

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

template<typename _Value_t, bool _Is_ref>

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

inline

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

        for (int _Idx = size(); 0 <= --_Idx; )
            _Ans[_Idx] = _Mymake_t::make_value(at(_Idx));
        return (_Ans);
        }

template<typename _Value_t, bool _Is_ref>

bool cliext::impl::deque_impl< _Value_t, _Is_ref >::valid_bias ( size_type  _Bias )

inline

        {   // test if _Bias is currently a valid bias
        return ((unsigned int)_Bias - begin_bias()
            <= (unsigned int)size());   // unsigned to handle bias wraparound
        }

Member Data Documentation

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

cliext::impl::deque_impl< _Value_t, _Is_ref >::_Blockshift

Initial value:

= _Valsize <= 1 ? 6
            : _Valsize <= 2 ? 5
            : _Valsize <= 4 ? 4
            : _Valsize <= 8 ? 3
            : _Valsize <= 16 ? 2
            : _Valsize <= 32 ? 1
            : 0

template<typename _Value_t, bool _Is_ref>

int cliext::impl::deque_impl< _Value_t, _Is_ref >::_Blockshift

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::deque_impl< _Value_t, _Is_ref >::_Dequesize = _Mapsize << _Blockshift

template<typename _Value_t, bool _Is_ref>

const int cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mapshift = 5

static

template<typename _Value_t, bool _Is_ref>

if (_Capacity < 0) throw gcnew System size_type cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mapsize = 1 << _Mapshift

template<typename _Value_t, bool _Is_ref>

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

static

template<typename _Value_t, bool _Is_ref>

cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mybias = 0

template<typename _Value_t, bool _Is_ref>

int cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mybias

template<typename _Value_t, bool _Is_ref>

cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mygen = 0

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mymap = nullptr

template<typename _Value_t, bool _Is_ref>

_Mymap_t cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mymap

template<typename _Value_t, bool _Is_ref>

cliext::impl::deque_impl< _Value_t, _Is_ref >::_Mysize = 0

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

Initial value:

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

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

template<typename _Value_t, bool _Is_ref>

property size_type cliext::impl::deque_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::deque_impl< _Value_t, _Is_ref >::default[size_type]

Initial value:

{   
        virtual value_type get(size_type _Pos)
            {   
            return (at(_Pos));
            }

        virtual void set(size_type _Pos, value_type _Val)
            {   
            at(_Pos) = _Val;
            }
        }

template<typename _Value_t, bool _Is_ref>

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

Initial value:

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

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

template<typename _Value_t, bool _Is_ref>

property bool cliext::impl::deque_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::deque_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:

• VS2013/inc/cliext/deque