bitmask.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
/*
 */
#include <type_traits>
 
 
#ifndef CXXUTILS_BITMASK_H
#define CXXUTILS_BITMASK_H
 
 
#define ATH_BITMASK IS_ATH_BITMASK=1
 
 
namespace {
 
  template <typename T, bool = std::is_enum_v<T>>
  struct relaxed_underlying_type {
    using type = std::underlying_type_t<T>;
  };
  template <typename T>
  struct relaxed_underlying_type<T, false> {
    using type = T;
  };
  template <class T>
  using relaxed_underlying_type_t = typename relaxed_underlying_type<T>::type;
 
  template <class E, class F>
  constexpr bool has_same_underlying_v = std::is_same_v<relaxed_underlying_type_t<E>,
                                                        relaxed_underlying_type_t<F>>;
 
  template <class E, class F>
  struct enum_or_underlying {
    using type = std::conditional_t<std::is_same_v<E,F> && has_same_underlying_v<E,F>,
                                    E, relaxed_underlying_type_t<E>>;
  };
  template <class E, class F>
  using enum_or_underlying_t = typename enum_or_underlying<E,F>::type;
 
  template <class E, typename Enable = void>
  constexpr bool is_bitmask_v = false;
 
#ifdef __CUDACC__
# pragma nv_diagnostic push
// expression has no effect
# pragma nv_diag_suppress 174
#endif
  template <class E>
  constexpr bool is_bitmask_v<E, std::enable_if_t<(E::IS_ATH_BITMASK,1)>> = true;
#ifdef __CUDACC__
# pragma nv_diagnostic pop
#endif
}
 
 
/*
 * Define bitwise operators for class enums.
 * These all cast the operands to the underlying type, and then cast
 * the result back again to the enumeration.
 *
 * These functions are enabled only for enumerators that have used the
 * @c ATH_BITMASK macro.
 */
 
template <class E>
constexpr
std::enable_if_t<is_bitmask_v<E>, E>
operator~ (E lhs)
{
  typedef std::underlying_type_t<E> underlying;
  return static_cast<E> (~static_cast<underlying>(lhs));
}
 
 
template <class E, class F,
          typename = std::enable_if_t<(is_bitmask_v<E> || is_bitmask_v<F>) &&
                                      has_same_underlying_v<E,F>>>
constexpr auto operator& (E lhs, F rhs)
{
  typedef relaxed_underlying_type_t<E> underlying;
  return static_cast<enum_or_underlying_t<E,F>>(static_cast<underlying>(lhs) &
                                                static_cast<underlying>(rhs));
}
 
 
template <class E, class F,
          typename = std::enable_if_t<(is_bitmask_v<E> || is_bitmask_v<F>) &&
                                      has_same_underlying_v<E,F>>>
constexpr auto operator| (E lhs, F rhs)
{
  typedef relaxed_underlying_type_t<E> underlying;
  return static_cast<enum_or_underlying_t<E,F>>(static_cast<underlying>(lhs) |
                                                static_cast<underlying>(rhs));
}
 
 
template <class E, class F,
          typename = std::enable_if_t<(is_bitmask_v<E> || is_bitmask_v<F>) &&
                                      has_same_underlying_v<E,F>>>
constexpr auto operator^ (E lhs, F rhs)
{
  typedef relaxed_underlying_type_t<E> underlying;
  return static_cast<enum_or_underlying_t<E,F>>(static_cast<underlying>(lhs) ^
                                                static_cast<underlying>(rhs));
}
 
 
template <class E>
constexpr
std::enable_if_t<is_bitmask_v<E>, E&>
operator&= (E& lhs, E rhs)
{
  typedef std::underlying_type_t<E> underlying;
  lhs = static_cast<E> (static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
  return lhs;
}
 
 
template <class E>
constexpr
std::enable_if_t<is_bitmask_v<E>, E&>
operator|= (E& lhs, E rhs)
{
  typedef std::underlying_type_t<E> underlying;
  lhs = static_cast<E> (static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
  return lhs;
}
 
 
template <class E>
constexpr
std::enable_if_t<is_bitmask_v<E>, E&>
operator^= (E& lhs, E rhs)
{
  typedef std::underlying_type_t<E> underlying;
  lhs = static_cast<E> (static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
  return lhs;
}
 
 
namespace CxxUtils {
 
 
template <class E>
constexpr
std::enable_if_t<is_bitmask_v<E>, E&>
set (E& lhs, E rhs)
{
  lhs |= rhs;
  return lhs;
}
 
 
template <class E>
constexpr
std::enable_if_t<is_bitmask_v<E>, E&>
reset (E& lhs, E rhs)
{
  lhs &= ~rhs;
  return lhs;
}
 
 
template <class E>
constexpr
std::enable_if_t<is_bitmask_v<E>, bool>
test (E lhs, E rhs)
{
  typedef std::underlying_type_t<E>underlying;
  return static_cast<underlying> (lhs & rhs) != 0;
}
 
 
} // namespace CxxUtils
 
 
#endif // not CXXUTILS_BITMASK_H