BitField.h

/*
 * Copyright 2022 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <limits>
#include <type_traits>
 
namespace lagrange {
 
 
template <typename EnumType_>
class BitField
{
public:
    using EnumType = EnumType_;
 
    using UnderlyingType = std::underlying_type_t<EnumType>;
 
    constexpr BitField()
        : m_bits(0)
    {}
 
    constexpr BitField(EnumType value)
        : m_bits(static_cast<UnderlyingType>(value))
    {}
 
    constexpr BitField(UnderlyingType bits)
        : m_bits(bits)
    {}
 
    constexpr static BitField none() { return BitField(); }
 
    constexpr static BitField all() { return ~BitField(); }
 
    constexpr void set(const BitField& other) { m_bits |= other.m_bits; }
 
    constexpr void clear(const BitField& other) { m_bits &= ~other.m_bits; }
 
    constexpr void clear_all() { m_bits = UnderlyingType(0); }
 
    constexpr bool test(const BitField& other) const
    {
        return (m_bits & other.m_bits) == other.m_bits;
    }
 
    constexpr bool test_any(const BitField& other) const { return (m_bits & other.m_bits) != 0; }
 
    constexpr void set_bit(const BitField& other, bool is_set)
    {
        if (is_set) {
            set(other);
        } else {
            clear(other);
        }
    }
 
    constexpr operator UnderlyingType() const { return m_bits; }
 
    constexpr const UnderlyingType& get_value() const { return m_bits; }
 
    constexpr bool operator==(const BitField& other) const { return m_bits == other.m_bits; }
 
    constexpr bool operator!=(const BitField& other) const { return m_bits != other.m_bits; }
 
    constexpr BitField operator|(const BitField& other) const
    {
        return BitField(m_bits | other.m_bits);
    }
 
    constexpr BitField operator&(const BitField& other) const
    {
        return BitField(m_bits & other.m_bits);
    }
 
    constexpr BitField operator^(const BitField& other) const
    {
        return BitField(m_bits ^ other.m_bits);
    }
 
    constexpr BitField operator~() const { return BitField(~m_bits); }
 
private:
    static_assert(std::is_enum_v<EnumType>);
 
    UnderlyingType m_bits = UnderlyingType(0);
};
 
 
} // namespace lagrange