Concurrency::details::_Dynamic_array< _Type > Class Template Reference

#include <agents.h>

Public Types
typedef _Dynamic_array< _Type >	_Myt
typedef _Type &	reference
typedef _Type const &	const_reference

Public Member Functions
	_Dynamic_array ()
	~_Dynamic_array ()
_Myt &	operator= (const _Myt &_Right)
void	_Clear ()
void	_Push_back (_Type const &_Element)
reference	operator[] (size_t _Pos)
const_reference	operator[] (size_t _Pos) const
size_t	_Size () const
void	_Swap (_Myt &_Right)

Private Member Functions
void	_Init ()
void	_Grow (size_t _NewSize)

Private Attributes
_Type *	_M_array
size_t	_M_index
size_t	_M_size

Static Private Attributes
static const int	_S_growthFactor = 2

Member Typedef Documentation

template<class _Type>

typedef _Dynamic_array<_Type> Concurrency::details::_Dynamic_array< _Type >::_Myt

template<class _Type>

typedef _Type const& Concurrency::details::_Dynamic_array< _Type >::const_reference

template<class _Type>

typedef _Type& Concurrency::details::_Dynamic_array< _Type >::reference

Constructor & Destructor Documentation

template<class _Type>

Concurrency::details::_Dynamic_array< _Type >::_Dynamic_array ( )

inline

        {
            _Init();
        }

template<class _Type>

Concurrency::details::_Dynamic_array< _Type >::~_Dynamic_array ( )

inline

        {
            _Clear();
        }

Member Function Documentation

template<class _Type>

void Concurrency::details::_Dynamic_array< _Type >::_Clear ( )

inline

        {
            if (_M_array != NULL)
            {
                delete [] _M_array;
                _Init();
            }
        }

template<class _Type>

void Concurrency::details::_Dynamic_array< _Type >::_Grow ( size_t  _NewSize )

inlineprivate

        {
            _CONCRT_ASSERT( _NewSize > _M_size );

            _Type * _Array = new _Type[_NewSize];

            if (_M_array != NULL)
            {
                // Copy over the elememts
                for (size_t _I = 0; _I < _M_size; _I++)
                {
                    _Array[_I] = _M_array[_I];
                }

                delete [] _M_array;
            }

            _M_array = _Array;
            _M_size = _NewSize;
        }

template<class _Type>

void Concurrency::details::_Dynamic_array< _Type >::_Init ( )

inlineprivate

        {
            _M_array = NULL;
            _M_index = 0;
            _M_size = 0;
        }

template<class _Type>

void Concurrency::details::_Dynamic_array< _Type >::_Push_back ( _Type const &  _Element )

inline

        {
            if (_M_index >= _M_size)
            {
                // Not enough space. Grow the array
                size_t _NewSize = (_M_index + 1) * _S_growthFactor;
                _Grow(_NewSize);
            }

            _CONCRT_ASSERT(_M_index < _M_size);
            _M_array[_M_index] = _Element;
            _M_index++;
        }

template<class _Type>

size_t Concurrency::details::_Dynamic_array< _Type >::_Size ( ) const

inline

        {
            return _M_index;
        }

template<class _Type>

void Concurrency::details::_Dynamic_array< _Type >::_Swap ( _Myt &  _Right )

inline

        {
            if (this != &_Right)
            {
                // Swap the details.
                _Type * _Array = _M_array;
                size_t _Index = _M_index;
                size_t _Size = _M_size;

                _M_array = _Right._M_array;
                _M_index = _Right._M_index;
                _M_size = _Right._M_size;

                _Right._M_array = _Array;
                _Right._M_index = _Index;
                _Right._M_size = _Size;
            }
        }

template<class _Type>

_Myt& Concurrency::details::_Dynamic_array< _Type >::operator= ( const _Myt &  _Right )

inline

        {
            if (this != &_Right)
            {
                // Remove all the elements
                _Clear();

                // Allocate space for the new elements
                size_t _Size = _Right._Size();
                _Grow(_Size);

                // Copy over the new elements
                for (size_t _I=0; _I < _Size; _I++)
                {
                    _Push_back(_Right[_I]);
                }
            }

            return *this;
        }

template<class _Type>

reference Concurrency::details::_Dynamic_array< _Type >::operator[] ( size_t  _Pos )

inline

        {
            _CONCRT_ASSERT(_Pos < _M_size);
            return _M_array[_Pos];
        }

template<class _Type>

const_reference Concurrency::details::_Dynamic_array< _Type >::operator[] ( size_t  _Pos ) const

inline

        {
            _CONCRT_ASSERT(_Pos < _M_size);
            return _M_array[_Pos];
        }

Member Data Documentation

template<class _Type>

_Type* Concurrency::details::_Dynamic_array< _Type >::_M_array

private

template<class _Type>

size_t Concurrency::details::_Dynamic_array< _Type >::_M_index

private

template<class _Type>

size_t Concurrency::details::_Dynamic_array< _Type >::_M_size

private

template<class _Type>

const int Concurrency::details::_Dynamic_array< _Type >::_S_growthFactor = 2

staticprivate

---

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

• VS2013/inc/agents.h