Bitmask.h

//
//  Bitmask.h
//  avara3d
//
//  Created by Morgan Davis on 1/6/26.
//  Copyright © 2026 Morgan K Davis. All rights reserved.
//
 
#ifndef AVARA3D_UTIL_BITMASK_H
#define AVARA3D_UTIL_BITMASK_H
 
#include <type_traits>
 
namespace a3d::util::bitmask {
 
// [Internal Types]
 
// unsigned underlying type used for bitwise ops.
template<typename E>
using U = std::make_unsigned_t<std::underlying_type_t<E>>;
 
// [Internal Functions]
 
// converts enum to its underlying integer type (unsigned for bitwise ops).
template<typename E>
constexpr U<E> to_uint(E e) noexcept {
    static_assert(std::is_enum_v<E>, "a3d::util::bitmask::to_uint() requires an enum type");
    return static_cast<U<E>>(static_cast<std::underlying_type_t<E>>(e));
}
 
// true if ANY bits in 'bits' are set in 'value'
template<typename E>
constexpr bool any(E value, E bits) noexcept {
    return (to_uint(value) & to_uint(bits)) != 0;
}
 
// true if ALL bits in 'bits' are set in 'value'
template<typename E>
constexpr bool all(E value, E bits) noexcept {
    const auto v = to_uint(value);
    const auto b = to_uint(bits);
    return (v & b) == b;
}
 
// [Public Functions]
 
template<typename E>
constexpr bool contains(E value, E bits) noexcept {
    return any(value, bits);
}
 
template<typename E>
constexpr bool contains_all(E value, E bits) noexcept {
    return all(value, bits);
}
 
template<typename E>
constexpr E add(E value, E bits) noexcept {
    return static_cast<E>(to_uint(value) | to_uint(bits));
}
 
template<typename E>
constexpr E remove(E value, E bits) noexcept {
    return static_cast<E>(to_uint(value) & ~to_uint(bits));
}
 
template<typename E>
constexpr void add_inplace(E& value, E bits) noexcept {
    value = add(value, bits);
}
 
template<typename E>
constexpr void remove_inplace(E& value, E bits) noexcept {
    value = remove(value, bits);
}
 
// [Internal Bitmask Operator Support]
 
template<typename E>
struct enable_ops : std::false_type {};
 
template<typename E>
constexpr bool enable_ops_v = enable_ops<E>::value;
 
template<typename E>
concept MaskEnum = std::is_enum_v<E> && enable_ops_v<E>;
 
} // namespace a3d::util::bitmask
 
namespace a3d {
 
// [Public Non-Member Functions]
 
template<util::bitmask::MaskEnum E>
constexpr E operator|(E a, E b) noexcept {
    return static_cast<E>(util::bitmask::to_uint(a) | util::bitmask::to_uint(b));
}
 
template<util::bitmask::MaskEnum E>
constexpr E operator&(E a, E b) noexcept {
    return static_cast<E>(util::bitmask::to_uint(a) & util::bitmask::to_uint(b));
}
 
template<util::bitmask::MaskEnum E>
constexpr E operator^(E a, E b) noexcept {
    return static_cast<E>(util::bitmask::to_uint(a) ^ util::bitmask::to_uint(b));
}
 
template<util::bitmask::MaskEnum E>
constexpr E operator~(E a) noexcept {
    return static_cast<E>(~util::bitmask::to_uint(a));
}
 
template<util::bitmask::MaskEnum E>
constexpr E& operator|=(E& a, E b) noexcept {
    return a = (a | b);
}
 
template<util::bitmask::MaskEnum E>
constexpr E& operator&=(E& a, E b) noexcept {
    return a = (a & b);
}
 
template<util::bitmask::MaskEnum E>
constexpr E& operator^=(E& a, E b) noexcept {
    return a = (a ^ b);
}
 
} // namespace a3d
 
#endif // AVARA3D_UTIL_BITMASK_H