FvArrayAllocator.h

[詳解]

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

#ifndef _FVARRAYALLOCATOR_H_INCLUDED_
#define _FVARRAYALLOCATOR_H_INCLUDED_

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

#include "FvAllocator.h"

#pragma pack(push,_FVCL_PACKING)

namespace FVCL
{

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

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

// /////////////////////////////////////////////////////////////////
// CLASS
template<class TYPE> class CFvArrayAllocator : public CFvAllocator<TYPE>
{
public:
    // DEFINE/TYPEDEF
    typedef TYPE*                           pointer;
    typedef const TYPE*                     const_pointer;
    typedef TYPE&                           reference;
    typedef const TYPE&                     const_reference;
    typedef UINT                            size_type;

public:
    // ===================================================================
    CFvArrayAllocator( size_type uiInitial, size_type uiIncrease ) : CFvAllocator<TYPE>( uiInitial, uiIncrease )
    {
        this->m_pTable = NULL;
        if( ! CFvArrayAllocator<TYPE>::Allocate() )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
    }

    // ===================================================================
    virtual ~CFvArrayAllocator()
    {
        CFvArrayAllocator<TYPE>::Clear();
    }

public:
    //
    // METHOD
    //

    // ===================================================================
    virtual reference SetItem( size_type uiIndex, const_reference _Val )
    {
        if( this->m_uiCount <= uiIndex )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        this->m_pTable[uiIndex] = _Val;
        return this->m_pTable[uiIndex];
    }

    // ===================================================================
    virtual reference GetItem( size_type uiIndex ) const
    {
        if( this->m_uiCount <= uiIndex )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        return this->m_pTable[uiIndex];
    }

    // ===================================================================
    virtual pointer GetBuffer( size_type uiIndex = 0 ) const
    {
        if( this->m_uiCount <= uiIndex )
            throw FVCL::CFveBadAccessException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        return &this->m_pTable[uiIndex];
    }

    // ===================================================================
    virtual bool Allocate()
    {
        if( this->m_pTable != NULL )
        {
            CFvArrayAllocator<TYPE>::Clear();
        }
        if( this->m_uiInitial != 0 )
        {
            this->m_pTable = new TYPE[this->m_uiInitial];
            if( this->m_pTable == NULL )
                return false;
        }
        this->m_uiCapacity = this->m_uiInitial;
        return true;
    }

    // ===================================================================
    virtual void Clear()
    {
        if( this->m_pTable != NULL )
        {
            delete [] this->m_pTable;
            this->m_pTable = NULL;
        }
        this->m_uiCount = 0;
        this->m_uiCapacity = 0;
    }

    // ===================================================================
    virtual bool Reserve( size_type uiIncrease )
    {
        if( this->m_pTable == NULL )
        {
            if( !Allocate() ) return false;
        }
        TYPE    *pNewTable;
        pNewTable = new TYPE[this->m_uiCapacity + uiIncrease];
        if( pNewTable == NULL ) return false;

        size_type       iCnt;
        for( iCnt=0 ; iCnt<this->m_uiCount ; iCnt++ )
            pNewTable[iCnt] = this->m_pTable[iCnt];

        this->m_uiCapacity += uiIncrease;

        delete [] this->m_pTable;
        this->m_pTable = pNewTable;
        return true;
    }

    // ===================================================================
    virtual bool Erase( size_type uiS, size_type uiE )
    {
        if( this->m_pTable == NULL ) return false;
        if( this->m_uiCount<=uiS ) return false;
        if( this->m_uiCount<=uiE ) uiE = this->m_uiCount-1;
        if( uiE < uiS ) return false;

        size_type   iCnt, jCnt;
        for( iCnt=uiS, jCnt=1 ; iCnt<this->m_uiCount ; iCnt++, jCnt++ )
        {
            size_type   uiP = uiE+jCnt;
            if( uiP < this->m_uiCount )
                this->m_pTable[iCnt] = this->m_pTable[uiP];
        }
        this->m_uiCount -= (uiE-uiS+1);
        return true;
    }

    // ===================================================================
    virtual bool Insert( size_type uiPos, size_type uiSize, const_reference _Val )
    {
        if( this->m_pTable == NULL ) return false;
        if( this->m_uiCount <= uiPos ) return false;
        if( uiSize == 0 ) uiSize = 1;
        if( this->m_uiCapacity < this->m_uiCount+uiSize )
            CFvArrayAllocator<TYPE>::Reserve( max(this->m_uiCount + uiSize - this->m_uiCapacity,this->m_uiIncrease) );

        size_type   uiLen = this->m_uiCount - uiPos;
        size_type   iCnt;
        for( iCnt=1 ; iCnt<=uiLen ; iCnt++ )
            this->m_pTable[this->m_uiCount+uiSize-iCnt] = this->m_pTable[this->m_uiCount-iCnt];
        for( iCnt=uiPos ; iCnt<uiPos+uiSize ; iCnt++ )
            this->m_pTable[iCnt] = _Val;
        this->m_uiCount += uiSize;
        return true;
    }

    // ===================================================================
    virtual bool PopBack()
    {
        if( this->m_pTable == NULL ) return false;
        if( this->m_uiCount == 0 ) return false;
        this->m_uiCount--;
        return true;
    }

    // ===================================================================
    virtual bool PushBack( const_reference _Val )
    {
        if( this->m_pTable == NULL )
        {
            if( !Allocate() ) return false;
        }
        if( this->m_uiCapacity <= this->m_uiCount )
            if( !CFvArrayAllocator<TYPE>::Reserve( this->m_uiIncrease ) )
                return false;
        this->m_pTable[this->m_uiCount] = _Val;
        this->m_uiCount++;
        return true;
    }

    // ===================================================================
    virtual bool Resize( size_type uiSize, const_pointer pVal=NULL )
    {
        if( this->m_pTable == NULL )
        {
            if( !Allocate() ) return false;
        }
        if( uiSize == 0 )
        {
            CFvArrayAllocator<TYPE>::Clear();
        }
        else if( uiSize < this->m_uiCount )
        {
            TYPE    *pNewTable = new TYPE[uiSize];
            if( pNewTable == NULL ) return false;

            for( size_type iCnt=0 ; iCnt<uiSize ; iCnt++ )
                pNewTable[iCnt] = this->m_pTable[iCnt];

            CFvArrayAllocator<TYPE>::Clear();
            this->m_pTable = pNewTable;
            this->m_uiCapacity = uiSize;
            this->m_uiCount = uiSize;
        }
        else if( this->m_uiCount < uiSize )
        {
            if( this->m_uiCapacity < uiSize )
                if( !CFvArrayAllocator<TYPE>::Reserve( max(uiSize - this->m_uiCapacity,this->m_uiIncrease) ) )
                    return false;
            if( pVal )
                for( size_type iCnt=this->m_uiCount ; iCnt<uiSize ; iCnt++ )
                    this->m_pTable[iCnt] = static_cast<const_reference>(*pVal);
            this->m_uiCount = uiSize;
        }
        return true;
    }

    // ===================================================================
    virtual bool ChangeOrder( size_type uiPos, INT order )
    {
        if( !(0 <= uiPos && uiPos < this->m_uiCount) )
            return false;

        INT     iPos1 = (INT)uiPos;
        INT     iPos2 = iPos1 + order;
        if( iPos2 < 0 )
            iPos2 = 0;
        if( iPos2 >= (INT)this->m_uiCount )
            iPos2 = (INT)this->m_uiCount - 1;

        INT         inc = (iPos1<iPos2) ? 1 : -1;
        TYPE        temp = this->m_pTable[iPos1];
        for( INT i=iPos1 ; i!=iPos2 ; i+=inc )
            this->m_pTable[i] = this->m_pTable[i+inc];
        this->m_pTable[iPos2] = temp;

        return true;
    }

    // ===================================================================
    virtual bool SwapItem( size_type uiPos1, size_type uiPos2 )
    {
        if( ! (uiPos1 < this->m_uiCount) ) return false;
        if( ! (uiPos2 < this->m_uiCount) ) return false;

        TYPE        temp = this->m_pTable[uiPos1];
        this->m_pTable[uiPos1] = this->m_pTable[uiPos2];
        this->m_pTable[uiPos2] = temp;

        return true;
    }

protected:
    // OBJECT
    pointer                         m_pTable;
};

}   // FVCL

#pragma pack(pop)

#endif // _FVARRAYALLOCATOR_H_INCLUDED_