cBits.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cBits_H
#define _INC_cBits_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "GrayCore.h"
#include "cUnitTestDecl.h"
 
namespace Gray
{
        UNITTEST2_PREDEF(cBits);
 
        typedef unsigned short BIT_SIZE_t;      
        typedef unsigned int BIT_ENUM_t;        
        enum BITOP_TYPE
        {
                BITOP_TOGGLE = -1,      
                BITOP_CLR = 0,          
                BITOP_SET = 1,          
        };
 
#ifndef _1BITMASK
#define _1BITMASK(b)    (((size_t)1)<<(b))      
#endif
 
#ifdef USE_INT64                // native support for literal HEX constant UINT 64 bit.
#if defined(_MSC_VER) || defined(__WATCOMC__) 
#define CUINT64(h,l)    0x##h##l##ui64
#else
#define CUINT64(h,l)    0x##h##l##ULL
#endif
#elif defined(USE_LITTLE_ENDIAN)
#define CUINT64(h,l)    { 0x##l, 0x##h }                // for use with cUInt64
#else
#define CUINT64(h,l)    { 0x##h, 0x##l }                // for use with cUInt64
#endif
 
        struct GRAYCORE_LINK cBits      // static
        {
 
                static const BYTE k_8 = 8;      
 
                static constexpr size_t GetSizeBytes(BIT_ENUM_t nBits) noexcept
                {
#define GETSIZEBYTES(nBits) (((nBits)+7)/8)             // equiv for use in const
                        return (nBits + 7) / k_8;
                }
 
                template <typename TYPE>
                static constexpr TYPE Mask1(BIT_ENUM_t nBit) noexcept
                {
                        return ((TYPE)1) << nBit;
                }
                template <typename TYPE>
                static constexpr bool IsMask1(TYPE nVal) noexcept
                {
                        return (nVal != 0) && ((nVal & (nVal - 1)) == 0) ;
                }
 
                template <typename TYPE>
                static constexpr bool IsSet(TYPE nVal, BIT_ENUM_t nBit) noexcept
                {
                        return (nVal & Mask1<TYPE>(nBit)) ? true : false ;
                }
                template <typename TYPE>
                static constexpr bool IsClear(TYPE nVal, BIT_ENUM_t nBit) noexcept
                {
                        return (nVal & Mask1<TYPE>(nBit)) ? false : true ;
                }
 
                template <typename TYPE>
                static constexpr TYPE SetBit(TYPE nVal, BIT_ENUM_t nBit) noexcept
                {
                        return nVal | Mask1<TYPE>(nBit);
                }
                template <typename TYPE>
                static constexpr TYPE ClearBit(TYPE nVal, BIT_ENUM_t nBit) noexcept
                {
                        return nVal & ~Mask1<TYPE>(nBit);
                }
 
                template <typename TYPE>
                static constexpr bool HasMask(TYPE nVal, TYPE nMask) noexcept
                {
                        return (nVal & nMask) != 0;
                }
 
                template <typename TYPE>
                static inline BIT_ENUM_t Highest1Bit(TYPE nMask) noexcept
                {
 
                        BIT_ENUM_t nBitsHighest = 0;
                        while (nMask != 0)
                        {
                                nMask >>= 1;
                                nBitsHighest++;
                        }
                        return nBitsHighest;
                }
 
                template <typename TYPE>
                static inline BIT_ENUM_t Count1Bits(TYPE nMask) noexcept
                {
 
                        BIT_ENUM_t nBits = 0; // accumulates the total bits set in nVal
                        for (; nMask; nBits++)
                        {
                                nMask &= nMask - 1; // clear the least significant bit set
                        }
                        return nBits;
                }
 
                template <typename TYPE>
                static inline TYPE Rotl(TYPE nVal, BIT_ENUM_t nBits) noexcept
                {
                        return (nVal << nBits) | (nVal >> ((sizeof(nVal) * k_8) - nBits));
                }
                template <typename TYPE>
                static inline TYPE Rotr(TYPE nVal, BIT_ENUM_t nBits) noexcept
                {
                        return (nVal >> nBits) | (nVal << ((sizeof(nVal) * k_8) - nBits));
                }
 
                template <typename TYPE>
                static inline TYPE Reverse(TYPE nVal) noexcept
                {
 
                        TYPE nTemp = nVal; // nTemp will have the reversed bits of nVal.
                        for (size_t i = (sizeof(nVal) * k_8 - 1); i > 0; i--)
                        {
                                nTemp |= (nVal & 1);
                                nTemp <<= 1;
                                nVal >>= 1;
                        }
                        return nTemp | (nVal & 1);
                }
 
#if 0
                template <typename TYPE>
                static inline TYPE Op(TYPE nVal, BITOP_TYPE eBitOp, TYPE nValMask = 1)
                {
                        // TODO or,and,xor/not // 
                }
#endif
                UNITTEST_FRIEND(cBits);
        };
 
        // Override implementations of templates.
 
#if defined(__GNUC__)
        template <>
        inline BIT_ENUM_t cBits::Count1Bits<UINT32>(UINT32 nMask) // static
        {
                return ::__builtin_popcount(nMask);
        }
        template <>
        inline BIT_ENUM_t cBits::Highest1Bit<UINT32>(UINT32 nMask) // static
        {
                // Use intrinsic function
                if (nMask == 0)
                        return 0;
                return 32 - __builtin_clz(nMask);
        }
 
#if defined(USE_INT64)
        template <>
        inline BIT_ENUM_t cBits::Count1Bits<UINT64>(UINT64 nMask) // static
        {
                return ::__builtin_popcountll(nMask);
        }
        template <>
        inline BIT_ENUM_t cBits::Highest1Bit<UINT64>(UINT64 nMask) // static
        {
                // Use intrinsic function
                if (nMask == 0)
                        return 0;
                return 64 - __builtin_clzll(nMask);
        }
#endif
 
#else
 
        template <>
        inline BIT_ENUM_t cBits::Count1Bits<UINT32>(UINT32 nVal) noexcept
        {
                nVal = (nVal & 0x55555555) + ((nVal & 0xAAAAAAAA) >> 1);
                nVal = (nVal & 0x33333333) + ((nVal & 0xCCCCCCCC) >> 2);
                nVal = (nVal + (nVal >> 4)) & 0x0F0F0F0F;
                nVal = (nVal + (nVal >> 16));
                nVal = (nVal + (nVal >> 8)) & 0x3F;
                return (BIT_ENUM_t)nVal;
        }
 
#endif
 
#ifdef _MSC_VER
        template <>
        inline UINT32 cBits::Rotl<UINT32>(UINT32 nVal, BIT_ENUM_t nBits) noexcept
        {
                return ::_rotl(nVal, (int)nBits);       
        }
        template <>
        inline UINT32 cBits::Rotr<UINT32>(UINT32 nVal, BIT_ENUM_t nBits) noexcept
        {
                return ::_rotr(nVal, (int)nBits);       
        }
 
#if !defined(_MANAGED)
        template <>
        inline BIT_ENUM_t cBits::Highest1Bit<UINT32>(UINT32 nMask) noexcept
        {
                // Use intrinsic function
                DWORD nRet;
                if (::_BitScanReverse(&nRet, nMask))
                        return (BIT_ENUM_t)(nRet + 1);
                return 0;
        }
#endif
 
#if defined(USE_INT64) && ! defined(UNDER_CE) && defined(_MSC_VER)      // _INTEGRAL_MAX_BITS >= 64
#ifdef USE_64BIT
        template <>
        inline BIT_ENUM_t cBits::Highest1Bit<UINT64>(UINT64 nMask) noexcept
        {
                // Use intrinsic function
                DWORD nRet;
                if (::_BitScanReverse64(&nRet, nMask))
                        return (BIT_ENUM_t)(nRet + 1);
                return 0;
        }
#endif
        template <>
        inline UINT64 cBits::Rotl<UINT64>(UINT64 nVal, BIT_ENUM_t nBits) noexcept
        {
                return ::_rotl64(nVal, (int)nBits);     
        }
        template <>
        inline UINT64 cBits::Rotr<UINT64>(UINT64 nVal, BIT_ENUM_t nBits) noexcept
        {
                return ::_rotr64(nVal, (int)nBits);     
        }
#endif  // USE_INT64
#endif  // _MSC_VER
 
        template <>
        inline BYTE cBits::Reverse<BYTE>(BYTE nVal) noexcept
        {
#ifdef USE_INT64
                return (BYTE)(((nVal * CUINT64(2, 02020202)) & CUINT64(0108, 84422010)) % 1023);
#else
                return (BYTE)((((nVal * 0x0802LU & 0x22110LU) | (nVal * 0x8020LU & 0x88440LU)) * 0x10101LU) >> 16);
#endif
        }
        template <>
        inline UINT32 cBits::Reverse<UINT32>(UINT32 nVal) noexcept
        {
                nVal = (((nVal & 0xaaaaaaaa) >> 1) | ((nVal & 0x55555555) << 1));
                nVal = (((nVal & 0xcccccccc) >> 2) | ((nVal & 0x33333333) << 2));
                nVal = (((nVal & 0xf0f0f0f0) >> 4) | ((nVal & 0x0f0f0f0f) << 4));
                nVal = (((nVal & 0xff00ff00) >> 8) | ((nVal & 0x00ff00ff) << 8));
                return((nVal >> 16) | (nVal << 16));
        }
 
        template <>
        inline ULONG cBits::Reverse<ULONG>(ULONG nVal) noexcept // static
        {
#ifdef USE_LONG_AS_INT64
                return Reverse<UINT64>(nVal);
#else
                return Reverse<UINT32>(nVal);
#endif
        }
 
        template <typename TYPE = UINT32>
        class GRAYCORE_LINK cBitmask
        {
        protected:
                TYPE m_uVal;
        public:
                cBitmask(TYPE uVal = 0) noexcept : m_uVal(uVal)
                {
                }
                void SetBit(BIT_ENUM_t nBit) noexcept
                {
                        m_uVal = cBits::SetBit(m_uVal, nBit);
                }
                void ClearBit(BIT_ENUM_t nBit) noexcept
                {
                        m_uVal = cBits::ClearBit(m_uVal, nBit);
                }
                bool IsSet(BIT_ENUM_t nBit) const noexcept
                {
                        return cBits::IsSet(m_uVal, nBit);
                }
                operator TYPE () const noexcept
                {
                        return m_uVal;
                }
        };
}
 
#endif  // _INC_cBits_H