TnbCollectionAdapter.h

[詳解]

#pragma once
#include "TnbCollection.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CAbstractAdapterT : public IConstCollectionT<TYP>
{
    DEFSUPER(IConstCollectionT<TYP>);
protected:
 
    const IConstCollectionT<TYP>*   m_pCol;     
    size_t                          m_size; 
 
public:
 
    CAbstractAdapterT(const IConstCollectionT<TYP>* c)
        : _super(), m_pCol(c), m_size(0)
    {
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return m_pCol->Lock(); 
    }
 
    virtual void Unlock(void) const 
    {
        m_pCol->Unlock(); 
    }
 
    virtual size_t GetSize(void) const
    {
        return m_size;
    }
 
    CAbstractAdapterT& operator=(const CAbstractAdapterT& other)
    {
        m_pCol = other.m_pCol;
        m_size = other.m_size;
        return *this;
    }
};
 
 
 
template<typename TYP>
class CConstOffsetAdapterT : public CAbstractAdapterT<TYP>
{
    DEFSUPER(CAbstractAdapterT<TYP>);
    INDEX   m_startIndex;               
public:
 
    CConstOffsetAdapterT(const IConstCollectionT<TYP>* c, INDEX startIndex, size_t size = INVALID_SIZE)
        : _super(c), m_startIndex(startIndex) 
    {
        _super::m_size = size;
    }
 
    virtual size_t GetSize(void) const
    {
        size_t l = m_pCol->GetSize() - m_startIndex;
        if ( _super::m_size != INVALID_SIZE && l > _super::m_size)
        {
            l = _super::m_size;
        }
        return l;
    }
 
    virtual const TYP& At(INDEX index) const
    {
        return m_pCol->At(index + m_startIndex);
    }
};
 
 
 
template<typename TYP>
class CConstReverseAdapterT : public CAbstractAdapterT<TYP>
{
    DEFSUPER(CAbstractAdapterT<TYP>);
public:
 
    explicit CConstReverseAdapterT(const IConstCollectionT<TYP>* c) : _super(c) 
    {
        _super::m_size = c->GetSize();
    }
 
    virtual const TYP& At(INDEX index) const
    {
        return m_pCol->At(_super::m_size - index - 1);
    }
};
 
 
 
template<typename TYP>
class CConstAppendAdapterT : public CAbstractAdapterT<TYP>
{
    DEFSUPER(CAbstractAdapterT<TYP>);
    const IConstCollectionT<TYP>*   m_p2ndCol;  
    size_t  m_sizeCol;
public:
 
    CConstAppendAdapterT(const IConstCollectionT<TYP>* c1, const IConstCollectionT<TYP>* c2)
        : _super(c1), m_p2ndCol(c2)
    {
        m_sizeCol = m_pCol->GetSize();
        _super::m_size = m_sizeCol + m_p2ndCol->GetSize();
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        return m_pCol->Lock() && m_p2ndCol->Lock();
    }
 
    virtual void Unlock(void) const
    {
        m_p2ndCol->Unlock();
        m_pCol->Unlock();
    }
 
    virtual const TYP& At(INDEX index) const
    {
        return (index < m_sizeCol) ? m_pCol->At(index) : m_p2ndCol->At(index - m_sizeCol);
    }
};
 
 
 
template<typename TYP>
class COffsetAdapterT : public ICollectionT<TYP>
{
    DEFSUPER(ICollectionT<TYP>);
    ICollectionT<TYP>*  m_pCol;         
    INDEX               m_startIndex;   
    size_t              m_size;         
public:
 
    COffsetAdapterT(ICollectionT<TYP>* c, INDEX startIndex, size_t size = 0)
        : _super(), m_pCol(c), m_startIndex(startIndex), m_size(size)
    {
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return m_pCol->Lock(); 
    }
 
    virtual void Unlock(void) const 
    {
        m_pCol->Unlock(); 
    }
 
    virtual size_t GetSize(void) const
    {
        size_t l = m_pCol->GetSize() - m_startIndex;
        return TNB::IsInRange(m_size, l) ? m_size : l;
    }
 
    virtual const TYP& At(INDEX index) const
    {
        return m_pCol->At(index + m_startIndex);
    }
 
    virtual TYP& Ref(INDEX index)
    {
        return m_pCol->Ref(index + m_startIndex);
    }
 
    virtual bool Set(INDEX index, const TYP& t)
    {
        return m_pCol->Set(index + m_startIndex, t);
    }
 
    virtual INDEX Add(const TYP& t) 
    {
        return INVALID_INDEX; 
    }
 
    virtual bool Remove(INDEX index) 
    {
        return false; 
    }
 
    virtual void Swap(INDEX index1, INDEX index2)
    {
        m_pCol->Swap(index1 + m_startIndex, index2 + m_startIndex);
    }
};
 
 
 
template<typename TYP>
class CConstAdapterT : public IConstCollectionT<TYP>, public ISequenceCollectionT<TYP>
{
    DEFSUPER(IConstCollectionT<TYP>);
    const TYP*          m_pcType;       
    size_t              m_size;         
public:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    // const_iterator型宣言
    typedef const TYP* const_iterator;
    #endif //_TnbDOXYEM
 
    const_iterator begin(void) const { return m_pcType; }
 
    const_iterator end(void) const { return m_pcType + m_size; }
 
    CConstAdapterT(size_t size, LPCVOID P) 
        : _super(), m_pcType(static_cast<const TYP*>(P)), m_size(size)
    {
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return true;
    }
 
    virtual void Unlock(void) const 
    {
    }
 
    virtual size_t GetSize(void) const
    {
        return m_size;
    }
 
    virtual const TYP* ReferBuffer(void) const
    {
        return m_pcType;
    }
 
    virtual const TYP& At(INDEX index) const
    {
        if ( ! IsInRange(index) ){ throw CIndexOutOfBoundsException(); }
        return m_pcType[index];
    }
 
    const TYP& operator[](INDEX index) const
    {
        return At(index);
    }
 
    CConstAdapterT& operator=(const CConstAdapterT& other)
    {
        m_pcType = other.m_pcType;
        m_size = other.m_size;
        return *this;
    }
};
 
 
 
template<typename TYP>
class CIndexAdapterT : public IConstCollectionT<TYP>, CCopyImpossible
{
    DEFSUPER(IConstCollectionT<TYP>);
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    // memo; ICollectionT の sort を使用するためにインナークラスを作成している。
    struct TParam : ICollectionT<TYP>
    {
        DEFSUPER(ICollectionT<TYP>);
        const IConstCollectionT<TYP>*   m_pCol;     
        INDEX*                          m_pIndexs;  
        size_t                          m_size;     
        // ロック
        virtual bool Lock(DWORD dwTime = INFINITE) const { return m_pCol->Lock(); }
        // アンロック
        virtual void Unlock(void) const { m_pCol->Unlock(); }
        // 要素数取得
        virtual size_t GetSize(void) const { return m_size; }
        // 要素の参照取得.
        virtual const TYP& At(INDEX index) const
        {
            if ( ! IsInRange(index) ){ throw CIndexOutOfBoundsException(); }
            return m_pCol->At(m_pIndexs[index]);
        }
        // 要素の参照取得.
        virtual TYP& Ref(INDEX index) { throw CNotSupportException(); }
        // 要素の設定.
        virtual bool Set(INDEX index, const TYP& t) { return false; }
        // 要素一つ追加.
        virtual INDEX Add(const TYP& t) { return INVALID_INDEX; }
        // 要素一つ削除.
        virtual bool Remove(INDEX index)
        {
            if ( ! IsInRange(index) ){ return false; }
            for ( INDEX i = index; i < m_size - 1; i++ )
            {
                m_pIndexs[i] = m_pIndexs[i + 1];
            }
            m_size--;
            return true;
        }
        // 要素の入れ替え
        virtual void Swap(INDEX index1, INDEX index2)
        {
            if ( ! IsInRange(index1) || ! IsInRange(index2) ){ throw CIndexOutOfBoundsException(); }
            TNB::Swap(m_pIndexs[index1], m_pIndexs[index2]);
        }
    };
 
    #endif //Document作成用シンボル
 
    TParam m_param;     
 
public:
 
    CIndexAdapterT(const IConstCollectionT<TYP>* c) : _super()
    {
        m_param.m_pCol          = c;
        m_param.m_size          = c->GetSize();
        m_param.m_pIndexs       = new INDEX[m_param.m_size];
        loop ( i, m_param.m_size )
        {
            m_param.m_pIndexs[i] = i;
        }
    }
 
    virtual ~CIndexAdapterT(void)
    {
        if ( m_param.m_pIndexs != NULL )
        {
            delete[] m_param.m_pIndexs;
            m_param.m_pIndexs = NULL;
        }
    }
 
    INDEX GetRawIndex(INDEX index) const
    {
        return IsInRange(index) ? m_param.m_pIndexs[index] : INVALID_INDEX;
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return m_param.Lock(); 
    }
 
    virtual void Unlock(void) const 
    {
        m_param.Unlock(); 
    }
 
    virtual size_t GetSize(void) const 
    {
        return m_param.m_size; 
    }
 
    virtual const TYP& At(INDEX index) const
    {
        return m_param.At(index);
    }
 
    bool Remove(INDEX index)
    {
        return m_param.Remove(index);
    }
 
    void Swap(INDEX index1, INDEX index2)
    {
        m_param.Swap(index1, index2);
    }
 
    bool Sort(const IComparatorT<TYP>& comparator, bool boIsReverse = false, bool boIsBubble = false)
    {
        return m_param.Sort(comparator, boIsReverse, boIsBubble);
    }
 
    bool Sort(bool boIsReverse = false, bool boIsBubble = false)
    {   
        return m_param.Sort(boIsReverse, boIsBubble);
    }
 
    size_t Cull(const IChecker& checker, bool boIsReverse = false)
    {
        EXCLUSIVE(this);
        size_t r = 0;
        if ( m_param.m_size > 0 )C
        {
            size_t size = m_param.m_size;
            INDEX* P = new INDEX[size];
            MemCopy(P, m_param.m_pIndexs, size);
            for ( size_t i = 0; i < size; i++ )
            {
                if ( checker.IsValid(At(i)) ^ boIsReverse )
                {
                    m_param.m_pIndexs[r++] = P[i];
                }
            }
            m_param.m_size = r;
            delete[] P;
        }
        return r;
    }
 
    void ResetIndex(void)
    {
        if ( m_param.m_size != m_pCol->GetSize() )
        {
            m_param.m_size = m_pCol->GetSize();
            if ( m_param.m_pIndexs != NULL )
            {
                delete[] m_param.m_pIndexs;
            }
            m_param.m_pIndexs = new INDEX[m_param.m_size];
        }
        loop ( i, m_param.m_size )
        {
            m_param.m_pIndexs[i] = i;
        }
    }
 
 
 
 
};
 
 
 
}; // TNB