Compiler Explorer

Source code

#include <array>
#include <string_view>
#include <optional>

template <typename EnumType>
struct MetaEnumMember
{
    EnumType value = {};
    std::string_view name;
    std::string_view string;
    size_t index = {};
};

template <typename EnumType, typename UnderlyingTypeIn, size_t size>
struct MetaEnum
{
    using UnderlyingType = UnderlyingTypeIn;
    std::string_view string;
    std::array<MetaEnumMember<EnumType>, size> members = {};
};

namespace meta_enum_internal
{

constexpr bool isNested (size_t brackets, bool quote)
{
    return brackets != 0 || quote;
}

constexpr size_t nextEnumCommaOrEnd(size_t start, std::string_view enumString, bool trigger = false)
{
    size_t brackets = 0; //()[]{}
    bool quote = false; //""
    char lastChar = '\0';
    char nextChar = '\0';

auto feedCounters = [&quote, &lastChar, &nextChar] (char c, size_t& brackets)
    {
        if(quote)
        {
            if(lastChar != '\\' && c == '"') //ignore " if they are backslashed
                quote = false;
            return;
        }

switch(c)
        {
            case '"':
                if(lastChar != '\\') //ignore " if they are backslashed
                    quote = true;
                break;
            case '<':
                if(lastChar == '<' || nextChar == '<')
                    break;
                ++brackets;
                break;
            case '(':
                ++brackets;
                break;
            case '{':
                ++brackets;
                break;
            case '>':
                if(lastChar == '>' || nextChar == '>')
                    break;
                --brackets;
                break;
            case ')':
                --brackets;
                break;
            case '}':
                --brackets;
                break;
            default:
                break;
        }
    };

size_t current = start;
    for(; current < enumString.size() && (isNested(brackets, quote) || (enumString[current] != ',')); ++current)
    {
        feedCounters(enumString[current], brackets);
        lastChar = enumString[current];
        nextChar = current + 2 < enumString.size() ? enumString[current + 2] : '\0';
    }

return current;
}

constexpr bool isAllowedIdentifierChar(char c)
{
    return (c >= 'a' && c <= 'z') ||
           (c >= 'A' && c <= 'Z') ||
           (c >= '0' && c <= '9') ||
           c == '_' ;
}

constexpr std::string_view parseEnumMemberName(std::string_view memberString)
{
    size_t nameStart = 0;
    while(!isAllowedIdentifierChar(memberString[nameStart]))
    {
        ++nameStart;
    }

size_t nameSize = 0;

while(isAllowedIdentifierChar(memberString[nameStart + nameSize]))
    {
        ++nameSize;
    }

return std::string_view(memberString.data() + nameStart, nameSize);
}

template <typename EnumType, typename UnderlyingType, size_t size>
constexpr MetaEnum<EnumType, UnderlyingType, size> parseMetaEnum(std::string_view in, const std::array<EnumType, size>& values)
{
    MetaEnum<EnumType, UnderlyingType, size> result;
    result.string = in;

std::array<std::string_view, size> memberStrings;
    size_t index = 0;

size_t currentStringStart = 0;

while(index < size)
    {
        bool trigger = currentStringStart == 5 && size == 7 && index == 1;
        size_t currentStringEnd = nextEnumCommaOrEnd(currentStringStart + 1, in, trigger);

if constexpr(size == 7)
        {
            if(index == 0 && currentStringEnd == 5 && currentStringStart == 0)
                ;//std::abort();
            if(index == 1 && currentStringEnd == 70 && currentStringStart == 5)
                ;//std::abort();
                
        if(index == 2 && currentStringEnd == 71 && currentStringStart == 70)
            std::abort();
        }
        size_t currentStringSize = currentStringEnd - currentStringStart;

if constexpr(size == 7)
        {
        if(index == 2 && currentStringSize == 1)
            std::abort();
        }

if(currentStringStart != 0)
        {
            ++currentStringStart;
            --currentStringSize;
        }

memberStrings[index] = std::string_view(in.data() + currentStringStart, currentStringSize);
        ++index;
        currentStringStart = currentStringEnd;
    }

for(size_t i = 0; i < memberStrings.size(); ++i)
    {
        result.members[i].name = parseEnumMemberName(memberStrings[i]);
        result.members[i].string = memberStrings[i];
        result.members[i].value = values[i];
        result.members[i].index = i;
    }

return result;
}

template <typename EnumUnderlyingType>
struct IntWrapper
{
    constexpr IntWrapper(): value(0), empty(true)
    {
    }
    constexpr IntWrapper(EnumUnderlyingType in): value(in), empty(false)
    {
    }
    constexpr IntWrapper operator=(EnumUnderlyingType in)
    {
        value = in;
        empty = false;
        return *this;
    }
    EnumUnderlyingType value;
    bool empty;
};

template <typename EnumType, typename EnumUnderlyingType, size_t size>
constexpr std::array<EnumType, size> resolveEnumValuesArray(const std::initializer_list<IntWrapper<EnumUnderlyingType>>& in)
{
    std::array<EnumType, size> result{};

EnumUnderlyingType nextValue = 0;
    for(size_t i = 0; i < size; ++i)
    {
        auto wrapper = *(in.begin() + i);
        EnumUnderlyingType newValue = wrapper.empty ? nextValue : wrapper.value;
        nextValue = newValue + 1;
        result[i] = static_cast<EnumType>(newValue);
    }

return result;
}
}

#define meta_enum(Type, UnderlyingType, ...)\
    enum Type : UnderlyingType { __VA_ARGS__};\
    constexpr static auto Type##_internal_size = []  () constexpr\
    {\
        using IntWrapperType = meta_enum_internal::IntWrapper<UnderlyingType>;\
        IntWrapperType __VA_ARGS__;\
        return std::initializer_list<IntWrapperType>{__VA_ARGS__}.size();\
    };\
    constexpr static auto Type##_meta = meta_enum_internal::parseMetaEnum<Type, UnderlyingType, Type##_internal_size()>(#__VA_ARGS__, []() {\
        using IntWrapperType = meta_enum_internal::IntWrapper<UnderlyingType>;\
        IntWrapperType __VA_ARGS__;\
        return meta_enum_internal::resolveEnumValuesArray<Type, UnderlyingType, Type##_internal_size()>({__VA_ARGS__});\
    }());\
    constexpr static auto Type##_value_to_string = [](Type e)\
    {\
        for(const auto& member : Type##_meta.members)\
        {\
            if(member.value == e)\
                return member.name;\
        }\
        return std::string_view("__INVALID_ENUM_VAL__");\
    \
    };\
    constexpr static auto Type##_meta_from_name = [](std::string_view s) -> std::optional<MetaEnumMember<Type>>\
    {\
        for(const auto& member : Type##_meta.members)\
        {\
            if(member.name == s)\
                return member;\
        }\
        return std::nullopt;\
    \
    };\
    constexpr static auto Type##_meta_from_value = [] (Type v) -> std::optional<MetaEnumMember<Type>>\
    {\
        for(const auto& member : Type##_meta.members)\
        {\
            if(member.value == v)\
                return member;\
        }\
        return std::nullopt;\
    \
    };\
    constexpr static auto Type##_meta_from_index = [] (size_t i)\
    {\
        std::optional<MetaEnumMember<Type>> result;\
        if(i < Type##_meta.members.size())\
            result = Type##_meta.members[i];\
        return result;\
    \
    };

#define meta_enum_class(Type, UnderlyingType, ...)\
    enum class Type : UnderlyingType { __VA_ARGS__};\
    constexpr static auto Type##_internal_size = [] () constexpr\
    {\
        using IntWrapperType = meta_enum_internal::IntWrapper<UnderlyingType>;\
        IntWrapperType __VA_ARGS__;\
        return std::initializer_list<IntWrapperType>{__VA_ARGS__}.size();\
    };\
    constexpr static auto Type##_meta = meta_enum_internal::parseMetaEnum<Type, UnderlyingType, Type##_internal_size()>(#__VA_ARGS__, []() {\
        using IntWrapperType = meta_enum_internal::IntWrapper<UnderlyingType>;\
        IntWrapperType __VA_ARGS__;\
        return meta_enum_internal::resolveEnumValuesArray<Type, UnderlyingType, Type##_internal_size()>({__VA_ARGS__});\
    }());\
    constexpr static auto Type##_value_to_string = [](Type e)\
    {\
        for(const auto& member : Type##_meta.members)\
        {\
            if(member.value == e)\
                return member.name;\
        }\
        return std::string_view("__INVALID_ENUM_VAL__");\
    \
    };\
    constexpr static auto Type##_meta_from_name = [](std::string_view s) -> std::optional<MetaEnumMember<Type>>\
    {\
        for(const auto& member : Type##_meta.members)\
        {\
            if(member.name == s)\
                return member;\
        }\
        return std::nullopt;\
    \
    };\
    constexpr static auto Type##_meta_from_value = [] (Type v) -> std::optional<MetaEnumMember<Type>>\
    {\
        for(const auto& member : Type##_meta.members)\
        {\
            if(member.value == v)\
                return member;\
        }\
        return std::nullopt;\
    \
    };\
    constexpr static auto Type##_meta_from_index = [] (size_t i)\
    {\
        std::optional<MetaEnumMember<Type>> result;\
        if(i < Type##_meta.members.size())\
            result = Type##_meta.members[i];\
        return result;\
    \
    };

#include <iostream>

//helpers
constexpr int sum(int a, int b, int c)
{
    return a + b + c;
}

//can be used for global or nested enums or enum classes
//first arg is the name of the enum. second is the underlying type. The rest are enum members.

meta_enum(Global, int, GlobalA, GlobalB = 3, GlobalC, GlobalD = 100);
meta_enum_class(GlobalClass, uint8_t, GlobalClassA, GlobalClassB = 3, GlobalClassC);

struct Nester
{
    meta_enum(Nested, int, NestedA, NestedB = 3);
    meta_enum_class(NestedClass, uint8_t, NestedClassA = 3, NestedClassB = 1 >> 3);
};

//also works with very complexly defined enum entries
meta_enum(Complex, int, First, Second= sum(1, 7, 4 >> 2), Third =     4,
Fourth);

//static assertions to verify that the complexly defined enum is parsed correctly
static_assert(Complex_meta.members.size() == 4);
static_assert(Complex_meta.members[0].string == "First");
static_assert(Complex_meta.members[1].string == " Second= sum(1, {(2, \")h(),,\\\"ej\", 1)}, 4 >> 2)");
static_assert(Complex_meta.members[2].string == " Third = 4");
static_assert(Complex_meta.members[3].string == " Fourth");

static_assert(Complex_meta.members[0].name == "First");
static_assert(Complex_meta.members[1].name == "Second");
static_assert(Complex_meta.members[2].name == "Third");
static_assert(Complex_meta.members[3].name == "Fourth");

static_assert(Complex_meta.members[0].value == 0);
static_assert(Complex_meta.members[1].value == 3);
static_assert(Complex_meta.members[2].value == 4);
static_assert(Complex_meta.members[3].value == 5);

static_assert(Complex_meta.members[0].index == 0);
static_assert(Complex_meta.members[1].index == 1);
static_assert(Complex_meta.members[2].index == 2);
static_assert(Complex_meta.members[3].index == 3);

int main()
{
    //enum meta objects are accessible with the _meta object
    //meta object has 'string' for full enum declaration string and 'members' for an array of all members
    //each member is an object of type MetaEnumMember
    std::cout << "global string: " << Global_meta.string << "\n";
    std::cout << "global count: " << Global_meta.members.size() << "\n";
    std::cout << "global class string: " << GlobalClass_meta.string << "\n";
    std::cout << "global class count: " << GlobalClass_meta.members.size() << "\n";
    std::cout << "nested string: " << Nester::Nested_meta.string << "\n";
    std::cout << "nested count: " << Nester::Nested_meta.members.size() << "\n";
    std::cout << "nested class string: " << Nester::NestedClass_meta.string << "\n";
    std::cout << "nested class count: " << Nester::NestedClass_meta.members.size() << "\n\n";

//enum member objects have the following members:
    std::cout << "global members:\n";
    for(const auto& enumMember : Global_meta.members)
    {
        using UnderlyingType = decltype(Global_meta)::UnderlyingType;
        std::cout << "index=" << enumMember.index << ", name='" << enumMember.name << "', value: " << static_cast<UnderlyingType>(enumMember.value) << ", string='" << enumMember.string << "'\n"; 
    }
    std::cout << "\n";

//helper functions are defined for convenience that operate on the _meta datastructure
    //value_to_string prints the name of an enum value and '__INVALID_ENUM_VAL__' on failure
    std::cout << "value_to_string: input=" << Nester::NestedB << " output='" << Nester::Nested_value_to_string(Nester::NestedB) << "'\n";

//these are different ways to access the meta enum member objects. they return an std::optional which will be empty on bad input
    std::cout << "meta_from_name accesses through name. input=" << "NestedClassA" << " found_index=" << Nester::NestedClass_meta_from_name("NestedClassA")->index << "\n";
    std::cout << "meta_from_value accesses through enum value. input=" << Nester::NestedB << " found_index=" << Nester::Nested_meta_from_value(Nester::NestedB)->index << "\n";
    std::cout << "meta_from_index accesses through index. input=" << 2 << " found_name='" << GlobalClass_meta_from_index(2)->name << "'\n";
}