Concurrency::details::_Vector_iterator< _Container, _Value > Class Template Reference

#include <concurrent_vector.h>

Public Types
typedef ptrdiff_t	difference_type
typedef _Value	value_type
typedef _Value *	pointer
typedef _Value &	reference
typedef std::random_access_iterator_tag	iterator_category

Public Member Functions
	_Vector_iterator ()
	_Vector_iterator (const _Vector_iterator< _Container, typename _Container::value_type > &_Other)
_Vector_iterator	operator+ (ptrdiff_t _Offset) const
_Vector_iterator &	operator+= (ptrdiff_t _Offset)
_Vector_iterator	operator- (ptrdiff_t _Offset) const
_Vector_iterator &	operator-= (ptrdiff_t _Offset)
_Value &	operator* () const
_Value &	operator[] (ptrdiff_t _K) const
_Value *	operator-> () const
_Vector_iterator &	operator++ ()
_Vector_iterator &	operator-- ()
_Vector_iterator	operator++ (int)
_Vector_iterator	operator-- (int)

Private Member Functions
	_Vector_iterator (const _Container &_Vec, size_t _Index, void *_Ptr=NULL)

Private Attributes
_Container *	_My_vector
size_t	_My_index
_Value *	_My_item

Friends
template<typename _C , typename _U >
class	::Concurrency::details::_Vector_iterator
template<typename _Ty , class _Ax >
class	::Concurrency::concurrent_vector
template<typename _C , typename _Ty >
_Vector_iterator< _C, _Ty >	operator+ (ptrdiff_t _Offset, const _Vector_iterator< _C, _Ty > &_Vec)
template<typename _C , typename _Ty , typename _U >
bool	operator== (const _Vector_iterator< _C, _Ty > &, const _Vector_iterator< _C, _U > &)
template<typename _C , typename _Ty , typename _U >
bool	operator< (const _Vector_iterator< _C, _Ty > &, const _Vector_iterator< _C, _U > &)
template<typename _C , typename _Ty , typename _U >
ptrdiff_t	operator- (const _Vector_iterator< _C, _Ty > &, const _Vector_iterator< _C, _U > &)

Detailed Description

template<typename _Container, typename _Value>
class Concurrency::details::_Vector_iterator< _Container, _Value >

_Value is either the _Ty or const _Ty type of the container.

Member Typedef Documentation

template<typename _Container, typename _Value>

typedef ptrdiff_t Concurrency::details::_Vector_iterator< _Container, _Value >::difference_type

template<typename _Container, typename _Value>

typedef std::random_access_iterator_tag Concurrency::details::_Vector_iterator< _Container, _Value >::iterator_category

template<typename _Container, typename _Value>

typedef _Value* Concurrency::details::_Vector_iterator< _Container, _Value >::pointer

template<typename _Container, typename _Value>

typedef _Value& Concurrency::details::_Vector_iterator< _Container, _Value >::reference

template<typename _Container, typename _Value>

typedef _Value Concurrency::details::_Vector_iterator< _Container, _Value >::value_type

Constructor & Destructor Documentation

template<typename _Container, typename _Value>

Concurrency::details::_Vector_iterator< _Container, _Value >::_Vector_iterator ( const _Container &  _Vec, size_t  _Index, void *  _Ptr = NULL  )

inlineprivate

            : _My_vector(const_cast<_Container*>(&_Vec)),
              _My_index(_Index),
              _My_item(static_cast<_Value*>(_Ptr))
        {
        }

template<typename _Container, typename _Value>

Concurrency::details::_Vector_iterator< _Container, _Value >::_Vector_iterator ( )

inline

            : _My_vector(NULL), _My_index(~size_t(0)), _My_item(NULL)
        {
        }

template<typename _Container, typename _Value>

Concurrency::details::_Vector_iterator< _Container, _Value >::_Vector_iterator ( const _Vector_iterator< _Container, typename _Container::value_type > &  _Other )

inline

            : _My_vector(_Other._My_vector),
              _My_index(_Other._My_index),
              _My_item(_Other._My_item)
        {
        }

Member Function Documentation

template<typename _Container, typename _Value>

_Value& Concurrency::details::_Vector_iterator< _Container, _Value >::operator* ( ) const

inline

        {
            _Value* _Item = _My_item;
            if( !_Item )
                _Item = _My_item = &_My_vector->_Internal_subscript(_My_index);
            _CONCRT_ASSERT( _Item==&_My_vector->_Internal_subscript(_My_index));  // corrupt cache
            return *_Item;
        }

template<typename _Container, typename _Value>

_Vector_iterator Concurrency::details::_Vector_iterator< _Container, _Value >::operator+ ( ptrdiff_t  _Offset ) const

inline

        {
            return _Vector_iterator( *_My_vector, _My_index+_Offset );
        }

template<typename _Container, typename _Value>

_Vector_iterator& Concurrency::details::_Vector_iterator< _Container, _Value >::operator++ ( )

inline

        {
            size_t _K = ++_My_index;
            if( _My_item )
            {
                // Following test uses 2's-complement wizardry.
                if( (_K& (_K-2))==0 )
                {
                    // _K is a power of two that is at least _K-2.
                    _My_item= NULL;
                }
                else
                {
                    ++_My_item;
                }
            }
            return *this;
        }

template<typename _Container, typename _Value>

_Vector_iterator Concurrency::details::_Vector_iterator< _Container, _Value >::operator++ ( int  )

inline

        {
            _Vector_iterator _Result = *this;
            operator++();
            return _Result;
        }

template<typename _Container, typename _Value>

_Vector_iterator& Concurrency::details::_Vector_iterator< _Container, _Value >::operator+= ( ptrdiff_t  _Offset )

inline

        {
            _My_index+=_Offset;
            _My_item = NULL;
            return *this;
        }

template<typename _Container, typename _Value>

_Vector_iterator Concurrency::details::_Vector_iterator< _Container, _Value >::operator- ( ptrdiff_t  _Offset ) const

inline

        {
            return _Vector_iterator( *_My_vector, _My_index-_Offset );
        }

template<typename _Container, typename _Value>

_Vector_iterator& Concurrency::details::_Vector_iterator< _Container, _Value >::operator-- ( )

inline

        {
            _CONCRT_ASSERT( _My_index>0 ); // operator--() applied to iterator already at beginning of concurrent_vector.
            size_t _K = _My_index--;
            if( _My_item )
            {
                // Following test uses 2's-complement wizardry.
                if( (_K& (_K-2))==0 )
                {
                    // k is a power of two that is at least k-2.
                    _My_item= NULL;
                }
                else
                {
                    --_My_item;
                }
            }
            return *this;
        }

template<typename _Container, typename _Value>

_Vector_iterator Concurrency::details::_Vector_iterator< _Container, _Value >::operator-- ( int  )

inline

        {
            _Vector_iterator _Result = *this;
            operator--();
            return _Result;
        }

template<typename _Container, typename _Value>

_Vector_iterator& Concurrency::details::_Vector_iterator< _Container, _Value >::operator-= ( ptrdiff_t  _Offset )

inline

        {
            _My_index-=_Offset;
            _My_item = NULL;
            return *this;
        }

template<typename _Container, typename _Value>

_Value* Concurrency::details::_Vector_iterator< _Container, _Value >::operator-> ( ) const

inline

        {
            return &operator*();
        }

template<typename _Container, typename _Value>

_Value& Concurrency::details::_Vector_iterator< _Container, _Value >::operator[] ( ptrdiff_t  _K ) const

inline

        {
            return _My_vector->_Internal_subscript(_My_index+_K);
        }

Friends And Related Function Documentation

template<typename _Container, typename _Value>

template<typename _Ty , class _Ax >

friend class ::Concurrency::concurrent_vector

friend

template<typename _Container, typename _Value>

template<typename _C , typename _U >

friend class ::Concurrency::details::_Vector_iterator

friend

template<typename _Container, typename _Value>

template<typename _C , typename _Ty >

_Vector_iterator<_C,_Ty> operator+ ( ptrdiff_t  _Offset, const _Vector_iterator< _C, _Ty > &  _Vec  )

friend

template<typename _Container, typename _Value>

template<typename _C , typename _Ty , typename _U >

ptrdiff_t operator- ( const _Vector_iterator< _C, _Ty > &  , const _Vector_iterator< _C, _U > &    )

friend

template<typename _Container, typename _Value>

template<typename _C , typename _Ty , typename _U >

bool operator< ( const _Vector_iterator< _C, _Ty > &  , const _Vector_iterator< _C, _U > &    )

friend

template<typename _Container, typename _Value>

template<typename _C , typename _Ty , typename _U >

bool operator== ( const _Vector_iterator< _C, _Ty > &  , const _Vector_iterator< _C, _U > &    )

friend

Member Data Documentation

template<typename _Container, typename _Value>

size_t Concurrency::details::_Vector_iterator< _Container, _Value >::_My_index

private

template<typename _Container, typename _Value>

_Value* Concurrency::details::_Vector_iterator< _Container, _Value >::_My_item

mutableprivate

NULL if cached value is not available

template<typename _Container, typename _Value>

_Container* Concurrency::details::_Vector_iterator< _Container, _Value >::_My_vector

private

---

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

• VS2013/inc/concurrent_vector.h