FvIterator.h

[詳解]

//  $Revision: 1.1 $
/*
    @file   FvIterator.h
    @brief  CFvIterator template class
    @author FAST Corporation
*/

#ifndef _FVITERATOR_H_INCLUDED_
#define _FVITERATOR_H_INCLUDED_

#include "FvMacros.h"
#include "FvDefs.h"
#include "FvDebug.h"
#include "FvErrors.h"
#include "FvObject.h"
#include "FvException.h"

#include "FvAllocator.h"

#include <xutility>

#pragma pack(push,_FVCL_PACKING)

namespace FVCL
{

// /////////////////////////////////////////////////////////////////
// DEFINE
//

// /////////////////////////////////////////////////////////////////
// TYPEDEF
//

// /////////////////////////////////////////////////////////////////
// CLASS
//
template<class TYPE> class CFvIterator : public CFvObject
{
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef TYPE                            value_type;
    typedef INT                             difference_type;
    typedef UINT                            size_type;
    typedef TYPE*                           pointer;
    typedef const TYPE*                     const_pointer;
    typedef TYPE&                           reference;
    typedef const TYPE&                     const_reference;

protected:
    CFvAllocator<TYPE>*                 m_alloc;
    size_type                           m_uiIndex;

public:
    // ===================================================================
    CFvIterator( size_type uiIndex=0, CFvAllocator<TYPE>* pAllocator=NULL )
    {
        this->m_alloc = pAllocator;
        this->m_uiIndex = uiIndex;
    }

    // ===================================================================
    CFvIterator( const CFvIterator<TYPE>& object )
    {
        operator = (object);
    }

    // ===================================================================
    virtual ~CFvIterator()
    {
    }

public:
    //
    // METHOD
    //

    // ===================================================================
    CFvAllocator<TYPE>* GetAllocator() const
    {
        return this->m_alloc;
    }

    // ===================================================================
    size_type GetIndex() const
    {
        return this->m_uiIndex;
    }

public:
    // ===================================================================
    CFvIterator<TYPE>& operator = ( const CFvIterator<TYPE>& ope )
    {
        this->m_alloc       = ope.m_alloc;
        this->m_uiIndex = ope.m_uiIndex;
        return *this;
    }

    // ===================================================================
    bool operator == ( const CFvIterator<TYPE>& ope ) const
    {
        if( this->m_alloc   != ope.m_alloc ) return false;
        if( this->m_uiIndex != ope.m_uiIndex ) return false;
        return true;
    }

    // ===================================================================
    bool operator != ( const CFvIterator<TYPE>& ope ) const
    {
        return (operator == (ope)) ? false : true;
    }

    // ===================================================================
    CFvIterator<TYPE> operator + ( difference_type iCount ) const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        UINT    index = this->m_uiIndex + iCount;
        if( !(index<=this->m_alloc->GetCount()) )
            throw FVCL::CFveBadParamException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        return CFvIterator<TYPE>( (UINT)index, this->m_alloc );
    }

    // ===================================================================
    CFvIterator<TYPE> operator + ( size_type iCount ) const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        UINT    index = this->m_uiIndex + iCount;
        if( !(index<=this->m_alloc->GetCount()) )
            throw FVCL::CFveBadParamException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        return CFvIterator<TYPE>( index, this->m_alloc );
    }

    // ===================================================================
    CFvIterator<TYPE> operator - ( difference_type iCount ) const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        UINT    index = this->m_uiIndex - iCount;
        if( !(index<=this->m_alloc->GetCount()) )
            throw FVCL::CFveBadParamException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        return CFvIterator<TYPE>( index, this->m_alloc );
    }

    // ===================================================================
    CFvIterator<TYPE> operator - ( size_type iCount ) const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        UINT    index = this->m_uiIndex - iCount;
        if( !(index<=this->m_alloc->GetCount()) )
            throw FVCL::CFveBadParamException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        return CFvIterator<TYPE>( index, this->m_alloc );
    }

    // ===================================================================
    CFvIterator<TYPE>& operator ++ ()
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        if( !(this->m_uiIndex < this->m_alloc->GetCount()) )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        this->m_uiIndex++;
        return *this;
    }

    // ===================================================================
    CFvIterator<TYPE> operator ++ (INT)
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        if( !(this->m_uiIndex < this->m_alloc->GetCount()) )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        CFvIterator<TYPE>   iter( this->m_uiIndex, this->m_alloc );
        this->m_uiIndex++;
        return iter;
    }

    // ===================================================================
    CFvIterator<TYPE>& operator -- ()
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        if( this->m_alloc->GetCount() == 0 )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        if( this->m_uiIndex == 0 )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        this->m_uiIndex--;
        return *this;
    }

    // ===================================================================
    CFvIterator<TYPE> operator -- (INT)
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        if( this->m_alloc->GetCount() == 0 )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        if( this->m_uiIndex == 0 )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        CFvIterator<TYPE>   iter( this->m_uiIndex, this->m_alloc );
        this->m_uiIndex--;
        return iter;
    }

    // ===================================================================
    CFvIterator<TYPE>& operator += ( difference_type iSize )
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );

        UINT    iPos = this->m_uiIndex + iSize;
        if( !(iPos<=this->m_alloc->GetCount()) )
            throw FVCL::CFveBadParamException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );

        this->m_uiIndex = iPos;
        return *this;
    }

    // ===================================================================
    CFvIterator<TYPE>& operator -= ( difference_type iSize )
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );

        UINT    iPos = this->m_uiIndex - iSize;
        if( !(iPos<=this->m_alloc->GetCount()) )
            throw FVCL::CFveBadParamException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );

        this->m_uiIndex = iPos;
        return *this;
    }

    // ===================================================================
    reference operator []( difference_type index ) const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        if( index < 0 )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        return this->m_alloc->GetItem( index );
    }
    // ===================================================================
    reference operator *() const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        return this->m_alloc->GetItem( this->m_uiIndex );
    }
    // ===================================================================
    pointer operator ->() const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        return this->m_alloc->GetBuffer( this->m_uiIndex );
    }

    // ===================================================================
    operator TYPE*() const
    {
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::NOT_ALLOCATED, __TFUNCTION__ );
        return this->m_alloc->GetBuffer( this->m_uiIndex );
    }
};

}   // FVCL

#pragma pack(pop)

#endif // _FVITERATOR_H_INCLUDED_