enum.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <type_traits>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/list.h>
#include <promeki/pair.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class Enum {
        public:
                PROMEKI_DATATYPE(Enum, DataTypeEnum, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<Enum> readFromStream(DataStream &s);
 
                static constexpr int InvalidValue = -1;
 
                struct Entry {
                                const char *name;
                                int         value;
                                const char *displayName = nullptr; 
                };
 
                struct Definition {
                                const char      *name = nullptr;              
                                const Entry     *entries = nullptr;           
                                size_t           entryCount = 0;              
                                int              defaultValue = InvalidValue; 
                                mutable uint32_t typeIndex = 0;               
 
                                const char *displayName = nullptr;
 
                                mutable StringLiteralData *nameLit = nullptr;
 
                                mutable StringLiteralData *entryNameLits = nullptr;
 
                                mutable StringLiteralData *entryQualifiedLits = nullptr;
 
                                mutable StringLiteralData *displayNameLit = nullptr;
 
                                mutable StringLiteralData *entryDisplayLits = nullptr;
 
                                const Entry *findByName(const String &n) const;
                                const Entry *findByValue(int v) const;
                };
 
                class Type {
                        public:
                                Type() = default;
 
                                bool isValid() const { return _def != nullptr; }
 
                                String name() const;
 
                                String displayName() const;
 
                                uint32_t id() const;
 
                                const Definition *definition() const { return _def; }
 
                                bool operator==(const Type &o) const { return _def == o._def; }
                                bool operator!=(const Type &o) const { return _def != o._def; }
 
                                bool operator<(const Type &o) const { return _def < o._def; }
 
                        private:
                                friend class Enum;
                                explicit Type(const Definition *def) : _def(def) {}
                                const Definition *_def = nullptr;
                };
 
                using Value = Pair<String, int>;
 
                using ValueList = ::promeki::List<Value>;
 
                using TypeList = StringList;
 
                static Type registerDefinition(Definition *def);
 
                static Type registerType(const String &typeName, const ValueList &values, int defaultValue);
 
                static Type findType(const String &typeName);
 
                static TypeList registeredTypes();
 
                static ValueList values(Type type);
 
                static int defaultValue(Type type);
 
                static Result<int> valueOf(Type type, const String &name);
 
                static String nameOf(Type type, int value, Error *err = nullptr);
 
                static String displayNameOf(Type type, int value, Error *err = nullptr);
 
                static Enum lookup(const String &text, Error *err = nullptr);
 
                static Result<Enum> fromString(const String &text) {
                        Error err;
                        Enum  e = lookup(text, &err);
                        if (err.isError()) return makeError<Enum>(err);
                        return makeResult(e);
                }
 
                Enum() = default;
 
                explicit Enum(Type type);
 
                Enum(Type type, int value) : _def(type._def), _value(value) {}
 
                Enum(Type type, const String &name);
 
                Type type() const { return Type(_def); }
 
                int value() const { return _value; }
 
                String valueName() const;
 
                String valueDisplayName() const;
 
                String typeName() const;
 
                String typeDisplayName() const;
 
                String toString() const;
 
                bool isValid() const;
 
                bool hasListedValue() const;
 
                bool operator==(const Enum &o) const { return _def == o._def && _value == o._value; }
                bool operator!=(const Enum &o) const { return !(*this == o); }
 
        private:
                const Definition *_def = nullptr;        
                int               _value = InvalidValue; 
};
 
template <typename Derived> class TypedEnum : public Enum {
        public:
                TypedEnum() : Enum(Derived::Type) {}
 
                explicit TypedEnum(int value) : Enum(Derived::Type, value) {}
 
                explicit TypedEnum(const String &name) : Enum(Derived::Type, name) {}
 
                friend bool operator==(const Derived &a, const Derived &b) {
                        return static_cast<const Enum &>(a) == static_cast<const Enum &>(b);
                }
 
                friend bool operator!=(const Derived &a, const Derived &b) { return !(a == b); }
 
                template <typename Other>
                        requires(::std::is_base_of_v<TypedEnum<Other>, Other> && !::std::is_same_v<Other, Derived>)
                friend bool operator==(const Derived &, const Other &) = delete;
 
                template <typename Other>
                        requires(::std::is_base_of_v<TypedEnum<Other>, Other> && !::std::is_same_v<Other, Derived>)
                friend bool operator!=(const Derived &, const Other &) = delete;
};
 
namespace detail {
 
        constexpr bool enumStrEqual(const char *a, const char *b) {
                while (*a != '\0' && *b != '\0') {
                        if (*a != *b) return false;
                        ++a;
                        ++b;
                }
                return *a == *b;
        }
 
        consteval bool enumEntriesUnique(const Enum::Entry *entries, size_t count) {
                for (size_t i = 0; i < count; ++i) {
                        for (size_t j = i + 1; j < count; ++j) {
                                if (enumStrEqual(entries[i].name, entries[j].name)) return false;
                                if (entries[i].value == entries[j].value) return false;
                        }
                }
                return true;
        }
 
        consteval bool enumHasDefault(const Enum::Entry *entries, size_t count, int def) {
                for (size_t i = 0; i < count; ++i) {
                        if (entries[i].value == def) return true;
                }
                return false;
        }
 
} // namespace detail
 
PROMEKI_NAMESPACE_END
 
#define PROMEKI_REGISTER_ENUM_TYPE(TypeName, Default, ...)                                                             \
        PROMEKI_REGISTER_ENUM_TYPE_DISPLAY(TypeName, nullptr, Default, __VA_ARGS__)
 
#define PROMEKI_REGISTER_ENUM_TYPE_DISPLAY(TypeName, DisplayName, Default, ...)                                        \
        static constexpr ::promeki::Enum::Entry _promeki_enum_entries_[] = {__VA_ARGS__};                              \
        static_assert(sizeof(_promeki_enum_entries_) / sizeof(_promeki_enum_entries_[0]) > 0,                          \
                      "Enum type '" TypeName "' has no entries");                                                      \
        static_assert(::promeki::detail::enumEntriesUnique(_promeki_enum_entries_,                                     \
                                                           sizeof(_promeki_enum_entries_) /                            \
                                                                   sizeof(_promeki_enum_entries_[0])),                 \
                      "Enum type '" TypeName "' has duplicate name or value");                                         \
        static_assert(::promeki::detail::enumHasDefault(                                                               \
                              _promeki_enum_entries_,                                                                  \
                              sizeof(_promeki_enum_entries_) / sizeof(_promeki_enum_entries_[0]), (Default)),          \
                      "Enum type '" TypeName "' default value not in entry table");                                    \
        static inline ::promeki::Enum::Definition _promeki_enum_def_{.name = TypeName,                                 \
                                                                     .entries = _promeki_enum_entries_,                \
                                                                     .entryCount = sizeof(_promeki_enum_entries_) /    \
                                                                                   sizeof(_promeki_enum_entries_[0]),  \
                                                                     .defaultValue = (Default),                        \
                                                                     .typeIndex = 0,                                   \
                                                                     .displayName = (DisplayName)};                    \
        static inline const ::promeki::Enum::Type Type = ::promeki::Enum::registerDefinition(&_promeki_enum_def_)
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::Enum);
 
#endif // PROMEKI_ENABLE_CORE