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

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

Public Types
typedef vector_impl< _Value_t, _Is_ref >	_Mytype_t
typedef _STLCLR IVector< _Value_t >	_Mycont_it
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 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
	vector_impl ()
vector_impl	operator= (vector_impl%_Right)
	vector_impl (_Mytype_t%_Right)
	vector_impl (size_type _Count)
	vector_impl (size_type _Count, value_type _Val)
template<typename _InIt_t >
	vector_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%)
	vector_impl (_Myenum_it^_Right)
	~vector_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)
reference	front ()
reference	back ()
_Myarray_t	to_array ()
iterator	make_iterator (size_type _Bias)
iterator	begin ()
iterator	end ()
reverse_iterator	rbegin ()
reverse_iterator	rend ()
void	reserve (size_type _Capacity)
size_type	capacity ()
virtual void	resize (size_type _Newsize)
void	resize (size_type _Newsize, value_type _Val)
size_type	size ()
bool	empty ()
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)
template<typename _InIt_t >
void	_Insert_self (size_type _Where, _InIt_t _First, _InIt_t _Last)
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)
	return (_Capacity)
size_type	_Copy (_Myarray_t^_Source, size_type _First, size_type _Last, size_type _Dest)
void	_Copyback (size_type _First, size_type _Last, size_type _Dest)
size_type	_Fill_n (size_type _First, size_type _Count, value_type _Val)
size_type	_Insert_space (size_type _Where, size_type _Count)
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__: size_type _Buy(size_type _Capacity) { _Mygen = 0
_Myarray_t	_Myarray
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::vector_impl< _Value_t, _Is_ref >::_Myarray_t

template<typename _Value_t, bool _Is_ref>

typedef _STLCLR IVector<_Value_t> cliext::impl::vector_impl< _Value_t, _Is_ref >::_Mycont_it

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

Constructor & Destructor Documentation

template<typename _Value_t, bool _Is_ref>

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

inline

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

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // construct by copying _Right
        for (size_type _Idx = _Buy(_Right.size()); 0 <= --_Idx; )
            _Myarray[_Idx] = _Mymake_t::make_value(_Right.at(_Idx));
        _Mysize = _Right.size();
        }

template<typename _Value_t, bool _Is_ref>

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

inlineexplicit

        {   // construct from _Count * value_type()
        _Mysize = _Fill_n(0, _Buy(_Count), value_type());
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // construct from _Count * _Val
        _Mysize = _Fill_n(0, _Buy(_Count), _Val);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

cliext::impl::vector_impl< _Value_t, _Is_ref >::vector_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::vector_impl< _Value_t, _Is_ref >::vector_impl ( _Myenum_it^  _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::vector_impl< _Value_t, _Is_ref >::~vector_impl ( )

inline

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

Member Function Documentation

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

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

inline

        {   // initialize with _Count * _Val
        _Mysize = _Fill_n(0, _Buy((size_type)_Count), (value_type)_Val);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

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

inline

        {   // initialize with [_First, _Last), input iterators
        _Buy(_First != _Last ? 1 : 0);  // buy at least one if non-empty
        for (; _First != _Last; ++_First)
            insert_n(size(), 1, (value_type)*_First);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

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

        _Buy(_Size);
        for (size_type _Idx = 0; _Idx < _Size; ++_Idx, ++_First)
            _Myarray[_Idx] = _Mymake_t::make_value(value_type(*_First));
        _Mysize = _Size;
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::vector_impl< _Value_t, _Is_ref >::_Copy ( _Myarray_t^  _Source, size_type  _First, size_type  _Last, size_type  _Dest  )

inline

        {   // copy [_First, _Last) in _Source to _Dest
        for (; _First != _Last; ++_First, ++_Dest)
            _Myarray[_Dest] = _Source[_First];
        return (_Dest);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::vector_impl< _Value_t, _Is_ref >::_Copyback ( size_type  _First, size_type  _Last, size_type  _Dest  )

inline

        {   // copy [_First, _Last) to [..., _Dest)
        for (; _First != _Last; )
            _Myarray[--_Dest] = _Myarray[--_Last];
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::vector_impl< _Value_t, _Is_ref >::_Fill_n ( size_type  _First, size_type  _Count, value_type  _Val  )

inline

        {   // copy initializing _Count * _Val
        for (; 0 < _Count; --_Count, ++_First)
            _Myarray[_First] = _Mymake_t::make_value(_Val);
        return (_First);
        }

template<typename _Value_t, bool _Is_ref>

template<typename _InIt_t >

void cliext::impl::vector_impl< _Value_t, _Is_ref >::_Insert_self ( size_type  _Where, _InIt_t  _First, _InIt_t  _Last  )

inline

        {   // insert [_First, _Last] at _Where, from this container
        size_type _Oldsize = size();

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

        for (; _First != _Last; ++_First)
            insert_n(size(), 1, (value_type)*_First);
        reverse_n(_Where, _Oldsize);
        reverse_n(_Oldsize, size());
        reverse_n(_Where, size());
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::vector_impl< _Value_t, _Is_ref >::_Insert_space ( size_type  _Where, size_type  _Count  )

inline

        {   // dig a hole for _Count elements at _Where
        size_type _Capacity = capacity();

        if (_Where < 0 || size() < _Where
            || _Count < 0 || _Maxsize - size() < _Count)
            throw gcnew System::ArgumentOutOfRangeException();
        else if (_Capacity < size() + _Count)
            {   // not enough room, reallocate
            _Myarray_t^ _Oldarray = _Myarray;

            _Capacity = _Maxsize - _Capacity < _Capacity
                ? 0 : 2 * _Capacity;    // try to double capacity
            if (_Capacity < size() + _Count)
                _Capacity = size() + _Count;
            _Myarray = gcnew _Myarray_t(_Capacity);

            _Copy(_Oldarray, 0, _Where, 0);
            _Mysize = _Copy(_Oldarray, _Where, _Mysize, _Where + _Count);
            }
        else if (size() - _Where < _Count)
            _Mysize = _Copy(_Myarray, _Where, size(),
                _Where + _Count);   // new stuff spills off end
        else
            {   // new stuff can all be assigned
            size_type _Oldend = size();

            _Mysize = _Copy(_Myarray, _Oldend - _Count, _Oldend, _Oldend);
            _Copyback(_Where, _Oldend - _Count, _Oldend);
            }
        return (_Where);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // assign _Count * _Val
        clear();
        insert_n(0, _Count, _Val);
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::vector_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())
            insert_n(size(),
                1, (value_type)_First->get_cref()); // append new stuff
        erase_n(0, _Oldsize);   // erase any leftover old stuff
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

        for each (value_type _Val in _Right)
            insert_n(size(), 1, _Val);  // append new stuff
        erase_n(0, _Oldsize);   // erase any leftover old stuff
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::vector_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)
            insert_n(size(), 1, _Val);  // append new stuff
        erase_n(0, _Oldsize);   // erase any leftover old stuff
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // subscript mutable sequence with checking
        if (_Pos < 0 || size() <= _Pos)
            throw gcnew System::ArgumentOutOfRangeException();

        return (_Myarray[_Pos]);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // subscript mutable sequence with checking, biased
        return (at(_Bias));
        }

template<typename _Value_t, bool _Is_ref>

reference cliext::impl::vector_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::vector_impl< _Value_t, _Is_ref >::begin ( )

inline

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

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::vector_impl< _Value_t, _Is_ref >::capacity ( )

inline

        {   // return current length of allocated storage
        return (_Myarray == nullptr ? 0 : _Myarray->Length);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // erase all
        erase_n(0, size());
        }

template<typename _Value_t, bool _Is_ref>

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

inlinevirtual

Reimplemented in cliext::vector< _Value_t >.

        {   // clone the vector
        return (gcnew vector_impl(*this));
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::vector_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::vector_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::vector_impl< _Value_t, _Is_ref >::erase_n ( size_type  _First, size_type  _Last  )

inline

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

        if (_First != _Last)
            {   // worth doing, copy down over hole
            for (size_type _Next = _First; _Next != _Last; ++_Next)
                _Mymake_t::unmake_value(at(_Next));

            _Mysize = _Copy(_Myarray, _Last, size(), _First);
            ++_Mygen;
            }
        return (_First);
        }

template<typename _Value_t, bool _Is_ref>

reference cliext::impl::vector_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::vector_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::vector_impl< _Value_t, _Is_ref >::get_generation ( )

inline

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

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::vector_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::vector_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::vector_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);
        size_type _Oldsize = size();

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

        for (; !_First->equal_to(_Last); _First->next())
            insert_n(size(), 1, (value_type)_First->get_cref());
        reverse_n(_Where, _Oldsize);
        reverse_n(_Oldsize, size());
        reverse_n(_Where, size());
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

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

        for each (value_type _Val in _Right)
            insert_n(size(), 1, _Val);
        reverse_n(_Where, _Oldsize);
        reverse_n(_Oldsize, size());
        reverse_n(_Where, size());
        }

template<typename _Value_t, bool _Is_ref>

void cliext::impl::vector_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);
        size_type _Oldsize = size();

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

        for each (value_type _Val in _Right)
            insert_n(size(), 1, _Val);
        reverse_n(_Where, _Oldsize);
        reverse_n(_Oldsize, size());
        reverse_n(_Where, size());
        }

template<typename _Value_t, bool _Is_ref>

size_type cliext::impl::vector_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)
            throw gcnew System::ArgumentOutOfRangeException();

        if (_Count == 0)
            return (_Where);
        else
            {   // insert finite sequence
            _Insert_space(_Where, _Count);
            _Fill_n(_Where, _Count, _Val);
            ++_Mygen;
            return (_Where + _Count - 1);
            }
        }

template<typename _Value_t, bool _Is_ref>

iterator cliext::impl::vector_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>

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

inline

        {   // assign
        if ((Object^)this != %_Right)
            {   // worth doing, do it
            clear();
            reserve(_Right.size());

            for (size_type _Idx = 0; _Idx < _Right.size(); ++_Idx)
                insert_n(size(), 1, _Right.at(_Idx));
            }
        return (*this);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // erase element at end
        erase_n(size() - 1, size());    // discard from end
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // insert element at end
        insert_n(size(), 1, _Val);
        }

template<typename _Value_t, bool _Is_ref>

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

void cliext::impl::vector_impl< _Value_t, _Is_ref >::reserve ( size_type  _Capacity )

inline

        {   // determine new minimum length of allocated storage
        if (_Capacity < 0)
            throw gcnew System::ArgumentOutOfRangeException();

        if (capacity() < _Capacity)
            {   // not enough room, reallocate
            _Myarray_t^ _Oldarray = _Myarray;

            _Myarray = gcnew _Myarray_t(_Capacity);
            for (size_type _Idx = size(); 0 <= --_Idx; )
                _Myarray[_Idx] = _Oldarray[_Idx];
            }
        }

template<typename _Value_t, bool _Is_ref>

virtual void cliext::impl::vector_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::vector_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_n(size(), _Newsize - size(), _Val);
        else if (_Newsize < size())
            erase_n(_Newsize, size());
        }

template<typename _Value_t, bool _Is_ref>

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

(

_Capacity

)

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // reverse a subrange
        bool _Changed = false;

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

            _Myarray[_First] = _Myarray[_Last];
            _Myarray[_Last] = _Temp;
            _Changed = true;
            }
        if (_Changed)
            ++_Mygen;
        }

template<typename _Value_t, bool _Is_ref>

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

inline

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

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // exchange contents with _Right
        if ((Object^)this != %_Right)
            {   // worth doing, swap
            _Myarray_t^ _Tarray = _Myarray;
            size_type _Tsize = _Mysize;

            _Myarray = _Right._Myarray;
            _Right._Myarray = _Tarray;

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

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

template<typename _Value_t, bool _Is_ref>

_Myarray_t cliext::impl::vector_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(_Myarray[_Idx]);
        return (_Ans);
        }

template<typename _Value_t, bool _Is_ref>

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

inline

        {   // test if _Bias is currently a valid bias
        return (0 <= _Bias && _Bias <= size());
        }

Member Data Documentation

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

static

template<typename _Value_t, bool _Is_ref>

_Myarray_t cliext::impl::vector_impl< _Value_t, _Is_ref >::_Myarray

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

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

template<typename _Value_t, bool _Is_ref>

property value_type cliext::impl::vector_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::vector_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::vector_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::vector_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::vector_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::vector_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/vector