ExtendedEnum.h

Go to the documentation of this file.

#pragma once
 
#include "common/Assert.h"
#include "common/Traits.h"
#include <limits>
 
NAMESPACE_SPH_BEGIN
 
template <typename TDerived, typename TBase>
struct IsExtended {
    static constexpr bool value = false;
};
 
#define SPH_EXTEND_ENUM(TDerived, TBase)                                                                     \
    template <>                                                                                              \
    struct IsExtended<TDerived, TBase> {                                                                     \
        static constexpr bool value = true;                                                                  \
    }
 
template <typename TBase>
class ExtendedEnum {
private:
    using TValue = std::underlying_type_t<TBase>;
    TValue value = 0;
 
public:
    using BaseType = TBase;
 
    ExtendedEnum() = default;
 
    ExtendedEnum(const TBase value)
        : value(TValue(value)) {}
 
    template <typename TDerived, typename = std::enable_if_t<IsExtended<TDerived, TBase>::value>>
    ExtendedEnum(const TDerived value)
        : value(TValue(value)) {}
 
    operator TBase() const {
        return TBase(value);
    }
 
    template <typename TDerived, typename = std::enable_if_t<IsExtended<TDerived, TBase>::value>>
    explicit operator TDerived() const {
        return TDerived(value);
    }
 
    bool operator<(const ExtendedEnum& other) const {
        return value < other.value;
    }
 
    bool operator==(const ExtendedEnum& other) const {
        return value == other.value;
    }
 
    bool operator==(const TBase& other) const {
        return TBase(value) == other;
    }
 
    template <typename TDerived, typename = std::enable_if_t<IsExtended<TDerived, TBase>::value>>
    bool operator==(const TDerived& other) const {
        return TDerived(value) == other;
    }
 
    bool operator!=(const ExtendedEnum& other) const {
        return value != other.value;
    }
};
 
template <typename T>
struct IsExtendedEnum {
    static constexpr bool value = false;
};
 
template <typename TEnum>
struct IsExtendedEnum<ExtendedEnum<TEnum>> {
    static constexpr bool value = true;
};
 
NAMESPACE_SPH_END