flag.hpp

#pragma once
 
#include "namespace.hpp"
#include <type_traits>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <typename T>
  struct enum_flag_type : std::false_type
  {
  };
 
  template <typename T, typename std::enable_if_t<enum_flag_type<T>::value> * = nullptr>
  inline constexpr T operator|(T lhs, T rhs) noexcept
  {
    return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) | static_cast<std::underlying_type_t<T>>(rhs));
  }
 
  template <typename T, typename std::enable_if_t<enum_flag_type<T>::value> * = nullptr>
  inline constexpr T &operator|=(T &lhs, T rhs) noexcept
  {
    lhs = operator|(lhs, rhs);
    return lhs;
  }
 
  template <typename T, typename std::enable_if_t<enum_flag_type<T>::value> * = nullptr>
  inline constexpr T operator&(T lhs, T rhs) noexcept
  {
    return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) & static_cast<std::underlying_type_t<T>>(rhs));
  }
 
  template <typename T, typename std::enable_if_t<enum_flag_type<T>::value> * = nullptr>
  inline constexpr T &operator&=(T &lhs, T rhs) noexcept
  {
    lhs = operator&(lhs, rhs);
    return lhs;
  }
 
  template <typename T, typename std::enable_if_t<enum_flag_type<T>::value> * = nullptr>
  inline constexpr T operator~(T lhs) noexcept
  {
    return static_cast<T>(~static_cast<std::underlying_type_t<T>>(lhs));
  }
 
  template <typename T, typename std::enable_if_t<enum_flag_type<T>::value> * = nullptr>
  inline constexpr T operator^(T lhs, T rhs) noexcept
  {
    return static_cast<T>(static_cast<std::underlying_type_t<T>>(lhs) ^ static_cast<std::underlying_type_t<T>>(rhs));
  }
 
  template <typename T, typename std::enable_if_t<enum_flag_type<T>::value> * = nullptr>
  inline constexpr T &operator^=(T &lhs, T rhs) noexcept
  {
    lhs = operator^(lhs, rhs);
    return lhs;
  }
 
  CVB_END_INLINE_NS
}  // namespace Cvb
 
using Cvb::operator|;
using Cvb::operator|=;
using Cvb::operator&;
using Cvb::operator&=;
using Cvb::operator~;
using Cvb::operator^;
using Cvb::operator^=;