Bitmask.hpp

Go to the documentation of this file.

 
//                Copyright Oliver J. Rosten 2022.                //
// Distributed under the GNU GENERAL PUBLIC LICENSE, Version 3.0. //
//    (See accompanying file LICENSE.md or copy at                //
//          https://www.gnu.org/licenses/gpl-3.0.en.html)         //
 
#pragma once
 
#include <type_traits>
 
#ifdef EXPOSE_SEQUOIA_BITMASK
#define NAMESPACE_SEQUOIA_AS_BITMASK inline namespace sequoia_bitmask
#else
#define NAMESPACE_SEQUOIA_AS_BITMASK namespace sequoia
#endif
 
NAMESPACE_SEQUOIA_AS_BITMASK
{
 
  template<class T>
    requires std::is_enum_v<T>
  struct as_bitmask : std::false_type
  {};
 
  template<class T>
    requires std::is_enum_v<T>
  using as_bitmask_t = typename as_bitmask<T>::type;
 
  template<class T>
    requires std::is_enum_v<T>
  constexpr bool as_bitmask_v{as_bitmask<T>::value};
 
  template<class T>
    requires as_bitmask_v<T>
  [[nodiscard]]
  constexpr T operator|(T lhs, T rhs) noexcept
  {
    using underlying = std::underlying_type_t<T>;
    return static_cast<T>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
  }
 
  template<class T>
    requires as_bitmask_v<T>
  constexpr T& operator|=(T& lhs, T rhs) noexcept
  {
    lhs = lhs | rhs;
    return lhs;
  }
 
  template<class T>
    requires as_bitmask_v<T>
  [[nodiscard]]
  constexpr T operator&(T lhs, T rhs) noexcept
  {
    using underlying = std::underlying_type_t<T>;
    return static_cast<T>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
  }
 
  template<class T>
    requires as_bitmask_v<T>
  constexpr T& operator&=(T& lhs, T rhs) noexcept
  {
    lhs = lhs & rhs;
    return lhs;
  }
 
  template<class T>
    requires as_bitmask_v<T>
  [[nodiscard]]
  constexpr T operator^(T lhs, T rhs) noexcept
  {
    using underlying = std::underlying_type_t<T>;
    return static_cast<T>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
  }
 
  template<class T>
    requires as_bitmask_v<T>
  constexpr T& operator^=(T& lhs, T rhs) noexcept
  {
    lhs = lhs ^ rhs;
    return lhs;
  }
 
  template<class T>
    requires as_bitmask_v<T>
  [[nodiscard]]
  constexpr T operator~(T om)
  {
    using underlying = std::underlying_type_t<T>;
    return static_cast<T>(~static_cast<underlying>(om));
  }
}