TnbVector.h

[詳解]

#pragma once
#include "TnbException.h"
#include "TnbCollection.h"
#include "TnbPointerHandle.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CVectorT : public ICollectionT<TYP> , public ISequenceCollectionT<TYP>
{
    DEFSUPER(ICollectionT<TYP>);
public:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    // const_iterator型宣言
    typedef const TYP* const_iterator;
    // iterator型宣言
    typedef TYP* iterator;
    #endif //_TnbDOXYEM
 
    const_iterator begin(void) const { return m_hptHead->data(0); }
 
    const_iterator end(void) const { return m_hptHead->data(GetSize()); }
 
    iterator begin(void) { m_Separate(); return m_hptHead->data(0); }
 
    iterator end(void) { m_Separate(); return m_hptHead->data(GetSize()); }
 
    iterator insert(iterator ite, const TYP& t = TYP())
    {
        INT_PTR index = ite - begin();
        Insert(index, t);
        return begin() + index;
    }
 
    iterator erase(iterator ite)
    {
        INT_PTR index = ite - begin();
        if ( ! Remove(index) ) { return end(); }
        return begin() + index;
    }
 
    void push_front(const TYP& t) { Insert(0, t); }
 
    void push_back(const TYP& t) { Add(t); }
 
 
    //------------------------
 
 
    explicit CVectorT(size_t size = 0) : _super()
    {
        m_Init();
        SetIncrementSize(size);
    }
 
    CVectorT(const CVectorT<TYP>& other) : _super()
    {
        m_Init();
        if ( other.m_hptHead.GetReferCount() < 0)
        {
            SetElements(other.GetSize(), other.ReferBuffer());
        }
        else
        {
            m_hptHead = other.m_hptHead;
        }
    }
    
    virtual ~CVectorT(void)
    {
        m_hptHead.Null();
    }
 
    CVectorT& operator=(const CVectorT& other)
    {
        EXCLUSIVE(&other);
        if ( other.m_hptHead.GetReferCount() < 0)
        {
            SetElements(other.GetSize(), other.ReferBuffer());
        }
        else
        {
            m_hptHead = other.m_hptHead;
        }
        return *this;
    }
 
    virtual TYP Get(INDEX index) const
    {
        return * m_hptHead->datack(index);
    }
 
    virtual const TYP& At(INDEX index) const
    {
        return * m_hptHead->datack(index);
    }
 
    virtual TYP& Ref(INDEX index)
    {
        TYP* P = m_GetPtr(index);
        if ( P == NULL )
        {
            throw CIndexOutOfBoundsException();
        }
        return *P;
    }
    
    virtual bool Set(INDEX index, const TYP& t)
    {
        TYP* P = m_GetPtr(index);
        if ( P == NULL )
        {
            return false; 
        }
        *P = t;
        return true;
    }
 
    const TYP& operator[](INDEX index) const
    {
        return At(index);
    }
 
    TYP& operator[](INDEX index)
    {
        TYP* P = m_GetPtr(index);
        if ( P != NULL ){ return *P; }
        throw CIndexOutOfBoundsException();
    }
    
    CVectorT& operator+=(const CVectorT<TYP>& vector)
    {
        AddElements(vector.GetSize(), vector.ReferBuffer());
        return *this;
    }
 
    CVectorT<TYP> operator+(const CVectorT<TYP>& other) const
    {
        CVectorT v = *this;
        v += other;
        return v;
    }
 
    void SetIncrementSize(size_t size)
    {
        m_incrementSize = size;
    }
 
    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
    {
        ASSERTLIB(! m_hptHead.IsNull());
        return m_hptHead->dataSize;
    }
 
    virtual INDEX Add(const TYP& t)
    {
        size_t r = GetSize();
        return (AddElements(1, &t) == 1) ? r : INVALID_INDEX;
    }
 
    virtual bool Remove(INDEX index)
    {
        return RemoveElements(index, 1) == 1;
    }
 
    virtual size_t RemoveElements(INDEX index, size_t size = 0)
    {
        EXCLUSIVE(this);
        if ( IsInRange(index) )
        {
            m_Separate();
            size_t nowSize = GetSize();
            TYP* P = m_hptHead->pBuffer;
            //削除サイズ調整
            if ( size == 0 || nowSize - index <= size )
            {
                if ( index == 0 )
                {
                    return RemoveAll() ? nowSize : INVALID_SIZE;
                }
                size = nowSize - index;
            }
            //削除範囲の後の移動が必要な数
            if ( nowSize > index + size )
            {
                loop ( i, nowSize - (index + size) )
                {
                    ASSERTLIB( index + i + size < nowSize );
                    P[index + i] = P[index + i + size];
                }
            }
            //いらない部分を消す
            size_t s = m_hptHead->dataSize - size;
            loop ( i, size )
            {
                P[i + s] = TYP();
            }
            //
            m_hptHead->dataSize -= size;
            return size;
        }
        return INVALID_SIZE;
    }
 
    virtual size_t AddElements(size_t size, const TYP* P = NULL)
    {
        if ( size == 0 )
        {
        }
        else if ( m_hptHead.IsNull() )
        {
            ASSERTLIB(false);
            //=== 自分は情報を持っていない
            THead* lpTmp = m_CreateHead(size);
            m_CopyBuffer(lpTmp->pBuffer, P, size);
            m_hptHead = lpTmp;
        }
        else
        {
            EXCLUSIVE(this);
            m_hptHead->syncObj.Lock();
            THead* ptHead = m_hptHead;
            if ( m_hptHead.GetReferCount() > 1 )
            {
                size_t l = ptHead->dataSize + size;
                THead* lpTmp = m_CreateHead(l);
                m_CopyBuffer(lpTmp->pBuffer, ptHead->pBuffer, ptHead->dataSize);
                m_CopyBuffer(lpTmp->data(ptHead->dataSize), P, size);
                m_hptHead->syncObj.Unlock();
                m_hptHead = lpTmp;
            }
            else
            {
                m_hptHead->syncObj.Unlock();
                size_t l = ptHead->dataSize + size;
                //二つを足したバッファサイズを確保してある？
                if ( ptHead->bufferSize >= l )
                {
                    //== 足りる
                    m_CopyBuffer(ptHead->data(ptHead->dataSize), P, size);
                    ptHead->dataSize = l;
                }
                else
                {
                    //== 足りない
                    //新たにメモリ確保
                    size_t ss = m_GetSecureSize(l);
                    TYP* N = new TYP[ss];
                    //データを代入
                    m_CopyBuffer(&N[0], ptHead->pBuffer, ptHead->dataSize);
                    m_CopyBuffer(&N[ptHead->dataSize], P, size);
                    //現在のバッファを開放
                    if ( ptHead->pBuffer != NULL )
                    {
                        delete[] ptHead->pBuffer;
                    }
                    //新しくバッファアドレスを指定
                    ptHead->bufferSize = ss;
                    ptHead->dataSize = l;
                    ptHead->pBuffer = N;
                }
            }
        }
        return size;
    }
 
    virtual size_t SetElements(size_t size, const TYP* P = NULL)
    {
        CVectorT v;
        size_t r = v.AddElements(size, P);
        if ( r >= 0 )
        {
            m_hptHead = v.m_hptHead;
        }
        return r;
    }
    
    virtual size_t Append(const IConstCollectionT<TYP>& c)
    {
        EXCLUSIVE2(&c, this);
        size_t as = c.GetSize();
        size_t j = GetSize();
        SetSize(j + as);
        TYP* P = m_hptHead->data(j);
        loop ( i, as )
        {
            *P++ = c.At(i);
        }
        return as;
    }
 
    virtual bool RemoveAll(void)
    {
        m_Init();
        return true;
    }
 
    virtual bool Insert(INDEX index, const TYP& t)
    {
        EXCLUSIVE(this);
        if ( ! TNB::IsInRange(index, GetSize() + 1) )
        {
            return false;
        }
        if ( Add(TYP()) == INVALID_INDEX )
        {
            return false;
        }
        size_t size = GetSize() - 1;
        TYP* P = m_hptHead->pBuffer;
        for ( size_t i = size; i > index; i-- )
        {
            P[i] = P[i - 1];
        }
        P[index] = t;
        return true;
    }
 
    void Invalid(void)
    {
        RemoveAll();
        m_hptHead->boValid = false;
    }
 
    virtual bool SetSize(size_t size)
    {
        if ( size != INVALID_SIZE )
        {
            EXCLUSIVE(this);
            if ( IsEmpty() )
            {
                //バッファなし
                SetElements(size);
            }
            else if ( size == 0 )
            {
                m_Init();
            }
            else
            {
                size_t now = m_hptHead->dataSize;
                if ( now > size )
                {
                    //今より小さく
                    m_Separate();
                    TYP* P = m_hptHead->data(size);
                    for ( size_t i = size; i < now; i++ )
                    {
                        *P++ = TYP();
                    }
                    m_hptHead->dataSize = size;
                }
                else if ( now < size )
                {
                    //今より大きく
                    AddElements(size - now);
                }
            }
        }
        return true;
    }
 
    virtual const TYP* ReferBuffer(void) const
    {
        ASSERTLIB(! m_hptHead.IsNull());
        return m_hptHead->pBuffer;
    }
 
    int GetReferCount(void)
    {
        return m_hptHead.GetReferCount();
    }
 
    bool IsValid(void) const
    {
        if ( IsEmpty() && ! m_hptHead->boValid )
        {
            return false;
        }
        return true;
    }
 
    CVectorT<TYP> Mid(INDEX startIndex, size_t size = 0) const
    {
        CVectorT v;
        EXCLUSIVE(this);
        if ( ! IsEmpty() )
        {
            if ( m_hptHead->dataSize > startIndex )
            {
                if ( size == 0 || m_hptHead->dataSize - startIndex < size )
                {
                    //取得データ長まで取り出せない 最後まで取得にする
                    size = m_hptHead->dataSize - startIndex;
                }
                v.SetElements(size, m_hptHead->data(startIndex));
            }   
        }
        return v;
    }
 
    TYP* GetBuffer(size_t size = 0)
    {
        if ( IsEmpty() && size == 0 )
        {
            return NULL;
        }
        m_hptHead->syncObj.Lock();
        Lock();
        //---自クラスにバッファがある
        int iCnt = m_hptHead.GetReferCount();
        if ( iCnt < 0 )
        {
            //---もう固定バッファになってる
            m_hptHead->syncObj.Unlock();
            if ( size > 0 )
            {
                SetSize(size);
            }
        }
        else if ( iCnt == 1 )
        {
            //---このクラスでしか使ってない
            m_hptHead->syncObj.Unlock();
            if ( size > 0 )
            {
                SetSize(size);
            }
            //参照数を-１にする。
            m_hptHead.SetReferCount(-1);
        }
        else
        {
            //---他でも使われてる
            //新たに確保せねば
            if ( size == 0 )
            {
                size = m_hptHead->dataSize;
            }
            //新たにメモリ確保
            THead* lpTmp = m_CreateHead(size);
            //データを代入
            m_CopyBuffer(lpTmp->pBuffer, m_hptHead->pBuffer, size);
            //新しくバッファアドレスを指定
            m_hptHead->syncObj.Unlock();
            m_hptHead = lpTmp;
            //参照数を-１にする。
            m_hptHead.SetReferCount(-1);
        }
        Unlock();
        return m_hptHead->pBuffer;
    }
 
    void ReleaseBuffer(void)
    {
        if ( ! IsEmpty() )
        {
            m_hptHead->syncObj.Lock();
            //---自クラスにバッファがある
            if ( m_hptHead.GetReferCount() < 0 )
            {
                //---固定バッファになってる
                //参照1の普通のバッファになる
                m_hptHead.SetReferCount(1);
            }
            m_hptHead->syncObj.Unlock();
        }
    }
 
    inline friend CVectorT<TYP> ToVector(const IConstCollectionT<TYP>& c, size_t size = 0)
    {
        EXCLUSIVE(&c);
        size_t l = c.GetSize();
        if ( size == 0 || size > l )
        {
            size = l; 
        }
        CVectorT vb;
        vb.SetSize(size);
        TYP* P = vb.m_hptHead->data();
        loop ( i, size )
        {
            *P++ = c.At(i);
        }
        return vb;
    }
 
private:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    struct THead
    {
        CSyncSection syncObj;   
        size_t  bufferSize;     
        size_t  dataSize;       
        bool    boValid;        
        TYP *   pBuffer;        
 
        THead(void) : bufferSize(0) , dataSize(0) , boValid(true) , pBuffer(NULL)   {}
 
        virtual ~THead(void)
        {
            if ( pBuffer != NULL )
            {
                delete[] pBuffer;
                pBuffer = NULL;
            } 
        }
 
        TYP* data(INDEX f = 0) const
        {
            return pBuffer + f; 
        }
 
        TYP* datack(INDEX f = 0) const
        {
            if ( TNB::IsInRange(f, dataSize) )
            {
                return pBuffer + f; 
            }
            throw CIndexOutOfBoundsException();
        }
    };
    #endif
 
    CPointerHandleT<THead>  m_hptHead;          
    CSyncSection            m_syncFunc;         
    size_t                  m_incrementSize;    
 
    size_t m_GetSecureSize(size_t size)
    {
        //追加サイズ計算
        size_t marginSize = m_incrementSize;
        if ( marginSize == 0 )
        {
            //自動になっている
            marginSize = size / 8;
            marginSize = (marginSize < 4) ? 4 : ((marginSize > 1024) ? 1024 : marginSize);
        }
        return size + marginSize;
    }
 
    THead* m_CreateHead(size_t size)
    {
        THead* lptTmpHead = new THead;
        //長さを入れる
        size_t bs = m_GetSecureSize(size);
        lptTmpHead->dataSize    = size;
        lptTmpHead->bufferSize  = bs;
        //バッファを確保する
        lptTmpHead->pBuffer = new TYP[bs];
        return lptTmpHead;
    }
 
    void m_CopyBuffer(TYP* _lpDst, const TYP* lpSrc, size_t iLen)
    {
        ASSERTLIB(_lpDst != NULL);
        if ( lpSrc == NULL )
        {
            TYP t = TYP();
            while ( iLen-- )
            {
                *_lpDst++ = t; 
            }
        }
        else
        {
            ASSERTLIB(! ::IsBadReadPtr(lpSrc, iLen));
            while ( iLen-- )
            {
                *_lpDst++ = *lpSrc++;
            }
        }
    }
 
    void m_Init(void)
    {
        m_hptHead = new THead;
        m_incrementSize = 0;
    }
 
    void m_Separate(void)
    {
        m_hptHead->syncObj.Lock();
        if ( m_hptHead.GetReferCount() > 1 )
        {
            size_t size = m_hptHead->dataSize;
            //新たにメモリ確保
            THead* lpTmp = m_CreateHead(size);
            //データを代入
            m_CopyBuffer(lpTmp->pBuffer, m_hptHead->pBuffer, size);
            //新しくバッファアドレスを指定
            m_hptHead->syncObj.Unlock();
            m_hptHead = lpTmp;
        }
        else
        {
            m_hptHead->syncObj.Unlock();
        }
    }
 
    TYP* m_GetPtr(INDEX index)
    {
        if ( TNB::IsInRange(index, m_hptHead->dataSize) )
        {
            m_Separate();
            return m_hptHead->data(index);
        }
        return NULL;
    }
 
    friend class CVectorTest;   
};
 
 
 
template<typename TYP>
class CAutoVectorT : public CVectorT<TYP>
{
    DEFSUPER(CVectorT<TYP>);
public:
 
    virtual bool Set(INDEX index, const TYP& t)
    {
        if ( GetSize() <= index )
        {
            SetSize(index + 1);
        }
        return _super::Set(index, t);
    }
 
    virtual bool Insert(INDEX index, const TYP& t)
    {
        if ( GetSize() < index )
        {
            SetSize(index);
        }
        return _super::Insert(index, t);
    }
 
    const TYP& operator[](INDEX index) const
    {
        if ( ! IsInRange(index) )
        {
            throw CIndexOutOfBoundsException();
        }
        return _super::operator[](index);
    }
 
    TYP& operator[](INDEX index)
    {
        if ( GetSize() <= index )
        {
            SetSize(index + 1);
        }
        return _super::operator[](index);
    }
};
 
 
 
typedef TNB::CVectorT< BYTE > CByteVector;
 
 
 
typedef TNB::CVectorT< WORD > CWordVector;
 
 
 
typedef TNB::CVectorT< DWORD > CDwordVector;
 
 
 
#ifdef __AFX_H__
 
    inline CByteVector ToByteVector(const CByteArray &ba)
    {
        CByteVector v;
        v.SetElements(static_cast<size_t>(ba.GetSize()), ba.GetData());
        return v;
    }
 
    inline void Copy(CByteArray &ba, const CByteVector &dat)
    {
        ba.SetSize(dat.GetSize());
        MemCopy(ba.GetData(), dat.ReferBuffer(), dat.GetSize());
    }
 
#endif
 
 
 
}; // TNB