flags.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup numapp
 * @brief Contains definitions for bitwise operators for enums
 * @copyright
 *   SPDX-FileCopyrightText: 2021-2021 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#ifndef NUMAPP_FLAGS_HPP_
#define NUMAPP_FLAGS_HPP_
#include <type_traits>
 
/**
 * Enables numapp bitwise operators in overload set for the specified enumeration @a enum.
 *
 * @note This macro must be used inside the namespace @c numapp.
 */
#define NUMAPP_ENABLE_BITFLAG(enum) \
    template <>\
    struct IsFlagEnum<enum> : std::true_type { \
        static_assert(std::is_enum_v<enum>); \
    };
 
namespace numapp {
// @cond INTERNAL
namespace detail {
template<class Enum>
constexpr std::underlying_type_t<Enum> ToUnderlying(Enum value) noexcept {
    return static_cast<std::underlying_type_t<Enum>>(value);
}
template<class Enum>
constexpr Enum FromUnderlying(std::underlying_type_t<Enum> value) noexcept {
    return static_cast<Enum>(value);
}
} // namespace detail
// @endcond
 
/**
 * Trait type that should be specialized for an enumeration to enable use of bitwise operators.
 *
 * @note Use macro NUMAPP_ENABLE_BITFLAG instead.
 *
 * Example to enable Flags for enum MyEnum:
 *
 *    namespace numapp {
 *    template<>
 *    struct IsFlagEnum<MyEnum> : std::true_type {};
 *    }
 */
template <class Enum>
struct IsFlagEnum;
 
 
/**
 * @name Bitwise operators for enabled enums
 *
 * Convenience function to compose bit flags using bitwise OR and AND operators.
 *
 * Example:
 *
 * @code
 *     using numapp::operator|; // Bring in numapp::operator| in this scope
 *
 *     MyEnum f = MyEnum::A | MyEnum::B;
 *     f &= MyEnum::A;
 *     MyFunc(f);
 *     MyFunc(MyEnum::A | MyEnum::B);
 * @endcode
 */
// @{
/**
 * @returns logical OR between @a lhs and @a rhs
 */
template <class Enum, typename = typename std::enable_if<IsFlagEnum<Enum>::value>::type>
[[nodiscard]] constexpr Enum operator|(Enum lhs, Enum rhs) noexcept {
    return detail::FromUnderlying<Enum>(detail::ToUnderlying(lhs) | detail::ToUnderlying(rhs));
}
 
/**
 * Sets @a lhs with logical OR between @a lhs and @a rhs
 */
template <class Enum, typename = typename std::enable_if<IsFlagEnum<Enum>::value>::type>
constexpr Enum& operator|=(Enum& lhs, Enum rhs) noexcept {
    lhs = lhs | rhs;
    return lhs;
}
 
/**
 * @returns logical AND between @a lhs and @a rhs
 */
template <class Enum, typename = typename std::enable_if<IsFlagEnum<Enum>::value>::type>
[[nodiscard]] constexpr Enum operator&(Enum lhs, Enum rhs) noexcept {
    return detail::FromUnderlying<Enum>(detail::ToUnderlying(lhs) & detail::ToUnderlying(rhs));
}
 
/**
 * Sets @a lhs with logical AND between @a lhs and @a rhs
 */
template <class Enum, typename = typename std::enable_if<IsFlagEnum<Enum>::value>::type>
constexpr Enum& operator&=(Enum& lhs, Enum rhs) noexcept {
    lhs = lhs & rhs;
    return lhs;
}
// @}
 
}  // namespace numapp
#endif  // #define NUMAPP_FLAGS_HPP_