UT_EnumHelper.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_EnumHelper.h
 *
 * COMMENTS:
 *      Simple system to enable bitflag operators on a strong enum.
 */

#ifndef __UT_ENUMHELPER_H__
#define __UT_ENUMHELPER_H__

#include <type_traits>

#define UT_STATIC_CHECK_ENUM(name)                                             \
    static_assert(std::is_enum<name>::value, "Enum type must be used.");

template <typename T>
struct UT_EnableBitMask
{
    static constexpr bool enable = false;
};

template <typename T>
typename std::enable_if<UT_EnableBitMask<T>::enable, T>::type
operator|(T lhs, T rhs)
{
    UT_STATIC_CHECK_ENUM(T);
    using U = typename std::underlying_type<T>::type;
    return static_cast<T>(static_cast<U>(lhs) | static_cast<U>(rhs));
}

template <typename T>
typename std::enable_if<UT_EnableBitMask<T>::enable, T&>::type
operator|=(T& lhs, T rhs)
{
    UT_STATIC_CHECK_ENUM(T);
    using U = typename std::underlying_type<T>::type;
    lhs = static_cast<T>(static_cast<U>(lhs) | static_cast<U>(rhs));
    return lhs;
}

template <typename T>
typename std::enable_if<UT_EnableBitMask<T>::enable, T>::type operator&(
        T lhs,
        T rhs)
{
    UT_STATIC_CHECK_ENUM(T);
    using U = typename std::underlying_type<T>::type;
    return static_cast<T>(static_cast<U>(lhs) & static_cast<U>(rhs));
}

template <typename T>
typename std::enable_if<UT_EnableBitMask<T>::enable, T&>::type
operator&=(T& lhs, T rhs)
{
    UT_STATIC_CHECK_ENUM(T);
    using U = typename std::underlying_type<T>::type;
    lhs = static_cast<T>(static_cast<U>(lhs) & static_cast<U>(rhs));
    return lhs;
}

template <typename T>
typename std::enable_if<UT_EnableBitMask<T>::enable, T>::type
operator^(T lhs, T rhs)
{
    UT_STATIC_CHECK_ENUM(T);
    using U = typename std::underlying_type<T>::type;
    return static_cast<T>(static_cast<U>(lhs) ^ static_cast<U>(rhs));
}

template <typename T>
typename std::enable_if<UT_EnableBitMask<T>::enable, T&>::type
operator^=(T& lhs, T rhs)
{
    UT_STATIC_CHECK_ENUM(T);
    using U = typename std::underlying_type<T>::type;
    lhs = static_cast<T>(static_cast<U>(lhs) ^ static_cast<U>(rhs));
    return lhs;
}

template <typename T>
typename std::enable_if<UT_EnableBitMask<T>::enable, T>::type
operator~(T lhs)
{
    UT_STATIC_CHECK_ENUM(T);
    using U = typename std::underlying_type<T>::type;
    return static_cast<T>(~static_cast<U>(lhs));
}

// Enable all bit flag operators on strong enum type
#define UT_ENABLE_ENUM_BIT_FLAGS(name)                                         \
    template <>                                                                \
    struct UT_EnableBitMask<name>                                              \
    {                                                                          \
        static constexpr bool enable = true;                                   \
    };

#endif // __UT_ENUMHELPER_H__