enum_ops.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifndef STLAB_ENUM_OPS_HPP
#define STLAB_ENUM_OPS_HPP
 
/**************************************************************************************************/
 
#include <cassert>
#include <type_traits>
 
/**************************************************************************************************/







 
/**************************************************************************************************/

namespace stlab {
 
/**************************************************************************************************/


auto stlab_enable_bitmask_enum(...) -> std::false_type;

auto stlab_enable_arithmetic_enum(...) -> std::false_type;
 
// Don't use the `\ deprecated` Doxygen tag here because clang will warn that the
// documentation marks the operations deprecated but the deprecated attribute is missing.

auto adobe_enable_bitmask_enum(...) -> std::false_type;

auto adobe_enable_arithmetic_enum(...) -> std::false_type;

 
/**************************************************************************************************/

namespace implementation {
 
/**************************************************************************************************/
 
template <class T>
using has_enabled_bitmask_t = decltype(stlab_enable_bitmask_enum(std::declval<T>()));
 
template <class T>
using has_deprecated_bitmask_t = decltype(adobe_enable_bitmask_enum(std::declval<T>()));
 
template <class T>
constexpr bool has_enabled_bitmask =
    has_enabled_bitmask_t<T>::value || has_deprecated_bitmask_t<T>::value;
 
template <class T>
using has_enabled_arithmetic_t = decltype(stlab_enable_arithmetic_enum(std::declval<T>()));
 
template <class T>
using has_deprecated_arithmetic_t = decltype(adobe_enable_arithmetic_enum(std::declval<T>()));
 
template <class, bool>
struct safe_underlying_type;
 
template <class T>
struct safe_underlying_type<T, true> {
    using type = std::underlying_type_t<T>;
};
 
template <class T>
struct safe_underlying_type<T, false> {
    using type = void;
};
 
template <class T>
using safe_underlying_type_t = typename safe_underlying_type<T, std::is_enum<T>::value>::type;
 
template <class U, class T>
using is_convertible_to_underlying =
    std::is_convertible<U, stlab::implementation::safe_underlying_type_t<T>>;
 
/**************************************************************************************************/
 
} // namespace implementation
 
/**************************************************************************************************/


template <class T>
constexpr bool has_enabled_bitmask = implementation::has_enabled_bitmask_t<T>::value ||
                                     implementation::has_deprecated_bitmask_t<T>::value;

template <class T>
constexpr bool has_enabled_arithmetic = implementation::has_enabled_arithmetic_t<T>::value ||
                                        implementation::has_deprecated_arithmetic_t<T>::value;

template <class U, class T>
constexpr bool is_compatible_scalar = implementation::is_convertible_to_underlying<U, T>::value;

 
/**************************************************************************************************/
 
} // namespace stlab
 
/**************************************************************************************************/

 
template <class T>
constexpr auto operator&(T lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
}
 
template <class T>
constexpr auto operator~(T a) -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(~static_cast<underlying>(a));
}
 
template <class T>
constexpr auto operator|(T lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
}
 
template <class T>
constexpr auto operator^(T lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
}
 
template <class T>
constexpr auto operator<<(T lhs, std::size_t rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T> {
    using underlying = std::make_unsigned_t<std::underlying_type_t<T>>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) << static_cast<underlying>(rhs));
}
 
template <class T>
constexpr auto operator>>(T lhs, std::size_t rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T> {
    using underlying = std::make_unsigned_t<std::underlying_type_t<T>>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) >> static_cast<underlying>(rhs));
}
 
template <class T>
constexpr auto operator^=(T& lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T&> {
    return lhs = lhs ^ rhs;
}
 
template <class T>
constexpr auto operator&=(T& lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T&> {
    return lhs = lhs & rhs;
}
 
template <class T>
constexpr auto operator|=(T& lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T&> {
    return lhs = lhs | rhs;
}
 
template <class T>
constexpr auto operator<<=(T& lhs, std::size_t rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T&> {
    return lhs = lhs << rhs;
}
 
template <class T>
constexpr auto operator>>=(T& lhs, std::size_t rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T&> {
    return lhs = lhs >> rhs;
}
 
template <class T, class U>
constexpr auto operator-(T lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T> && stlab::is_compatible_scalar<U, T>, T> {
    assert(rhs == 0 || rhs == 1);
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) - static_cast<underlying>(rhs));
}
 
template <class T>
constexpr auto operator-(std::nullptr_t lhs, T rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T>, T> {
    return -rhs;
}
 
template <class T, class U>
constexpr auto operator+(T lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T> && stlab::is_compatible_scalar<U, T>, T> {
    assert(rhs == 0 || rhs == 1);
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) + static_cast<underlying>(rhs));
}
 
template <class U, class T>
constexpr auto operator+(U lhs, T rhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T> && stlab::is_compatible_scalar<U, T>, T> {
    assert(lhs == 0 || lhs == 1);
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) + static_cast<underlying>(rhs));
}

 
/**************************************************************************************************/

 
template <class T>
constexpr auto operator+(T a) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(+static_cast<underlying>(a));
}
 
template <class T>
constexpr auto operator+(T lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) + static_cast<underlying>(rhs));
}
 
template <class T>
constexpr auto operator-(T lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) - static_cast<underlying>(rhs));
}
 
template <class T, class U>
constexpr auto operator*(T lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> && stlab::is_compatible_scalar<U, T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) * rhs);
}
 
template <class U, class T>
constexpr auto operator*(U lhs, T rhs)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> && stlab::is_compatible_scalar<U, T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(lhs * static_cast<underlying>(rhs));
}
 
template <class T, class U>
constexpr auto operator/(T lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> && stlab::is_compatible_scalar<U, T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) / rhs);
}
 
template <class T, class U>
constexpr auto operator%(T lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> && stlab::is_compatible_scalar<U, T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(static_cast<underlying>(lhs) % rhs);
}
 
template <class T>
constexpr auto operator+=(T& lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T&> {
    return lhs = lhs + rhs;
}
 
template <class T>
constexpr auto operator-=(T& lhs, T rhs) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T&> {
    return lhs = lhs - rhs;
}
 
template <class T, class U>
constexpr auto operator*=(T& lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> && stlab::is_compatible_scalar<U, T>, T&> {
    return lhs = lhs * rhs;
}
 
template <class T, class U>
constexpr auto operator/=(T& lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> && stlab::is_compatible_scalar<U, T>, T&> {
    return lhs = lhs / rhs;
}
 
template <class T, class U>
constexpr auto operator%=(T& lhs, U rhs)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> && stlab::is_compatible_scalar<U, T>, T&> {
    return lhs = lhs % rhs;
}
 
template <class T>
constexpr auto operator++(T& lhs) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T&> {
    return lhs += static_cast<T>(1);
}
 
template <class T>
constexpr auto operator++(T& lhs, int) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T> {
    T result = lhs;
    lhs += static_cast<T>(1);
    return result;
}
 
template <class T>
constexpr auto operator--(T& lhs) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T&> {
    return lhs -= static_cast<T>(1);
}
 
template <class T>
constexpr auto operator--(T& lhs, int) -> std::enable_if_t<stlab::has_enabled_arithmetic<T>, T> {
    T result = lhs;
    lhs -= static_cast<T>(1);
    return result;
}

 
/**************************************************************************************************/

 
template <class T>
constexpr auto operator-(T a)
    -> std::enable_if_t<stlab::has_enabled_arithmetic<T> || stlab::has_enabled_bitmask<T>, T> {
    using underlying = std::underlying_type_t<T>;
    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
    return static_cast<T>(-static_cast<underlying>(a));
}
 
template <class T>
constexpr auto operator==(T lhs, std::nullptr_t)
    -> std::enable_if_t<(stlab::has_enabled_bitmask<T> || stlab::has_enabled_arithmetic<T>) &&
                            !stlab::is_compatible_scalar<T, T>,
                        bool> {
    return !lhs;
}
 
template <class T>
constexpr auto operator==(std::nullptr_t, T rhs)
    -> std::enable_if_t<(stlab::has_enabled_bitmask<T> || stlab::has_enabled_arithmetic<T>) &&
                            !stlab::is_compatible_scalar<T, T>,
                        bool> {
    return !rhs;
}
 
template <class T>
constexpr auto operator!=(T lhs, std::nullptr_t rhs)
    -> std::enable_if_t<(stlab::has_enabled_bitmask<T> || stlab::has_enabled_arithmetic<T>) &&
                            !stlab::is_compatible_scalar<T, T>,
                        bool> {
    return !(lhs == rhs);
}
 
template <class T>
constexpr auto operator!=(std::nullptr_t lhs, T rhs)
    -> std::enable_if_t<(stlab::has_enabled_bitmask<T> || stlab::has_enabled_arithmetic<T>) &&
                            !stlab::is_compatible_scalar<T, T>,
                        bool> {
    return !(lhs == rhs);
}
 
template <class T>
constexpr auto operator!(T lhs)
    -> std::enable_if_t<stlab::has_enabled_bitmask<T> || stlab::has_enabled_arithmetic<T>, bool> {
    return !static_cast<bool>(lhs);
}

 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/