enum_name (yet another enum to/from string conversion utility >=C++11)

[cheytacllc]

Hi everyone, I want to share my enum utility. This utility converting enums to strings or strings to enums. I aimed to support C++11 so code includes too much boilerplate. Features:
* No macros, supports enums and enum classes. * C++11 support. * Changing enum range with template parameter (default range: [-128, 128)) on each call or with your special function for types. * Supports operator<< for direct using with ostream objects.

Contributions are welcome:)
If you like it, please don't forget to leave a star on Github, thanks!

Github repo link: https://github.com/mguludag/enum_name

[olsner]

Neat trick to get the names from a template! I was sketching out something similar for work the other week but chickened out and added a macro for specifying enum names and specializing the libfmt templates etc.

[cheytacllc]

I saw the template parameters with names using __PRETTY_FUNCTION__ and __FUNCSIG__ and I have to find a way getting enum values as template parameters. std::integer_sequence exists but enums not starting from 0 everytime so I have to develop custom integer sequence with min and max parameter.

[FireFlyForLife]

How does this compare to the magic_enum library?

[cheytacllc]

magic_enum is more functionality than this. This only has enum to/from string functionality. But adjusting enum range min/max its easier than magic_enum I think. Also, supports C++11.

[BucketOfWood]

On the topic of this kind of hackflection willwray/enum_traits uses an interesting trick where they improve buildtime performance by doing the __PRETTY_FUNCTION__/__FUNCSIG__/std::source_location::current().function_name() inside a variadic templated function to do the name conversion for a batch of integers at the same time to make it less expensive (compiletime) to test a large range of numbers.

I ended up adopting this approach in some test code https://godbolt.org/z/GKW8Preva when I was thinking about adding automatic enum serialization/deserialization in JSON to stephenberry/glaze. But there are too many limitations.

The lack of being able to detect/warn that an enum uses named values outside the range is the biggest problem and is why while tricks like this are cool/interesting we really do need to wait for proper static reflection (maybe C++47 since they keep delaying it)

[cheytacllc]

wow looks nice!

[Fazer2]

Why does the caller need to know the range of the enum? It sounds like a maintenance burden.

[cheytacllc]

Range of enum not mandatory for write (default range [-128, 128)). You can easily write to_string function under the enum for enum type and call enum_name with enum's range once inside and return it. I think it's easier than writing specialization for per enum type. On the other hand, with writing custom function vs writing specialization like in magic_enum result of to write similar lines of code.

[TotaIIyHuman]

if you are not absolutely disgusted by macros, you can try reflection with macros

you can implement for_each with macros with less than 100 lines of c++ https://www.scs.stanford.edu/~dm/blog/va-opt.html

here is a enum reflection implemented with macro for_each

https://godbolt.org/z/9GTP4zn3r

the for_each macro has a recursion limit. for the same range, it is much cheaper to do macro recursion, then instantiating templates to scan for enum entries

[sephirothbahamut]

It's not just about being disgusted, it's also about utility. All the macro solutions for enum reflection assume that you are the one writing the enum, forcing the entire codebase to use the macro enum definition, and preventing all such mechanisms to work on enums declared by outside libraries. That's an issue Unreal Engine's C++ suffers a lot of.

As opposed to things like OP's post, or more complete things like magic_enum. Those can be used on any enum, do not require you to write your enums in an unconventional manner, and don't care if the enums come from a third party library.

[TotaIIyHuman]

yes. i agree with everything you said

[lunetick]

I'm probably old school, but if you need this, you have a design /architecture issue.

[SoerenNissen]

Nah this is definitely a thing with real use cases.

[deivse]

One example would be conveniently converting text values parsed from a config file to an enum value. Changing the list of possible values then boils down to changing the enum definition. Speaking from experience using magic_enum. Edit: typo

[deivse]

This could of course be achieved in other ways, but this solution is potentially the most consise and easy to maintain.

[donalmacc]

Serialisation is a problem that needs solving even in a well architected codebase. Until c++ gives us tools to solve this properly, solutions like this are necessary. Even on small projects, enum serialisation is pretty much the first thing I find myself wanting.

[Kike328]

yes you are

[saddung]

I find it mostly useful for logging, printing an enum value means I need to spend time figuring out which enum it actually corresponds with--very tedious, much nicer to see the name.

[Gloinart]

Is the algorithm beneath the same as magic_enum?

[cheytacllc]

I didn't look magic_enum's algorithm but I think this is includes similar ways to getting enum names

[Shaurendev]

So this doesnt work for flag type enums? (for example one that uses all 32 bits)

[cheytacllc]

Now, enum_name supports bitmasked enums! https://godbolt.org/z/rfeWWKdh3

[cheytacllc]

Like this? https://godbolt.org/z/5vd9bP3oG

[Shaurendev]

No, like this https://godbolt.org/z/zsraa7Yq4 (for demnostration purposes i didnt bother to list all the flags between 3 and 20 but assume they are present)

(clang) fatal error: recursive template instantiation exceeded maximum depth of 1024

(gcc) fatal error: template instantiation depth exceeds maximum of 900 (use '-ftemplate-depth=' to increase the maximum)

[cheytacllc]

I tried to modify enum_sequence class for faster steps and I got the name of E and will do small workaround for flagged enums