FvMultiData.h

[詳解]

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

#ifndef _FVMULTIDATA_H_INCLUDED_
#define _FVMULTIDATA_H_INCLUDED_

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

#include "FvAllocator.h"
#include "FvIterator.h"

#pragma pack(push,_FVCL_PACKING)

namespace FVCL
{

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

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

// /////////////////////////////////////////////////////////////////
// CLASS
template<class TYPE> class CFvMultiData : public CFvObject
{
public:
    typedef TYPE*                           pointer;
    typedef const TYPE*                     const_pointer;
    typedef TYPE&                           reference;
    typedef const TYPE&                     const_reference;
    typedef UINT                            size_type;
    typedef CFvIterator<TYPE>               iterator;
    typedef const iterator                  const_iterator;

public:
    // ===================================================================
    CFvMultiData()
    {
        this->m_alloc = NULL;
    }

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

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

    // ===================================================================
    virtual INT GetDataID() const = 0;

    // ===================================================================
    virtual bool GetPointer( INT id, void** val ) const = 0;

    //
    // METHOD
    //

    // ===================================================================
    virtual reference at( size_type _Pos )
    {
        return this->m_alloc->GetItem(_Pos);
    }

    // ===================================================================
    virtual const_reference at( size_type _Pos ) const
    {
        return this->m_alloc->GetItem(_Pos);
    }

    // ===================================================================
    virtual reference front()
    {
        return this->m_alloc->GetItem( 0 );
    }

    // ===================================================================
    virtual const_reference front() const
    {
        return this->m_alloc->GetItem( 0 );
    }

    // ===================================================================
    virtual reference back()
    {
        return this->m_alloc->GetItem( this->m_alloc->GetBack() );
    }

    // ===================================================================
    virtual const_reference back() const
    {
        return this->m_alloc->GetItem( this->m_alloc->GetBack() );
    }

    // ===================================================================
    virtual iterator begin()
    {
        return iterator( 0, this->m_alloc );
    }

    // ===================================================================
    virtual const_iterator begin() const
    {
        return iterator( 0, this->m_alloc );
    }

    // ===================================================================
    virtual iterator end()
    {
        return iterator( this->m_alloc->GetCount(), this->m_alloc );
    }

    // ===================================================================
    virtual const_iterator end() const
    {
        return iterator( this->m_alloc->GetCount(), this->m_alloc );
    }

    // ===================================================================
    virtual size_type capacity() const
    {
        return this->m_alloc->GetCapacity();
    }

    // ===================================================================
    virtual void clear()
    {
        this->m_alloc->Clear();
    }

    // ===================================================================
    virtual bool empty() const
    {
        return (this->m_alloc->GetCount()==0 ? true : false);
    }

    // ===================================================================
    virtual iterator erase( iterator _First, iterator _Last )
    {
        size_type   uiPos = _First.GetIndex();
        if( this->m_alloc->Erase( _First.GetIndex(), _Last.GetIndex() ) )
            return iterator( uiPos, this->m_alloc );
        else
            return end();
    }

    // ===================================================================
    virtual iterator erase( iterator _Where )
    {
        return erase( _Where, _Where );
    }

    // ===================================================================
    virtual CFvAllocator<TYPE>& get_allocator()
    {
        return *this->m_alloc;
    }

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

    // ===================================================================
    virtual void insert( iterator _Where, size_type _Count, const_reference _Val )
    {
        this->m_alloc->Insert( _Where.GetIndex(), _Count, _Val );
    }

    // ===================================================================
    virtual iterator insert( iterator _Where, const_reference _Val )
    {
        size_type   uiPos = _Where.GetIndex();
        this->m_alloc->Insert( uiPos, 1, _Val );
        return iterator( uiPos, this->m_alloc );
    }

    // ===================================================================
    virtual bool push_back( const_reference _Val )
    {
        return this->m_alloc->PushBack( _Val );
    }

    // ===================================================================
    virtual bool pop_back()
    {
        return this->m_alloc->PopBack();
    }

    // ===================================================================
    virtual bool resize( size_type _Newsize, const_reference _Val )
    {
        return this->m_alloc->Resize( _Newsize, &_Val );
    }

    // ===================================================================
    virtual bool resize( size_type _Newsize )
    {
        return this->m_alloc->Resize( _Newsize, NULL );
    }

    // ===================================================================
    virtual void reserve( size_type _Count )
    {
        this->m_alloc->Reserve( _Count );
    }

    // ===================================================================
    virtual size_type size() const
    {
        return this->m_alloc->GetCount();
    }

public:
    // ===================================================================
    virtual bool ChangeOrder( iterator _Where, INT _Order )
    {
        CFvAllocator<TYPE>* alloc = _Where.GetAllocator();
        if( alloc == NULL ) return false;
        if( alloc != this->m_alloc ) return false;

        return this->m_alloc->ChangeOrder( _Where.GetIndex(), _Order );
    }

    // ===================================================================
    virtual bool SwapItem( iterator _Where1, iterator _Where2 )
    {
        CFvAllocator<TYPE>* alloc1 = _Where1.GetAllocator();
        CFvAllocator<TYPE>* alloc2 = _Where2.GetAllocator();
        if( alloc1 == NULL ) return false;
        if( alloc2 == NULL ) return false;
        if( alloc1 != this->m_alloc ) return false;
        if( alloc2 != this->m_alloc ) return false;

        return this->m_alloc->SwapItem( _Where1.GetIndex(), _Where2.GetIndex() );
    }

public:
    // ===================================================================
    virtual reference operator [] ( size_type uiIndex )
    {
        return this->m_alloc->GetItem( uiIndex );
    }

    // ===================================================================
    virtual const_reference operator [] ( size_type uiIndex ) const
    {
        return this->m_alloc->GetItem( uiIndex );
    }

    // ===================================================================
    virtual CFvMultiData<TYPE>& operator = ( const CFvMultiData<TYPE>& ope )
    {
        CFvObject::operator = (ope);
        if( this->m_alloc->GetCount() != ope.m_alloc->GetCount() )
            if( !this->m_alloc->Resize( ope.m_alloc->GetCount() ) )
                throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );

        if( this->m_alloc->GetCapacity() < ope.m_alloc->GetCapacity() )
        {
            size_type   uiCapacity = 0;
            uiCapacity = ope.m_alloc->GetCapacity() - this->m_alloc->GetCapacity();
            if( !this->m_alloc->Reserve( uiCapacity ) )
                throw FVCL::CFveBadAllocException( FVCL_ErrorCode::FAILED_TO_ALLOCATE, __TFUNCTION__ );
        }

        for( size_type iCnt=0 ; iCnt<this->m_alloc->GetCount() ; iCnt++ )
            this->m_alloc->SetItem( iCnt, ope.m_alloc->GetItem( iCnt ) );
        return *this;
    }

protected:
    // OBJECT
    CFvAllocator<TYPE>*                     m_alloc;
};

}   // FVCL

#pragma pack(pop)

#endif // _FVMULTIDATA_H_INCLUDED_