TnbBlockLinkVector.h

[詳解]

#pragma once
#include "TnbCollection.h"
#include "TnbVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CBlockLinkVectorT : public ICollectionMidT<TYP>, CCopyImpossible
{
    DEFSUPER(ICollectionMidT<TYP>);
public:
 
    struct TBlockInformation
    {
        const TYP*  pData;  
        size_t      size;   
    };
 
 
    //-------
 
 
    CBlockLinkVectorT(void) : m_totalSize(0)
    {
        m_blockShift = 10;
        m_blockSize = down_cast<size_t>(_BIT(m_blockShift));
        m_blockMask = m_blockSize - 1;
    }
 
    CBlockLinkVectorT(size_t bs) : m_totalSize(0)
    {
        m_blockShift = 1;   
        m_blockSize = 1 << m_blockShift;
        while ( m_blockSize < bs )
        {
            m_blockSize <<= 1;
            m_blockShift++;
            if ( m_blockSize == 0 )
            {
                m_blockShift = 7;
                m_blockSize = 1 << m_blockShift;
            }
        }
        m_blockMask = m_blockSize - 1;
    }
 
    ~CBlockLinkVectorT(void)
    {
        RemoveAll();
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return m_sync.Lock(dwTime);
    }
 
    virtual void Unlock(void) const
    {
        m_sync.Unlock();
    }
 
    virtual size_t GetSize(void) const
    {
        return m_totalSize;
    }
 
    virtual INDEX Add(const TYP& t)
    {
        size_t i = m_totalSize;
        INDEX bn = i >> m_blockShift;
        INDEX idx = i & m_blockMask;
        if ( bn >= m_blocks.GetSize() )
        {
            TYP* P = new TYP[m_blockSize];
            m_blocks.Add(P);
        }
        TYP* B = m_blocks[bn];
        B[idx] = t;
        m_totalSize++;
        return i;
    }
 
    virtual size_t AddElements(size_t size, const TYP* P = NULL)
    {
        INDEX is = m_totalSize;
        size_t i = m_totalSize - 1 + size;
        INDEX bn = i >> m_blockShift;
        while ( bn >= m_blocks.GetSize() )
        {
            TYP* P = new TYP[m_blockSize];
            m_blocks.Add(P);
        }
        m_totalSize += size;
        if ( P != NULL )
        {
            loop ( i, size )
            {
                Set(is + i, *P++);
            }
        }
        else
        {
            loop ( i, min(m_blockSize, size) )  //memo 全部やる必要はないので、一ブロック分のみ
            {
                Set(is + i, TYP());
            }
        }
        return size;
    }
 
    virtual bool RemoveAll(void)
    {
        m_totalSize = 0;
        m_blocks.RemoveAll();
        return true;
    }
 
    virtual bool Remove(INDEX index)
    {
        if ( index >= m_totalSize )
        {
            return false;
        }
        size_t d = m_totalSize - index;
        if ( d > 1 )
        {
            loop ( i, d - 1 )
            {
                Set(index + i, At(index + i + 1));
            }
        }
        m_totalSize--;
        if ( m_totalSize == 0 )
        {
            m_blocks.RemoveAll();
        }
        else
        {
            INDEX bn = (m_totalSize - 1) >> m_blockShift;
            if ( bn < m_blocks.GetSize() )
            {
                m_blocks.SetSize(bn + 1);
            }
        }
        return true;
    }
 
    virtual size_t RemoveElements(INDEX index, size_t size = 0)
    {
        EXCLUSIVE( &m_sync );
        size_t sz = GetSize();
        if ( sz < index )
        {
            return INVALID_SIZE;
        }
        if ( size == 0 || sz < index + size)
        {
            SetSize(index);
            return sz - index;
        }
        size_t z = sz - size - index;
        loop ( i, z )
        {
            Set(index + i, Get(index + size + i));
        }
        SetSize(index + z);
        return size;
    }
 
    size_t GetBlockCount(void) const
    {
        return m_blocks.GetSize();
    }
 
    bool GetBlockInformation(TBlockInformation& _bi, INDEX index) const
    {
        if ( m_blocks.IsInRange(index ) )
        {
            _bi.size = m_blockSize;
            if ( index == m_blocks.GetSize() - 1 )
            {
                _bi.size = (m_totalSize & m_blockMask);
            }
            _bi.pData = m_blocks[index];
            return true;
        }
        return false;
    }
 
protected:
 
    virtual const TYP* m_GetConstPointer(INDEX index) const
    {
        if ( index >= m_totalSize )
        {
            return NULL;
        }
        INDEX bn = index >> m_blockShift;
        INDEX idx = index & m_blockMask;
        TYP* B = m_blocks[bn];
        return &B[idx];
    }
 
    virtual TYP* m_GetPointer(INDEX index)
    {
        if ( index >= m_totalSize )
        {
            return NULL;
        }
        INDEX bn = index >> m_blockShift;
        INDEX idx = index & m_blockMask;
        TYP* B = m_blocks[bn];
        return &B[idx];
    }
 
private:
    CSyncSection                        m_sync;         
    size_t                              m_totalSize;    
    CVectorT<CArrayPtrHandleT<TYP> >    m_blocks;       
    size_t                              m_blockSize;    
    int                                 m_blockShift;   
    INDEX                               m_blockMask;    
    friend class CBlockListVectorTest;  
};
 
 
 
}; // TNB