mgl_bit.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_BIT_H_1610068077
#define INCGUARD_MGL_BIT_H_1610068077
 
#include <cstdint>
#include <type_traits>
 
namespace MGL
{
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
template<typename T>
constexpr T MakeBit(uint8_t bit) noexcept
{
    return static_cast<T>(1u << bit);
}
 
 
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
template<class EnumType, typename FlagType = uint32_t>
class EnumBitFlags
{
public:
    using UnderlyingType = std::underlying_type_t<EnumType>;
 
    static constexpr size_t kSize = sizeof(FlagType) * 8;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags() noexcept
        : _value(0)
    {
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags(EnumType value) noexcept
        : _value(FlagType(1u << UnderlyingType(value)))
    {
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr explicit EnumBitFlags(FlagType value) noexcept
        : _value(value)
    {
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const FlagType &GetValue() const noexcept
    {
        return _value;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool Has(EnumType value) const noexcept
    {
        return _value & FlagType(1u << UnderlyingType(value));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool HasAny() const noexcept
    {
        return _value != 0;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &Set(EnumType value) noexcept
    {
        _value |= FlagType(1u << UnderlyingType(value));
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &Clear(EnumType value) noexcept
    {
        _value &= ~FlagType(1u << UnderlyingType(value));
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &Clear() noexcept
    {
        _value = 0;
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &Flip(EnumType value) noexcept
    {
        _value ^= FlagType(1 << UnderlyingType(value));
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &Flip() noexcept
    {
        _value = ~_value;
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr explicit operator bool() const noexcept
    {
        return _value != 0;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr bool operator!() const noexcept
    {
        return _value == 0;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &operator|=(EnumType rhs) noexcept
    {
        _value |= FlagType(1 << UnderlyingType(rhs));
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &operator|=(const EnumBitFlags &rhs) noexcept
    {
        _value |= rhs._value;
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &operator&=(EnumType rhs) noexcept
    {
        _value &= FlagType(1 << UnderlyingType(rhs));
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &operator&=(const EnumBitFlags &rhs) noexcept
    {
        _value &= rhs._value;
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &operator^=(EnumType rhs) noexcept
    {
        _value ^= FlagType(1 << UnderlyingType(rhs));
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags &operator^=(const EnumBitFlags &rhs) noexcept
    {
        _value ^= rhs._value;
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags operator|(EnumType rhs) const noexcept
    {
        return EnumBitFlags(_value | FlagType(1u << UnderlyingType(rhs)));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags operator|(const EnumBitFlags &rhs) const noexcept
    {
        return EnumBitFlags(_value | rhs._value);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags operator&(EnumType rhs) const noexcept
    {
        return EnumBitFlags(_value & FlagType(1u << UnderlyingType(rhs)));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags operator&(const EnumBitFlags &rhs) const noexcept
    {
        return EnumBitFlags(_value & rhs._value);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags operator^(EnumType rhs) const noexcept
    {
        return EnumBitFlags(_value ^ FlagType(1u << UnderlyingType(rhs)));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags operator^(const EnumBitFlags &rhs) const noexcept
    {
        return EnumBitFlags(_value ^ rhs._value);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr EnumBitFlags operator~() const noexcept
    {
        return EnumBitFlags(~_value);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr bool operator==(const EnumBitFlags &rhs) const noexcept
    {
        return _value == rhs._value;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr bool operator!=(const EnumBitFlags &rhs) const noexcept
    {
        return _value != rhs._value;
    }
 
private:
    FlagType _value;
};
}    // namespace MGL
#endif    // INCGUARD_MGL_BIT_H_1610068077
 
// vim: et ts=4 sw=4 sts=4