Note, consider this beta right now. Bugfixes and ideas for improvement are more than welcome.

Light-Enum

Light-Enum is an "add-on" for Magic-Enum aiming to provide the same (almost) functionality with low compile time. The idea is to introspect enums (using Magic Enum) at application start and store them all in a global hash map. This means that the heavey Magic Enum introspection only needs to be compiled in a single translation unit/cpp file rather than every time an enum is introspected. See example below.

Magic-Enum

As mentioned, this just a simple add-on for Magic Enum. All the hard work for introspecting enums shall be credited to the creator of Magic Enum. Magic Enum

Summary

light_enum.hpp - Light header file used when accessing enums. Suitable for adding to precompiled headers. light_enum_register.hpp - Heavy header file only to be used in .cpp files where enums are registered.

Interface

Introspecting enums

All these functions are similar to the corresponding function in magic_enum, but a span is returned instead of a std::array. Trying to access an enum not registred throws an out_of_bounds exception.

template <typename E> autoenum_cast(const std::string_view& name) -> std::optional<E>;
template <typename E> autoenum_values() -> detail::span<E>;
template <typename E> autoenum_names() -> detail::span<std::string_view>;
template <typename E> autoenum_name(const E& e) -> std::string_view; // Returns an empty string_view if invalid enumtemplate <typename E> autoenum_count() -> size_t;
template <typename E> autoenum_index(const E& e) -> std::optional<size_t>;
template <typename E> autoenum_contains(const E& e) -> bool;
template <typename E> autoenum_next() -> E; // Returns the next enumtemplate <typename E> autoenum_prev() -> E; // Returns the previous enum

Adding enums to registry

template <typename E> [[nodiscard]]autois_registred() -> bool;
template <typename E> autoregister_enum() -> void;
LIGHT_ENUM_REGISTER(E) // Convenience macro for putting in global namespace 

Usage example

Fruit.h

// Define enum as ususalenumclassFruit{Apple, Orange, Banana};

Fruit.cpp

// Only include light_enum_register.hpp where you register enums
#include"Fruit.h"
#include"light_enum/light_enum_register.hpp"LIGHT_ENUM_REGISTER(Fruit);
// ...or ...LIGHT_ENUM_REGISTER_RANGE(Fruit, 0, 200); // If you have a large enum you can define the range to search for values like this.// Note that the range can be larger than the values of the enum

Application.cpp

#include"Fruit.h"// Only light_enum.hpp is required for accessing enums
#include"light_enum/light_enum.hpp"autofunction() {
// Introspect enums just as Magic Enumconstauto apple = Fruit::Apple;
assert(light_enum::enum_count<Fruit>() == 3);
assert(light_enum::enum_name(apple) == "Apple");
constauto values = light_enum::enum_values<Fruit>();
assert(values[0] == Fruit::Apple);
assert(values[1] == Fruit::Orange);
assert(values[2] == Fruit::Banana);
}

Features

Stable memory

All returned spans and string_views are guaranteed to be stable in memory, even if new enums are registered. Therefore, it's perfectly store them locally for faster access.

Example:

structFruitInfo{
Fruit fruit;
std::string_view name;
};
auto fruit_info = FruitInfo {
EFruit::Apple,
light_enum::enum_name(EFruit::Apple);
};
// fruit_info.name will always be validstructFruitBasket{
span<std::string_view> names;
span<Fruit> fruits;
};
auto fruit_basket = FruitBasket{
light_enum::enum_names<Fruit>(),
light_enum::enum_values<Fruit>()
};
// fruit_basket.names and fruit_basket.fruits will always be valid

Run-time performance

Every introspection * Constructs a std::type_index * Reads a static variable holding the database * Performs a std::unordered_map lookup RTTI is required to be enabled in order to use std::type_index. Future updates will be able to use boost::type_index which does not depend on RTTI.

Installation

Light enum is almost header-only for easy installation.

• Include light_enum_impl.ipp once in a .cpp file of your choice.
• Include light_enum.hpp wherever you want to access enums (I recommend you to put this in you precompiled header file)
• Include "light_enum_register.hpp" in the .cpp files where you register enums, as registering enums is slow from a compile time perspective.

Future improvements

These improvements are planned for the future

• Ability to change std::type_index to boost::typeindex in order to not require RTTI
• Ability to change the underlying std::unordered_map to a faster hash-map (tsl::hopscotch_map for example)

License

MIT License. Use however you like, if you're using it in something released I would be happy for a mail telling me about it :)

Contact

I'm available at viktor dot sehr (at) gmail dot com