TnbList.h

[詳解]

#pragma once
#include "TnbPointerHandle.h"
#include "TnbCollection.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP, typename ATT = DWORD>
class CListT : public ICollectionMidT<TYP>
{
    DEFSUPER(ICollectionMidT<TYP>); 
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    struct TOne
    {
        TOne*   pNextOne;   
        ATT     attribute;  
        TYP     value;      
        TOne(TYP t) : value(t) , attribute(ATT()) , pNextOne(NULL) 
        {
        }
        void Delete(void)
        {
            if ( pNextOne != NULL )
            {
                pNextOne->Delete();
                delete pNextOne;
                pNextOne = NULL;
            }
        }
    };
 
    struct TTop : public TOne, CCopyImpossible
    {
        CSyncSection    m_syncObj;      
        size_t          size;           
        TOne*           pLastOne;       
        TTop(void) : TOne(TYP()) , size(0) , pLastOne(NULL) {}
        ~TTop(void)
        {
            TOne::Delete();
        }
        TOne* GetPointer(INDEX index) const
        {
            const TOne* P = this;
            for ( INDEX i = index + 1; i > 0; i-- )
            {
                if ( P->pNextOne == NULL )
                {
                    P = NULL;
                    break;
                }
                P = P->pNextOne;
            }
            return const_cast<TOne*>(P);
        }
 
        TOne* GetLastPointer(void)
        {
            #ifndef _DEBUG
                if ( pLastOne != NULL ){ return pLastOne; } 
            #endif
            TOne* P = this;
            while ( true )
            {
                if ( P->pNextOne == NULL )
                {
                    break;
                }
                P = P->pNextOne;
            }
            ASSERTLIB(pLastOne == NULL || pLastOne == P);
            pLastOne = P; 
            return P;
        }
    };
    #endif
 
    CPointerHandleT<TTop> m_hpTop;  
    CSyncSection        m_syncFunc; 
 
    void m_Separate(void)
    {
        m_hpTop->m_syncObj.Lock();
        if ( m_hpTop.GetReferCount() > 1 )
        {
            //新たにメモリ確保
            TTop* P = new TTop;
            TOne* pNew = P;
            //複製
            TOne* pOld = m_hpTop->pNextOne;
            loop ( i, GetSize() )
            {
                ASSERTLIB(pOld != NULL);
                pNew->pNextOne = new TOne(pOld->value);
                pNew->pNextOne->attribute = pOld->attribute;
                P->size++;
                P->pLastOne = pNew->pNextOne;
                //
                pOld = pOld->pNextOne;
                pNew = pNew->pNextOne;
            }
            //新しくバッファアドレスを指定
            m_hpTop->m_syncObj.Unlock();
            m_hpTop = P;
        }
        else
        {
            m_hpTop->m_syncObj.Unlock();
        }
    }
 
protected:
 
    virtual const TYP* m_GetConstPointer(INDEX index) const
    {
        const TOne* P = m_hpTop->GetPointer(index);
        return (P == NULL) ? NULL : &(P->value);
    }
 
    virtual TYP* m_GetPointer(INDEX index)
    {
        m_Separate();
        TOne* P = m_hpTop->GetPointer(index);
        return (P == NULL) ? NULL : &(P->value);
    }
 
public:
 
    iterator insert(iterator ite, const TYP& t = TYP())
    {
        INDEX index = ite.GetIndex();
        Insert(index, t);
        return begin() + index;
    }
 
    void push_front(const TYP& t) 
    {
        Insert(0, t); 
    }
 
 
    //------------------------
 
    
    CListT(void) : _super(), m_hpTop(new TTop) 
    {
    }
 
    CListT(const CListT& other) : _super(), m_hpTop(other.m_hpTop) 
    {
    }
 
    virtual ~CListT(void)
    {
        m_hpTop.Null();
    }
 
    CListT& operator=(const CListT& other)
    {
        m_hpTop = other.m_hpTop;
        return *this;
    }
 
    CListT& operator+=(const CListT& list)
    {
        EXCLUSIVE2(list, *this);
        TOne* P = list.GetPointer(0);
        loop ( i, list.m_hpTop->GetSize() )
        {
            ASSERTLIB( P != NULL );
            VERIFYLIB( Add(P->value, P->attribute) != INVALID_INDEX );
            P = P->pNextOne;
        }
        return *this;
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        return m_syncFunc.Lock();
    }
 
    virtual void Unlock(void) const
    {
        m_syncFunc.Unlock();
    }
 
    virtual size_t GetSize(void) const
    {
        return m_hpTop->size;
    }
 
    virtual INDEX Add(const TYP& t)
    {
        return Add(t, ATT());
    }
 
    virtual bool Remove(INDEX index)
    {
        m_Separate();
        m_hpTop->m_syncObj.Lock();
        TOne* P = m_hpTop->GetPointer(index - 1);
        if ( P == NULL )
        {
            m_hpTop->m_syncObj.Unlock();
            return false;
        }
        TOne* pTmp = P->pNextOne;
        if ( pTmp == NULL )
        {
            m_hpTop->m_syncObj.Unlock();
            return false;
        }
        P->pNextOne = pTmp->pNextOne;
        delete pTmp;
        m_hpTop->size--;
        m_hpTop->pLastOne = NULL;
        m_hpTop->m_syncObj.Unlock();
        return true;
    }
 
    virtual bool Set(INDEX index, const TYP& t)
    {
        return Set(index, t, ATT());
    }
 
    virtual bool SetEx(INDEX index, const TYP& t)
    {
        return SetEx(index, t, ATT());
    }
 
    virtual bool RemoveAll(void)
    {
        m_hpTop = new TTop;
        return true;
    }
 
    virtual void Swap(INDEX index1, INDEX index2)
    {
        if ( index1 == index2 )
        {
            return;
        }
        EXCLUSIVE(this);
        m_Separate();
        TOne* P1 = m_hpTop->GetPointer(index1 - 1);
        TOne* P2 = m_hpTop->GetPointer(index2 - 1);
        if ( P1 == NULL || P2 == NULL ){ throw CIndexOutOfBoundsException(); }
        TOne* P1n = P1->pNextOne;
        TOne* P2n = P2->pNextOne;
        if ( P1n == NULL || P2n == NULL ){ throw CIndexOutOfBoundsException(); }
        TOne** P1nn = &(P1n->pNextOne);
        TOne** P2nn = &(P2n->pNextOne);
        //
        P1->pNextOne = P2n;
        P2->pNextOne = P1n;
        TOne* P = *P1nn;
        *P1nn = *P2nn;
        *P2nn = P;
        m_hpTop->pLastOne = NULL;
    }
 
    INDEX Add(const TYP& t, const ATT& attribute)
    {
        m_Separate();
        m_hpTop->m_syncObj.Lock();
        INDEX r = m_hpTop->size;
        TOne* P = m_hpTop->GetLastPointer();
        ASSERTLIB(P != NULL);
        P->pNextOne = new TOne(t);
        P->pNextOne->attribute = attribute;
        m_hpTop->size++;
        m_hpTop->pLastOne = P->pNextOne;
        m_hpTop->m_syncObj.Unlock();
        return r;
    }
 
    INDEX AddEx(const TYP& t, const ATT& attribute)
    {
        EXCLUSIVE(this);
        return Add(t, attribute);
    }
 
    bool Set(INDEX index, const TYP& t, const ATT& attribute)
    {
        m_Separate();
        TOne* P = m_hpTop->GetPointer(index);
        if ( P == NULL )
        {
            return false;
        }
        P->value = t;
        P->attribute = attribute;
        return true;
    }
 
    bool SetEx(INDEX index, const TYP& t, const ATT& attribute)
    {
        EXCLUSIVE(this);
        return Set(index, t, attribute);
    }
 
    const ATT& GetAttribute(INDEX index) const
    {
        EXCLUSIVE(this);
        TOne* P = m_hpTop->GetPointer(index);
        if ( P != NULL )
        {
            return P->attribute;
        }
        ASSERT1(false, "CListT::GetAttribute", "範囲外のIndex(%d)が指定されました。", index);
        throw CIndexOutOfBoundsException();
    }
 
    bool Insert(INDEX index, const TYP& t, const ATT& attribute = ATT())
    {
        EXCLUSIVE(this);
        m_Separate();
        if ( index == GetSize() )
        {
            return Add(t) != INVALID_INDEX;
        }
        m_hpTop->m_syncObj.Lock();
        TOne* P = m_hpTop->GetPointer(index - 1);
        if ( P == NULL )
        {
            m_hpTop->m_syncObj.Unlock();
            return false;
        }
        TOne* pNew = new TOne(t);
        pNew->attribute = attribute;
        pNew->pNextOne = P->pNextOne;
        P->pNextOne = pNew;
        m_hpTop->size++;
        m_hpTop->m_syncObj.Unlock();
        return true;
    }
 
    virtual bool SetSize(size_t size)
    {
        if ( size == INVALID_SIZE )
        {
            return false;
        }
        EXCLUSIVE(this);
        m_hpTop->m_syncObj.Lock();
        if ( size < m_hpTop->size )
        {
            //今より小さく
            m_Separate();
            TOne* P = m_hpTop->GetPointer(size - 1);
            P->Delete();
            m_hpTop->size = size;
            m_hpTop->m_syncObj.Unlock();
        }
        else if ( size > m_hpTop->size )
        {
            //今より大きく
            INT_PTR l = size - m_hpTop->size;
            m_Separate();
            m_hpTop->m_syncObj.Unlock();
            while ( l-- )
            {
                Add(TYP());
            }
        }
        return true;
    }
 
    virtual size_t Cull(const IChecker& checker, bool boIsReverse = false)
    {
        EXCLUSIVE(this);
        size_t r = 0;
        size_t i = 0;
        while ( i < GetSize() )
        {
            if ( ! checker.IsValid(At(i)) ^ boIsReverse )
            {
                if ( ! Remove(i) ){ return INVALID_SIZE; }
                r++;
            }
            else
            {
                i++;
            }
        }
        return r;
    }//memo;Listは頭から削除していったほうが高速のため、特別に実装。
 
    #ifndef _WIN32_WCE
    size_t CullOnAttribute(typename const IConstCollectionT<ATT>::IChecker& checker, bool boIsReverse = false)
    {
        EXCLUSIVE(this);
        size_t r = 0;
        if ( ! IsEmpty() )
        {
            for ( INDEX i = GetSize() - 1; i >= 0; i-- )
            {
                if ( ! checker.IsValid(GetAttribute(i)) ^ boIsReverse )
                {
                    if ( ! Remove(i) )
                    {
                        return INVALID_SIZE;
                    }
                    r++;
                }
            }
        }
        return r;
    }
    #endif // _WIN32_WCE
 
    virtual void Serialize(ISerializer& _sr) const
    {
        size_t l = GetSize();
        _sr << l << l;
        loop ( i, l )
        {
            _sr << At(i);
            _sr << GetAttribute(i);
        }
    }
 
    virtual void Deserialize(const IDeserializer& ds)
    {
        size_t l1, l2;
        ds >> l1 >> l2;
        if ( l1 != l2 )
        {
            throw CInvalidParamException();
        }
        RemoveAll();
        TYP t;
        ATT attribute;
        loop ( i, l1 )
        {
            ds >> t;
            ds >> attribute;
            Add(t, attribute);
        }
    }
};
 
 
 
typedef TNB::CListT< BYTE > CByteList;
 
 
 
 
}; // TNB