BitFlag.hpp

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: BitFlag
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/LibAssert.h>
namespace NDEVR
{
    class BitFlag
    {
    protected:
        static constexpr uint01 kBitMask[8] = {
            0x01, // 0000 0001
            0x02, // 0000 0010
            0x04, // 0000 0100
            0x08, // 0000 1000
            0x10, // 0001 0000
            0x20, // 0010 0000
            0x40, // 0100 0000
            0x80  // 1000 0000
        };
        static constexpr uint01 kBitMaskInv[8] = {
            0xFE, // 1111 1110
            0xFD, // 1111 1101
            0xFB, // 1111 1011
            0xF7, // 1111 0111
            0xEF, // 1110 1111
            0xDF, // 1101 1111
            0xBF, // 1011 1111
            0x7F  // 0111 1111
        };
    public:
        constexpr BitFlag()
            : m_bits(0)
        {}
        constexpr BitFlag(sint04 flags)
            : m_bits(cast<uint01>(flags))
        {
            lib_assert(flags <= 255, "Bad bitflag");
        }
        constexpr BitFlag(uint01 flags)
            : m_bits(flags)
        {}
        explicit constexpr BitFlag(bool flag)
            : m_bits(flag ? 255U : 0U)
        {}
 
        template<class t_type>
        BitFlag(std::initializer_list<t_type> active_list)
            : m_bits(0)
        {
            for (auto i : active_list)
                (*this)(cast<uint01>(i), true);
        }

        constexpr bool operator[](uint01 bit_index) const
        {
            lib_assert(bit_index < 8, "Tried to access large bit value");
            return (m_bits & kBitMask[bit_index]) != 0;
        }

        constexpr void operator()(const uint01 bit_index, bool value)
        {
            if (value)
                m_bits |= kBitMask[bit_index];
            else
                m_bits &= kBitMaskInv[bit_index];
        }

        constexpr operator uint01() const
        {
            return m_bits;
        }

        constexpr void operator|=(const BitFlag& mask)
        {
            m_bits |= mask.m_bits;
        }
 
 
        constexpr void operator^=(const BitFlag& mask)
        {
            m_bits ^= mask.m_bits;
        }

        constexpr void operator&=(const BitFlag& mask)
        {
            m_bits &= mask.m_bits;
        }

        constexpr void operator&=(uint01 mask)
        {
            m_bits &= mask;
        }

        constexpr BitFlag operator&(const BitFlag& mask) const
        {
            return BitFlag(cast<uint01>(m_bits & mask.m_bits));
        }

        constexpr BitFlag operator^(const BitFlag& mask) const
        {
            return BitFlag(cast<uint01>(m_bits ^ mask.m_bits));
        }

        constexpr BitFlag operator&(uint01 mask) const
        {
            return BitFlag(cast<uint01>(m_bits & mask));
        }

        constexpr BitFlag operator^(uint01 mask) const
        {
            return BitFlag(cast<uint01>(m_bits ^ mask));
        }

        constexpr BitFlag operator~() const
        {
            return BitFlag(cast<uint01>(~m_bits));
        }
 
 
        constexpr bool operator!=(const BitFlag& other) const
        {
            return m_bits != other.m_bits;
        }
        constexpr bool operator==(const BitFlag& other) const
        {
            return m_bits == other.m_bits;
        }

        constexpr static BitFlag merge(const BitFlag& value_a, const BitFlag& value_b, const BitFlag& mask)
        {
            return value_b ^ ((value_b ^ value_a) & mask);
        }

        constexpr static BitFlag merge(const BitFlag& value_a, const BitFlag& value_b, uint01 num_of_bits)
        {
            const uint01 mask = cast<uint01>((1U << (num_of_bits + 1U)) - 1U);
            return value_b ^ ((value_b ^ value_a) & mask);
        }
 
        [[nodiscard]] uint01 bits() const
        {
            return m_bits;
        }
    private:
        uint01 m_bits;
    };
}
#ifdef _MSC_VER
//Used to help debuging
namespace natvis
{
    struct b4lo { unsigned __int8 v : 4;    unsigned __int8 _ : 4; };  // NOLINT(clang-diagnostic-language-extension-token)
    struct b4hi { unsigned __int8 _ : 4;    unsigned __int8 v : 4; };  // NOLINT(clang-diagnostic-language-extension-token)
    struct b8 { unsigned __int8 _; }; // NOLINT(clang-diagnostic-language-extension-token)
    struct b32 { __int32 _; }; // NOLINT(clang-diagnostic-language-extension-token)
}
#endif