TnbBitSet.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbComparable.h"
#include "TnbException.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
class CBitSet : public IComparableT<TNB::CBitSet>
{
    DEFSUPER(IComparableT<TNB::CBitSet>); 
    size_t  m_bitSize;                          
    BYTE*   m_pBuf;                             
 
    size_t m_BufSize(void) const
    {
        return (m_bitSize + 7) / 8;
    }
    INDEX m_BitNo(INDEX index) const
    {
        return index & 7;
    }
    INDEX m_ByteNo(INDEX index) const
    {
        return index / 8;
    }
    bool m_Test(INDEX index) const
    {
        return (m_pBuf[m_ByteNo(index)] & _BIT(m_BitNo(index))) != 0;
    }
    void m_Set(INDEX index)
    {
        m_pBuf[m_ByteNo(index)] |= _BIT(m_BitNo(index));
    }
    void m_Reset(INDEX index)
    {
        m_pBuf[m_ByteNo(index)] &= ~_BIT(m_BitNo(index));
    }
    void m_Fix(INDEX index, bool b)
    {
        (b) ? m_Set(index) : m_Reset(index);
    }
    void m_Flip(INDEX index)
    {
        m_Test(index) ? m_Reset(index) : m_Set(index);
    }
 
public:
 
    explicit CBitSet(size_t bitSize = 32) : _super()
    {
        if ( bitSize == 0 )
        {
            throw CNotSupportException();
        }
        m_bitSize = bitSize;
        m_pBuf = new BYTE[m_BufSize()];
        memset(m_pBuf, 0, m_BufSize());
    }
 
    explicit CBitSet(LPCTSTR lpszBin) : _super()
    {
        m_bitSize = STRLIB::GetLen(lpszBin);
        if ( m_bitSize == 0 )
        {
            throw CNotSupportException();
        }
        m_pBuf = new BYTE[m_BufSize()];
        memset(m_pBuf, 0, m_BufSize());
        loop ( i, m_bitSize )
        {
            if ( lpszBin[i] != '0' )
            {
                m_Set(m_bitSize - 1 - i);
            }
        }
    }
 
    CBitSet(const CBitSet& other) : _super()
    {
        m_bitSize = 0;
        m_pBuf = NULL;
        operator=(other);
    }
 
    virtual ~CBitSet(void)
    {
        if ( m_pBuf != NULL )
        {
            delete[] m_pBuf;
            m_pBuf = NULL;
        }
    }
 
    CBitSet& operator=(const CBitSet& other)
    {
        ASSERTLIB(other.m_bitSize > 0);
        if ( m_pBuf != NULL )
        {
            delete[] m_pBuf;
        }
        m_bitSize = other.m_bitSize;
        m_pBuf = new BYTE[m_BufSize()];
        MemCopy(m_pBuf, other.m_pBuf, m_BufSize());
        return *this;
    }
 
    CBitSet& SetData(size_t size, LPCVOID P)
    {
        if ( size == 0 || P == NULL )
        {
            throw CNotSupportException();
        }
        if ( m_pBuf != NULL )
        {
            delete[] m_pBuf;
        }
        m_bitSize = size * 8;
        ASSERTLIB(m_BufSize() == size);
        m_pBuf = new BYTE[size];
        MemCopy(m_pBuf, static_cast<const BYTE*>(P), size);
        return *this;
    }
 
    CBitSet& SetInteger(ULONGLONG ullValue)
    {
        Reset();
        if ( m_bitSize < sizeof(ULONGLONG) * 8 )
        {
            ullValue &= _BIT(m_bitSize) - 1;
        }
        size_t s = m_BufSize();
        if ( s >= 7 ){  m_pBuf[7] = static_cast<BYTE>(ullValue>>56); }
        if ( s >= 6 ){  m_pBuf[6] = static_cast<BYTE>(ullValue>>48); }
        if ( s >= 5 ){  m_pBuf[5] = static_cast<BYTE>(ullValue>>40); }
        if ( s >= 4 ){  m_pBuf[4] = static_cast<BYTE>(ullValue>>32); }
        if ( s >= 3 ){  m_pBuf[3] = static_cast<BYTE>(ullValue>>24); }
        if ( s >= 2 ){  m_pBuf[2] = static_cast<BYTE>(ullValue>>16); }
        if ( s >= 1 ){  m_pBuf[1] = static_cast<BYTE>(ullValue>> 8); }
                        m_pBuf[0] = static_cast<BYTE>(ullValue    );
        return *this;
    }
 
    UINT GetUnsignedInt(void) const
    {
        UINT r = 0;
        for ( INDEX i = 0; i < sizeof(UINT) * 8; i++ )
        {
            if ( Test(i) )
            {
                r |= (1 << i);
            }
        }
        return r;
    }
 
    int GetSignedInt(void) const
    {
        int r = GetSignedInt();
        if ( Test(GetSize() - 1) )
        {
            //符号拡張の必要あり
            for ( size_t i = GetSize(); i < sizeof(int) * 8; i++ )
            {
                r |= (1 << i);
            }
        }
        return r;
    }
 
    ULONGLONG GetUnsignedInt64(void) const
    {
        ULONGLONG r = 0;
        for ( INDEX i = 0; i < sizeof(ULONGLONG) * 8; i++ )
        {
            if ( Test(i) )
            {
                r |= (1ui64 << i);
            }
        }
        return r;
    }
 
    LONGLONG GetSignedInt64(void) const
    {
        LONGLONG r = GetUnsignedInt64();
        if ( Test(GetSize() - 1) )
        {
            //符号拡張の必要あり
            for ( size_t i = GetSize(); i < sizeof(ULONGLONG) * 8; i++ )
            {
                r |= (1ui64 << i);
            }
        }
        return r;
    }
 
    CStr ToString(void) const
    {
        CStr str;
        LPTSTR P = str.GetBuffer(m_bitSize + 1);
        for ( INDEX i = m_bitSize - 1; i >= 0; i-- )
        {
            *P++ = m_Test(i) ? _T('1') : _T('0');
        }
        *P = 0;
        str.ReleaseBuffer();
        return str;
    }
 
    size_t GetSize(void) const
    {
        return m_bitSize;
    }
 
    CBitSet& SetSize(size_t size)
    {
        if ( GetSize() != size )
        {
            CBitSet bs = GetMid(0, size);
            *this = bs;
        }
        return *this;
    }
 
    bool Test(INDEX index) const
    {
        if ( ! IsInRange(index) )
        {
            return false;
        }
        return m_Test(index);
    }
 
    CBitSet& Set(INDEX index)
    {
        if ( IsInRange(index) )
        {
            m_Set(index); 
        }
        return *this;
    }
 
    CBitSet& Set(void)
    {
        for ( INDEX i = 0; i < m_bitSize; i++ )
        {
            m_Set(i);
        }
        return *this;
    }
 
    CBitSet& Reset(INDEX index)
    {
        if ( IsInRange(index) )
        {
            m_Reset(index);
        }
        return *this;
    }
 
    CBitSet& Reset(void)
    {
        memset(m_pBuf, 0, m_BufSize());
        return *this;
    }
 
    CBitSet& Flip(INDEX index)
    {
        if ( IsInRange(index) )
        {
            m_Flip(index);
        }
        return *this;
    }
 
    CBitSet& Flip(void)
    {
        for ( INDEX i = 0; i<m_bitSize; i++ )
        {
            m_Flip(i);
        }
        return *this;
    }
 
    bool IsInRange(INDEX index) const
    {
        return TNB::IsInRange(index, m_bitSize);
    }
 
    CBitSet GetMid(INDEX index, size_t bitSize) const
    {
        CBitSet bs(bitSize);
        for ( INDEX i = 0; i < bitSize; i++ )
        {
            if ( Test(i + index) )
            {
                bs.m_Set(i);
            }
        }
        return bs;
    }
 
    CBitSet& operator+=(const CBitSet& t)
    {
        CBitSet bs = *this + t;
        return *this = bs;
    }
 
    CBitSet& operator&=(const CBitSet& t)
    {
        for ( INDEX i = 0; i < m_bitSize; i++ )
        {
            if ( ! t.Test(i) )
            {
                m_Reset(i);
            }
        }
        return *this;
    }
 
    CBitSet& operator|=(const CBitSet& t)
    {
        for ( INDEX i = 0; i < m_bitSize; i++ )
        {
            if ( t.Test(i) )
            {
                m_Set(i);
            }
        }
        return *this;
    }
 
    CBitSet& operator^=(const CBitSet& t)
    {
        for ( INDEX i = 0; i < m_bitSize; i++ )
        {
            m_Fix(i, t.Test(i)^m_Test(i));
        }
        return *this;
    }
 
    CBitSet& operator>>=(DWORD dwPos)
    {
        ASSERT0(false, "CBitSet::operator>>=()", "未実装");
        return *this;
    }
 
    CBitSet& operator<<=(DWORD dwPos)
    {
        ASSERT0(false, "CBitSet::operator<<=()", "未実装");
        return *this;
    }
 
    CBitSet operator+(const CBitSet& t)
    {
        size_t l1 = GetSize();
        size_t l2 = t.GetSize();
        CBitSet bs(l1 + l2);
        MemCopy(bs.m_pBuf, m_pBuf, m_BufSize());
        for ( INDEX i = 0; i < l2; i++ )
        {
            if ( t.Test(i) )
            {
                bs.m_Set(l1 + i);
            }
        }
        return bs;
    }
 
    CBitSet operator&(const CBitSet& t) const
    {
        CBitSet bs(*this);
        return bs &= t;
    }
 
    CBitSet operator|(const CBitSet& t) const
    {
        CBitSet bs(*this);
        return bs |= t;
    }
 
    CBitSet operator^(const CBitSet& t) const
    {
        CBitSet bs(*this);
        return bs ^= t;
    }
 
    CBitSet operator<<(DWORD dwPos) const
    {
        CBitSet bs(*this);
        return bs <<= dwPos;
    }
 
    CBitSet operator>>(DWORD dwPos) const
    {
        CBitSet bs(*this);
        return bs >>= dwPos;
    }
 
    CBitSet operator~(void) const
    {
        CBitSet bs(*this);
        return bs.Flip();
    }
 
    virtual INT_PTR Compare(const CBitSet& t) const
    {
        size_t size = (m_bitSize < t.m_bitSize) ? t.m_bitSize : m_bitSize;
        size_t l = size - 1;
        for ( INDEX i = 0; i < size; i++ )
        {
            int r = t.Test(l) - Test(l);
            if ( r != 0 )
            {
                return r;
            }
            l--;
        }
        return 0;
    }
 
private:
    friend class CBitSetTest;
};
 
 
 
inline ISerializer& operator<<(ISerializer& _sr, const CBitSet& t)
{
    _sr << t.ToString();
    return _sr;
}
 
inline const IDeserializer& operator>>(const IDeserializer& ds, CBitSet& _t)
{
    CStr s;
    ds >> s;
    _t = CBitSet(s);
    return ds;
}
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")