StructEnum.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "String.hpp"
#include "Container/Optional.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
namespace CeresEngine {
 
    template<typename T, typename Underlying = UInt32> class StructEnum {
    public:
        using UnderlyingType = Underlying;
        using Self = T;
        
        explicit operator UnderlyingType() const noexcept {
            return static_cast<const T*>(this)->raw;
        }
 
        void toString(std::ostream& stream) const noexcept { stream << static_cast<const T*>(this)->toString(); }
 
        friend std::ostream& operator<<(std::ostream& stream, const T& object) { return stream << object.toString(); }
 
        static Self fromRawUnderlying(UnderlyingType underlying) noexcept { return Self(typename Self::RawType(underlying)); }
 
    public:
        [[nodiscard]] friend bool operator==(const T& lhs, const T& rhs) noexcept { return lhs.raw == rhs.raw; }
 
        [[nodiscard]] friend bool operator!=(const T& lhs, const T& rhs) noexcept { return lhs.raw != rhs.raw; }
    };
    
    template<typename T>
    concept CStructEnum = std::is_base_of_v<StructEnum<T, typename T::UnderlyingType>, T>;
 
#define CE_STRUCT_ENUM_DECL(T)                                                                                            \
    using RawType = decltype(raw);                                                                                        \
    constexpr T() = default;                                                                                              \
    CE_EXPLICIT(false) constexpr T(RawType raw) : raw(raw) {}                                                              \
    explicit constexpr T(UnderlyingType raw) : T(RawType(raw)) {}                                                         \
                                                                                                                          \
public:                                                                                                                   \
                                                                           \
    [[nodiscard]] StringView toString() const noexcept;                                                                   \
                                                                                                                          \
 \
    [[nodiscard]] static Optional<T> fromString(StringView string) noexcept;
 
#define CE_STRUCT_ENUM_FOREACH(T, F) CE_STRUCT_ENUM_FOREACH_##T(F)
 
#define CE_STRUCT_ENUM_TO_STRING_IMPL(T) \
    case T:                              \
        return #T;
#define CE_STRUCT_ENUM_TO_STRING(T, M)                                           \
    StringView T::toString() const noexcept {                                    \
        switch(raw) { CE_STRUCT_ENUM_FOREACH(M, CE_STRUCT_ENUM_TO_STRING_IMPL) } \
        return "<unknown>";                                                      \
    }
 
#define CE_STRUCT_ENUM_FROM_STRING_IMPL(T) \
    if(string == #T)                       \
        return T;
#define CE_STRUCT_ENUM_FROM_STRING(T, M)                            \
    Optional<T> T::fromString(StringView string) noexcept {         \
        CE_STRUCT_ENUM_FOREACH(M, CE_STRUCT_ENUM_FROM_STRING_IMPL); \
        return {};                                                  \
    }
 
#define CE_STRUCT_ENUM_DEF(T)      \
    CE_STRUCT_ENUM_TO_STRING(T, T) \
    CE_STRUCT_ENUM_FROM_STRING(T, T)
 
#define CE_STRUCT_ENUM_DEF2(T, M)  \
    CE_STRUCT_ENUM_TO_STRING(T, M) \
    CE_STRUCT_ENUM_FROM_STRING(T, M)
} // namespace CeresEngine