TnbBitVector.h

[詳解]

#pragma once
#include "TnbCollection.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CBitVector : public ICollectionT<bool>
{
    DEFSUPER(ICollectionT<bool>);
    CVectorT<BYTE>          m_vbData;       
    size_t                  m_dataSize;     
    CSyncSection            m_syncFunc;     
    mutable bool            m_boTemp;       
 
    static void ms_ShiftRight(INDEX startIndex, BYTE* B, size_t len)
    {
        bool boLastBit = false;
        BYTE bTop = B[startIndex / 8];
        for ( INDEX i = len - 1; i >= startIndex / 8; i-- )
        {
            bool b = (B[i] & _BIT(0)) != 0;
            B[i] >>= 1;
            if ( boLastBit )
            {
                B[i] |= _BIT(7);
            }
            boLastBit = b;
        }
        INDEX pos = startIndex & 7;
        if ( pos != 0 )
        {
            BYTE bMask = static_cast<BYTE>(_BIT(pos) - 1);
            bTop &= bMask;
            B[startIndex / 8] &= ~bMask;
            B[startIndex / 8] |= bTop;
        }
    }
 
    static void ms_ShiftLeft(INDEX startIndex, BYTE* B, size_t len)
    {
        bool boLastBit = false;
        BYTE bTop = B[startIndex / 8];
        for ( INDEX i = startIndex / 8; i < len; i++ )
        {
            bool b = (B[i] & _BIT(7)) != 0;
            B[i] <<= 1;
            if ( boLastBit )
            {
                B[i] |= _BIT(0);
            }
            boLastBit = b;
        }
        INDEX pos = startIndex & 7;
        if ( pos != 0 )
        {
            BYTE bMask = static_cast<BYTE>(_BIT(pos) - 1);
            bTop &= bMask;
            B[startIndex / 8] &= ~bMask;
            B[startIndex / 8] |= bTop;
        }
    }
 
public:
 
    class CRef
    {
        friend class CBitVector;
        CBitVector* m_vb;
        INDEX       m_index;
        CRef(const CBitVector* P, INDEX i)
        {
            m_vb = const_cast<CBitVector*>(P);
            m_index = i;
        }
    public:
        operator bool(void) const
        {
            return m_vb->At(m_index);
        }
        bool operator=(bool b)
        {
            m_vb->Set(m_index, b);
            return b;
        }
    };
 
    
    //--------------------------------------
 
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    // const_iterator型宣言
    typedef CConstIteratorBaseT<CBitVector, bool> const_iterator;
    // iterator宣言
    class iterator
    {
        _ITERATORCORE(iterator, CBitVector)
    public:
        CRef operator*(void)
        {
            return (*m_V)[m_ind];
        }
        CRef operator[](int i)
        {
            return (*m_V)[m_ind+i];
        }
    };
    #endif //_TnbDOXYEM
 
    const_iterator begin(void) const { return const_iterator(this, 0); }
 
    const_iterator end(void) const { return const_iterator(this, GetSize()); }
 
    iterator begin(void) { return iterator(this, 0); }
 
    iterator end(void) { return iterator(this, GetSize()); }
 
    iterator insert(iterator ite, bool t = false)
    {
        INDEX i = ite.GetIndex();
        Insert(i, t);
        return iterator(this, i);
    }
 
    void push_front(bool t) { Insert(0, t); }
 
 
    //------------------------
 
 
    explicit CBitVector(size_t size = 0) : _super(), m_vbData(size) 
    {
        m_dataSize = 0;
    }
 
    CBitVector(const CBitVector& other) : _super(), m_vbData(other.m_vbData)
    {
        m_dataSize = other.m_dataSize;
    }
    
    virtual ~CBitVector(void)
    {
    }
 
    CBitVector& operator=(const CBitVector& other)
    {
        m_vbData = other.m_vbData;
        m_dataSize = other.m_dataSize;
        return *this;
    }
 
    void SetIncrementSize(size_t size)
    {
        m_vbData.SetIncrementSize(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
    {
        return m_dataSize;
    }
 
    virtual const bool& At(INDEX index) const
    {
        if ( ! IsInRange(index) )
        {
            throw CIndexOutOfBoundsException();
        }
        m_boTemp = (m_vbData[index / 8] & _BIT(index & 7)) != 0;
        return m_boTemp;
    }
 
    virtual bool& Ref(INDEX index)
    {
        throw CNotSupportException();
    }
 
    virtual bool Set(INDEX index, const bool& t)
    {
        if ( ! IsInRange(index) )
        {
            return false;
        }
        if ( t )
        {
            m_vbData[index / 8] |= _BIT(index & 7);
        }
        else
        {
            m_vbData[index / 8] &= ~_BIT(index & 7);
        }
        return true;
    }
 
    virtual INDEX Add(const bool& t)
    {
        if ( m_dataSize == 0 || (m_dataSize & 7) == 7 )
        {
            m_vbData.Add(0);
        }
        if ( t )
        {
            m_vbData[m_dataSize / 8] |= _BIT(m_dataSize & 7);
        }
        else
        {
            m_vbData[m_dataSize / 8] &= ~_BIT(m_dataSize & 7);
        }
        return m_dataSize++;
    }
 
    virtual bool Remove(INDEX index)
    {
        if ( ! IsInRange(index) )
        {
            return false;
        }
        m_dataSize--;
        ms_ShiftRight(index, m_vbData.GetBuffer(), m_vbData.GetSize());
        m_vbData.ReleaseBuffer();
        return true;
    }
 
    virtual bool RemoveAll(void)
    {
        m_vbData.RemoveAll();
        m_dataSize = 0;
        return true;
    }
 
    bool Insert(INDEX index, const bool& t)
    {
        if ( index == m_dataSize )
        {
            return IsValid(Add(t));
        }
        if ( ! IsInRange(index) )
        {
            return false;
        }
        if ( m_dataSize == 0 || (m_dataSize & 7) == 7 )
        {
            m_vbData.Add(0);
        }
        ms_ShiftLeft(index, m_vbData.GetBuffer(), m_vbData.GetSize());
        m_vbData.ReleaseBuffer();
        if ( t )
        {
            m_vbData[index / 8] |= _BIT(index & 7);
        }
        else
        {
            m_vbData[index / 8] &= ~_BIT(index & 7);
        }
        m_dataSize++;
        return true;
    }
 
    const CRef operator[](INDEX index) const
    {
        if ( ! IsInRange(index) )
        {
            throw CIndexOutOfBoundsException();
        }
        return CRef(this, index);
    }
 
    CRef operator[](INDEX index)
    {
        if ( ! IsInRange(index) )
        {
            throw CIndexOutOfBoundsException();
        }
        return CRef(this, index);
    }
 
private:
    friend class CBitVectorTest;    
};
 
 
 
}; // TNB