bitmask.hpp

 
//                                                                                   //
//  MIT License                                                                      //
//                                                                                   //
//  Copyright (c) 2025 DeadDev                                                       //
//                                                                                   //
//  Permission is hereby granted, free of charge, to any person obtaining a copy     //
//  of this software and associated documentation files (the "Software"), to deal    //
//  in the Software without restriction, including without limitation the rights     //
//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell        //
//  copies of the Software, and to permit persons to whom the Software is            //
//  furnished to do so, subject to the following conditions:                         //
//                                                                                   //
//  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.                                                                        //
//                                                                                   //
 
#ifndef DEADDEV_BITMASK_HPP
#define DEADDEV_BITMASK_HPP
#pragma once
#include <climits>
#include <type_traits>
#include <cstddef>
 
#ifndef DEADDEV_CONSTEVAL
#if __cplusplus >= 202002L
#define DEADDEV_CONSTEVAL consteval
#else
#define DEADDEV_CONSTEVAL constexpr
#endif
#endif
 
#ifndef DEADDEV_NODISCARD
#if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard)
#define DEADDEV_NODISCARD [[nodiscard]]
#else
#define DEADDEV_NODISCARD
#endif
#endif
 
namespace deaddev {
 
namespace details {
 
#ifdef __cpp_lib_is_scoped_enum
template <typename T> constexpr bool is_scoped_enum_v = ::std::is_scoped_enum_v<T>;
#elif defined(__has_builtin) && __has_builtin(__is_scoped_enum)
 
template <typename T> constexpr bool is_scoped_enum_v = __is_scoped_enum(T);
#else
template <typename T>
constexpr bool is_scoped_enum_v =
    ::std::is_enum<T>::value &&
    !::std::is_convertible<T, typename ::std::underlying_type<T>::type>::value;
#endif
 
struct empty_bitmask_traits {
  static constexpr bool enable = false;
  static constexpr size_t all_flags = 0xFFFFFFFFFFFFFFFF;
};
 
template <typename T>
DEADDEV_CONSTEVAL auto combine_flags(::std::underlying_type_t<T> &result, T value)
    -> void {
  result |= static_cast<::std::underlying_type_t<T>>(value);
}
 
#if __cplusplus < 201703L
template <typename T>
DEADDEV_CONSTEVAL auto calculate_all_flags_cpp_before_17(T val) -> T {
  return static_cast<T>(val);
}
template <typename T, typename... Args>
DEADDEV_CONSTEVAL auto calculate_all_flags_cpp_before_17(T arg, Args... args) -> T {
  return static_cast<T>(static_cast<typename ::std::underlying_type<T>::type>(arg) |
                        static_cast<typename ::std::underlying_type<T>::type>(
                            calculate_all_flags_cpp_before_17(args...)));
}
#else
template <typename T, typename... Args>
DEADDEV_CONSTEVAL auto calculate_all_flags_cpp_17(Args... args) -> T {
  ::std::underlying_type_t<T> result{0};
  (::deaddev::details::combine_flags(result, args), ...);
  return static_cast<T>(result);
}
#endif
 
template <typename T, typename... Args>
DEADDEV_CONSTEVAL auto calculate_all_flags(Args... args) -> T {
#if __cplusplus < 201703L
  return calculate_all_flags_cpp_before_17<T>(args...);
#else
  return calculate_all_flags_cpp_17<T>(args...);
#endif
}
template <typename T> DEADDEV_CONSTEVAL auto calculate_all_flags() -> T {
  return static_cast<T>((1ull << ((sizeof(T) * CHAR_BIT) - 1)) - 1); // patched
}
 
template <typename T, T AllFlags> struct bitmask_traits {
  static constexpr bool enable = true;
  static constexpr T all_flags = AllFlags;
};
 
auto adl_bitmask_operations_check(...) -> ::deaddev::details::empty_bitmask_traits;
 
template <typename T>
struct bitmask_operations_check_traits
    : decltype(adl_bitmask_operations_check(::std::declval<T &>())){};
 
template <typename T,
          typename = typename ::std::enable_if<::std::is_enum<T>::value>::type>
constexpr bool is_bitmask_v =
#ifdef DEADDEV_ENABLE_BITMASKS_FOR_SCOPED_ENUMS
    ::deaddev::details::is_scoped_enum_v<T> ||
#endif
    ::deaddev::details::bitmask_operations_check_traits<T>::enable;
 
template <typename T,
          typename = typename ::std::enable_if<::std::is_enum<T>::value>::type>
constexpr T bitmask_all_flags_v =
    ::deaddev::details::bitmask_operations_check_traits<T>::all_flags;
 
} // namespace details
 
template <typename T,
          typename = typename ::std::enable_if<::deaddev::details::is_bitmask_v<T>>::type>
class bitmask {
 
public:
  using mask_type = ::std::underlying_type_t<T>;
  using enum_type = T;
  constexpr bitmask() noexcept = default;
  constexpr bitmask(const bitmask &) noexcept = default;
  constexpr bitmask(bitmask &&) noexcept = default;
  constexpr bitmask &operator=(const bitmask &) noexcept = default;
  constexpr bitmask &operator=(bitmask &&) noexcept = default;
  constexpr bitmask(enum_type value) noexcept : mask_(static_cast<mask_type>(value)) {}
  explicit constexpr bitmask(mask_type value) noexcept : mask_(value) {}
 
  DEADDEV_NODISCARD explicit constexpr operator enum_type() const noexcept {
    return static_cast<enum_type>(mask_);
  }
  DEADDEV_NODISCARD explicit constexpr operator mask_type() const noexcept {
    return mask_;
  }
 
  DEADDEV_NODISCARD DEADDEV_CONSTEVAL static bitmask all_flags() noexcept {
    return bitmask(::deaddev::details::bitmask_all_flags_v<enum_type>);
  }
 
  DEADDEV_NODISCARD constexpr bool operator==(mask_type mask) const noexcept {
    return mask_ == mask;
  }
  DEADDEV_NODISCARD constexpr bool operator!=(mask_type mask) const noexcept {
    return mask_ != mask;
  }
  DEADDEV_NODISCARD constexpr bool operator<=(mask_type mask) const noexcept {
    return mask_ <= mask;
  }
  DEADDEV_NODISCARD constexpr bool operator>=(mask_type mask) const noexcept {
    return mask_ >= mask;
  }
  DEADDEV_NODISCARD constexpr bool operator<(mask_type mask) const noexcept {
    return mask_ < mask;
  }
  DEADDEV_NODISCARD constexpr bool operator>(mask_type mask) const noexcept {
    return mask_ > mask;
  }
  DEADDEV_NODISCARD constexpr bool operator==(bitmask other) const noexcept {
    return mask_ == other.mask_;
  }
  DEADDEV_NODISCARD constexpr bool operator!=(bitmask other) const noexcept {
    return mask_ != other.mask_;
  }
  DEADDEV_NODISCARD constexpr bool operator<=(bitmask other) const noexcept {
    return mask_ <= other.mask_;
  }
  DEADDEV_NODISCARD constexpr bool operator>=(bitmask other) const noexcept {
    return mask_ >= other.mask_;
  }
  DEADDEV_NODISCARD constexpr bool operator<(bitmask other) const noexcept {
    return mask_ < other.mask_;
  }
  DEADDEV_NODISCARD constexpr bool operator>(bitmask other) const noexcept {
    return mask_ > other.mask_;
  }
 
  DEADDEV_NODISCARD constexpr bitmask operator~() const noexcept {
    return bitmask(static_cast<mask_type>(mask_ ^ all_flags().mask_));
  }
 
  DEADDEV_NODISCARD constexpr bitmask operator^(bitmask other) const noexcept {
    return bitmask(mask_ ^ other.mask_);
  }
 
  DEADDEV_NODISCARD constexpr bitmask operator|(bitmask other) const noexcept {
    return bitmask(mask_ | other.mask_);
  }
 
  DEADDEV_NODISCARD constexpr bitmask operator&(bitmask other) const noexcept {
    return bitmask(mask_ & other.mask_);
  }
 
  constexpr bitmask &operator^=(bitmask other) noexcept {
    mask_ ^= other.mask_;
    return *this;
  }
 
  constexpr bitmask &operator|=(bitmask other) noexcept {
    mask_ |= other.mask_;
    return *this;
  }
 
  constexpr bitmask &operator&=(bitmask other) noexcept {
    mask_ &= other.mask_;
    return *this;
  }
 
  DEADDEV_NODISCARD constexpr bitmask operator^(enum_type other) const noexcept {
    return bitmask(mask_ ^ static_cast<mask_type>(other));
  }
 
  DEADDEV_NODISCARD constexpr bitmask operator|(enum_type other) const noexcept {
    return bitmask(mask_ | static_cast<mask_type>(other));
  }
 
  DEADDEV_NODISCARD constexpr bitmask operator&(enum_type other) const noexcept {
    return bitmask(mask_ & static_cast<mask_type>(other));
  }
 
  constexpr bitmask &operator^=(enum_type other) noexcept {
    mask_ ^= static_cast<mask_type>(other);
    return *this;
  }
 
  constexpr bitmask &operator|=(enum_type other) noexcept {
    mask_ |= static_cast<mask_type>(other);
    return *this;
  }
 
  constexpr bitmask &operator&=(enum_type other) noexcept {
    mask_ &= static_cast<mask_type>(other);
    return *this;
  }
 
  DEADDEV_NODISCARD constexpr bool is_set(enum_type flag) const noexcept {
    return (mask_ & static_cast<mask_type>(flag)) == static_cast<mask_type>(flag);
  }
 
  DEADDEV_NODISCARD constexpr bool is_set(bitmask other) const noexcept {
    return (mask_ & other.mask_) == other.mask_;
  }
 
  constexpr bitmask &set(enum_type flag) noexcept { return *this |= flag; }
 
  constexpr bitmask &set(bitmask other) noexcept { return *this |= other.mask_; }
 
  constexpr bitmask &remove(enum_type flag) noexcept { return *this ^= flag; }
 
  constexpr bitmask &remove(bitmask other) noexcept { return *this ^= other.mask_; }
 
private:
  mask_type mask_{};
};
 
} // namespace deaddev
 
// Out of namespace because of ADL
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator==(T left, deaddev::bitmask<T> right) noexcept {
  return right == left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator!=(T left, deaddev::bitmask<T> right) noexcept {
  return right != left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator>=(T left, deaddev::bitmask<T> right) noexcept {
  return right <= left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator<=(T left, deaddev::bitmask<T> right) noexcept {
  return right >= left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator<(T left, deaddev::bitmask<T> right) noexcept {
  return right > left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator>(T left, deaddev::bitmask<T> right) noexcept {
  return right < left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator==(typename std::underlying_type<T>::type left,
                                            deaddev::bitmask<T> right) noexcept {
  return right == left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator!=(typename std::underlying_type<T>::type left,
                                            deaddev::bitmask<T> right) noexcept {
  return right != left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator>=(typename std::underlying_type<T>::type left,
                                            deaddev::bitmask<T> right) noexcept {
  return right <= left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator<=(typename std::underlying_type<T>::type left,
                                            deaddev::bitmask<T> right) noexcept {
  return right >= left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator<(typename std::underlying_type<T>::type left,
                                           deaddev::bitmask<T> right) noexcept {
  return right > left; // reversed order
}
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr bool operator>(typename std::underlying_type<T>::type left,
                                           deaddev::bitmask<T> right) noexcept {
  return right < left; // reversed order
}
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr deaddev::bitmask<T> operator~(T flag) noexcept {
  return ~deaddev::bitmask<T>(flag);
}
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr deaddev::bitmask<T> operator^(T left, T right) noexcept {
  return deaddev::bitmask<T>(left) ^ right;
}
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr deaddev::bitmask<T> operator|(T left, T right) noexcept {
  return deaddev::bitmask<T>(left) | right;
}
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr deaddev::bitmask<T> operator&(T left, T right) noexcept {
  return deaddev::bitmask<T>(left) & right;
}
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr deaddev::bitmask<T> operator^(T left, ::deaddev::bitmask<T> right) noexcept {
  return right ^ left;
}
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr deaddev::bitmask<T> operator|(T left, ::deaddev::bitmask<T> right) noexcept {
  return right | left;
}
 
template <typename T, typename = ::std::enable_if<::deaddev::details::is_bitmask_v<T>>>
DEADDEV_NODISCARD constexpr deaddev::bitmask<T> operator&(T left, ::deaddev::bitmask<T> right) noexcept {
  return right & left;
}
 
#define DEADDEV_ENABLE_BITMASK(T, ...)                                                   \
  auto adl_bitmask_operations_check(T &) -> ::deaddev::details::bitmask_traits<          \
      T, ::deaddev::details::calculate_all_flags<T>(__VA_ARGS__)>;
 
#define DEADDEV_ENABLE_BITMASK_EXTERNAL(T, ...)                                          \
  template <>                                                                            \
  struct ::deaddev::details::bitmask_operations_check_traits<T>                          \
      : ::deaddev::details::bitmask_traits<                                              \
            T, ::deaddev::details::calculate_all_flags<T>(__VA_ARGS__)> {};
 
#endif // DEADDEV_BITMASK_HPP