FvBuffer.h

[詳解]

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

#ifndef _FVBUFFER_H_INCLUDED_
#define _FVBUFFER_H_INCLUDED_

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

#include "MultiData/FvMultiData.h"
#include "MultiData/FvBufferAllocator.h"

#pragma pack(push,_FVCL_PACKING)

namespace FVCL
{

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

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

// /////////////////////////////////////////////////////////////////
// CLASS
template<class TYPE> class CFvBuffer : public CFvMultiData<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:
    enum { DataID = 30 };
    enum
    {
        DefaultInitial = 0,
        DefaultIncrease = 256
    };

public:
    // ===================================================================
    CFvBuffer() : CFvMultiData<TYPE>()
    {
        size_type   uiInitial  = DefaultInitial;
        size_type   uiIncrease = DefaultIncrease;
        this->m_alloc = static_cast<CFvAllocator<TYPE>*>(new CFvBufferAllocator<TYPE>( uiInitial, uiIncrease ));
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
    }

    // ===================================================================
    CFvBuffer( size_type uiInitial ) : CFvMultiData<TYPE>()
    {
        size_type   uiIncrease = DefaultIncrease;
        this->m_alloc = static_cast<CFvAllocator<TYPE>*>(new CFvBufferAllocator<TYPE>( uiInitial, uiIncrease ));
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
    }

    // ===================================================================
    CFvBuffer( size_type uiInitial, size_type uiIncrease ) : CFvMultiData<TYPE>()
    {
        this->m_alloc = static_cast<CFvAllocator<TYPE>*>(new CFvBufferAllocator<TYPE>( uiInitial, uiIncrease ));
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
    }

    // ===================================================================
    CFvBuffer( TYPE* adrs, size_type count ) : CFvMultiData<TYPE>()
    {
        this->m_alloc = static_cast<CFvAllocator<TYPE>*>(new CFvBufferAllocator<TYPE>( DefaultInitial, DefaultIncrease, adrs, count ));
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
    }

    // ===================================================================
    CFvBuffer( TYPE* adrs, size_type count, bool is_attach ) : CFvMultiData<TYPE>()
    {
        this->m_alloc = static_cast<CFvAllocator<TYPE>*>(new CFvBufferAllocator<TYPE>( DefaultInitial, DefaultIncrease, adrs, count, is_attach ));
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
    }

    // ===================================================================
    CFvBuffer( const CFvBuffer<TYPE>& object ) : CFvMultiData<TYPE>()
    {
        size_type uiInitial     = object.m_alloc->GetCapacity();
        size_type uiIncrease    = object.m_alloc->GetIncrease();

        this->m_alloc = static_cast<CFvAllocator<TYPE>*>(new CFvBufferAllocator<TYPE>( uiInitial, uiIncrease ));
        if( this->m_alloc == NULL )
            throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
        CFvBuffer<TYPE>::operator = (object);
    }

    // ===================================================================
    virtual ~CFvBuffer()
    {
        if( this->m_alloc != NULL )
            delete this->m_alloc;
    }

    // ===================================================================
    virtual INT GetDataID() const
    {
        return CFvBuffer<TYPE>::DataID;
    }

    // ===================================================================
    virtual bool GetPointer( INT id, void** val ) const
    {
        if( CFvBuffer<TYPE>::GetDataID() != id )
            return false;
        *val = (void*)this;
        return true;
    }

public:
    // ===================================================================
    virtual CFvBuffer<TYPE>& operator = ( const CFvBuffer<TYPE>& ope )
    {
        CFvMultiData<TYPE>::operator = (ope);
        return *this;
    }

    // ===================================================================
    virtual bool operator == ( const CFvBuffer<TYPE>& ope ) const
    {
        const CFvBufferAllocator<TYPE>* ope1 = static_cast<const CFvBufferAllocator<TYPE>*>(this->m_alloc);
        const CFvBufferAllocator<TYPE>* ope2 = static_cast<const CFvBufferAllocator<TYPE>*>(ope.m_alloc);
        if (ope1->GetCount() != ope2->GetCount()) return false;
        for(size_type i=0 ; i<ope1->GetCount() ; i++)
            if (0 != memcmp(ope1->GetBuffer(i), ope2->GetBuffer(i), sizeof(TYPE))) return false;
        return true;
    }

    // ===================================================================
    virtual bool operator != ( const CFvBuffer<TYPE>& ope ) const
    {
        return !(operator == (ope));
    }

    // ===================================================================
    virtual CFvBuffer<TYPE>& MoveFrom(CFvBuffer<TYPE>& src)
    {
        if (src.IsAttach())
            return Attach(src);

        this->SetBuffer(src.GetAddress(), src.size(), false);       // (!) allow free
        src.IsAttach(true);
        src.clear();
        return *this;
    }

    // ===================================================================
    virtual CFvBuffer<TYPE>& Attach(const CFvBuffer<TYPE>& src)
    {
        this->SetBuffer(src.GetAddress(), src.size(), true);    // (!) deny free
        return *this;
    }

    // ===================================================================
    virtual bool SetBuffer( pointer adrs, size_type count )
    {
        return static_cast<CFvBufferAllocator<TYPE>*>(this->m_alloc)->SetBuffer(adrs, count);
    }

    // ===================================================================
    virtual bool SetBuffer( pointer adrs, size_type count, bool is_attach )
    {
        return static_cast<CFvBufferAllocator<TYPE>*>(this->m_alloc)->SetBuffer(adrs, count, is_attach);
    }

    // ===================================================================
    virtual pointer GetAddress( size_type uiIndex = 0 ) const
    {
        return static_cast<CFvBufferAllocator<TYPE>*>(this->m_alloc)->GetBuffer(uiIndex);
    }

    // ===================================================================
    virtual void IsAttach( bool value )
    {
        static_cast<CFvBufferAllocator<TYPE>*>(this->m_alloc)->IsAttach(value);
    }

    // ===================================================================
    virtual bool IsAttach() const
    {
        return static_cast<CFvBufferAllocator<TYPE>*>(this->m_alloc)->IsAttach();
    }

    // ===================================================================
    virtual void Reset() const
    {
        return static_cast<CFvBufferAllocator<TYPE>*>(this->m_alloc)->Reset();
    }

protected:
    // OBJECT
};

}   // FVCL

#pragma pack(pop)

#endif // _FVBUFFER_H_INCLUDED_