FvBufferAllocator.h

[詳解]

//  $Revision: 1.2 $
/*
    @file   FvBufferAllocator.h
    @brief  CFvBufferAllocator template class
    @author FAST Corporation
*/

#ifndef _FVBUFFERALLOCATOR_H_INCLUDED_
#define _FVBUFFERALLOCATOR_H_INCLUDED_

#include "fie.h"
#include "oal_aloc.h"
#include "FvMacros.h"
#include "FvDefs.h"
#include "FvDebug.h"
#include "FvErrors.h"
#include "FvObject.h"
#include "fvalg.api.h"
#include "MultiData/FvAllocator.h"

#pragma pack(push,_FVCL_PACKING)

namespace FVCL
{

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

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

// /////////////////////////////////////////////////////////////////
// CLASS
template<class TYPE> class CFvBufferAllocator : 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:
    // ===================================================================
    CFvBufferAllocator( size_type uiInitial, size_type uiIncrease ) : CFvAllocator<TYPE>( uiInitial, uiIncrease )
    {
        this->m_pTable = NULL;
        this->m_uiCount = 0;
        this->m_IsAttach = false;
        if( ! CFvBufferAllocator<TYPE>::Allocate() )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
    }

    // ===================================================================
    CFvBufferAllocator( size_type uiInitial, size_type uiIncrease, TYPE* adrs, size_type count ) : CFvAllocator<TYPE>( uiInitial, uiIncrease )
    {
        if( adrs == NULL && count != 0 )
            throw FVCL::CFveBadParamException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        this->m_pTable = adrs;
        this->m_uiCount = count;
        this->m_IsAttach = false;
    }

    // ===================================================================
    CFvBufferAllocator( size_type uiInitial, size_type uiIncrease, TYPE* adrs, size_type count, bool is_attach ) : CFvAllocator<TYPE>( uiInitial, uiIncrease )
    {
        if( adrs == NULL && count != 0 )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::INVALID_PARAMETER, __TFUNCTION__ );
        this->m_pTable = adrs;
        this->m_uiCount = count;
        this->m_IsAttach = is_attach;
    }

    // ===================================================================
    virtual ~CFvBufferAllocator()
    {
        CFvBufferAllocator<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 bool SetBuffer( pointer adrs, size_type count )
    {
        return SetBuffer(adrs, count, false);
    }

    // ===================================================================
    virtual bool SetBuffer( pointer adrs, size_type count, bool is_attach )
    {
        if( adrs == NULL && count != 0 ) return false;
        CFvBufferAllocator<TYPE>::Clear();
        this->m_pTable = adrs;
        this->m_uiCount = count;
        this->m_IsAttach = is_attach;
        return true;
    }

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

    // ===================================================================
    virtual void IsAttach( bool value )
    {
        this->m_IsAttach = value;
    }

    // ===================================================================
    virtual bool IsAttach() const
    {
        return this->m_IsAttach;
    }

    // ===================================================================
    virtual bool Allocate()
    {
        if( this->m_pTable != NULL )
        {
            CFvBufferAllocator<TYPE>::Clear();
        }
        if( this->m_uiInitial != 0 )
        {
            this->m_pTable = (TYPE*)fvalg::api::fnOAL_calloc( this->m_uiInitial, sizeof(TYPE) );
            if( this->m_pTable == NULL )
                return false;
        }
        this->m_uiCapacity = this->m_uiInitial;
        return true;
    }

    // ===================================================================
    virtual void Clear()
    {
        if( this->m_pTable != NULL && !this->m_IsAttach )
        {
            fvalg::api::fnOAL_free( this->m_pTable );
        }
        this->m_pTable = NULL;
        this->m_uiCount = 0;
        this->m_uiCapacity = 0;
        this->m_IsAttach = false;
    }

    // ===================================================================
    virtual void Reset()
    {
        if (this->m_pTable == NULL) return;

        for(UINT i=0 ; i<this->m_uiCount ; i++)
            memset(&this->m_pTable[i], 0, sizeof(TYPE));
    }

    // ===================================================================
    virtual bool Reserve( size_type uiIncrease )
    {
        if( this->m_pTable == NULL )
        {
            if( !Allocate() ) return false;
        }
        TYPE    *pNewTable;
        pNewTable = (TYPE*)fvalg::api::fnOAL_calloc( (this->m_uiCapacity + uiIncrease), sizeof(TYPE) );
        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;

        if (!this->m_IsAttach)
            fvalg::api::fnOAL_free( this->m_pTable );
        this->m_pTable = pNewTable;
        this->m_IsAttach = false;
        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 )
            CFvBufferAllocator<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( !CFvBufferAllocator<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 )
        {
            CFvBufferAllocator<TYPE>::Clear();
        }
        else if( uiSize < this->m_uiCount )
        {
            this->m_uiCount = uiSize;
        }
        else if( this->m_uiCount < uiSize )
        {
            if( this->m_uiCapacity < uiSize )
                if( !CFvBufferAllocator<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;
    bool                            m_IsAttach;
};

}   // FVCL

#pragma pack(pop)

#endif // _FVBUFFERALLOCATOR_H_INCLUDED_