bitfield.hpp

Go to the documentation of this file.

 
#ifndef EAGINE_BITFIELD_HPP
#define EAGINE_BITFIELD_HPP
 
#include "all_are_same.hpp"
 
namespace eagine {
 
template <typename Bit>
class bitfield {
public:
    using bit_type = Bit;
 
    using value_type = std::make_unsigned_t<std::underlying_type_t<bit_type>>;
 
    constexpr bitfield() noexcept = default;
 
    constexpr explicit bitfield(value_type bits) noexcept
      : _bits{bits} {}
 
    constexpr bitfield(bit_type _bit) noexcept
      : _bits{value_type(_bit)} {}
 
    constexpr bitfield(bit_type _bit_a, bit_type _bit_b) noexcept
      : _bits(value_type(_bit_a) | value_type(_bit_b)) {}
 
    constexpr auto is_empty() const noexcept {
        return _bits == value_type(0);
    }
 
    explicit constexpr operator bool() const noexcept {
        return _bits != value_type(0);
    }
 
    explicit constexpr operator value_type() const noexcept {
        return _bits;
    }
 
    constexpr auto bits() const noexcept -> value_type {
        return _bits;
    }
 
    constexpr auto has(bit_type bit) const noexcept {
        return (_bits & value_type(bit)) == value_type(bit);
    }
 
    constexpr auto has_not(bit_type bit) const noexcept {
        return (_bits & value_type(bit)) != value_type(bit);
    }
 
    template <typename... B>
    constexpr auto has_all(bit_type bit, B... bits) const noexcept
      -> std::enable_if_t<all_are_same_v<bit_type, B...>, bool> {
        return (has(bit) && ... && has(bits));
    }
 
    template <typename... B>
    constexpr auto has_any(bit_type bit, B... bits) const noexcept
      -> std::enable_if_t<all_are_same_v<bit_type, B...>, bool> {
        return (has(bit) || ... || has(bits));
    }
 
    template <typename... B>
    constexpr auto has_none(bit_type bit, B... bits) const noexcept
      -> std::enable_if_t<all_are_same_v<bit_type, B...>, bool> {
        return (has_not(bit) && ... && has_not(bits));
    }
 
    constexpr auto has_only(bit_type bit) const noexcept {
        return _bits == value_type(bit);
    }
 
    constexpr auto has_at_most(bit_type bit) const noexcept {
        return is_empty() || has_only(bit);
    }
 
    friend constexpr auto operator==(bitfield a, bitfield b) noexcept {
        return a._bits == b._bits;
    }
 
    friend constexpr auto operator!=(bitfield a, bitfield b) noexcept {
        return a._bits != b._bits;
    }
 
    friend constexpr auto operator|(bitfield a, bitfield b) noexcept
      -> bitfield {
        return bitfield(a._bits | b._bits);
    }
 
    auto operator|=(bitfield b) noexcept -> bitfield& {
        _bits |= b._bits;
        return *this;
    }
 
    friend constexpr auto operator&(bitfield a, bitfield b) noexcept
      -> bitfield {
        return bitfield(a._bits & b._bits);
    }
 
    auto operator&=(bitfield b) noexcept -> bitfield& {
        _bits &= b._bits;
        return *this;
    }
 
    friend constexpr auto operator~(bitfield b) noexcept -> bitfield {
        return bitfield{value_type(~b._bits)};
    }
 
    auto clear(bit_type b) noexcept -> bitfield& {
        _bits &= ~value_type(b); // NOLINT(hicpp-signed-bitwise)
        return *this;
    }
 
    auto clear() noexcept -> bitfield& {
        _bits = value_type(0);
        return *this;
    }
 
private:
    value_type _bits{0U};
};
 
} // namespace eagine
 
#endif // EAGINE_BITFIELD_HPP