Skip to content

Latest commit

 

History

History
533 lines (383 loc) · 15.4 KB

reference.md

File metadata and controls

533 lines (383 loc) · 15.4 KB

Reference

Synopsis

  • Before use, read the limitations of functionality.

  • To check is magic_enum supported compiler use macro MAGIC_ENUM_SUPPORTED or constexpr constant magic_enum::is_magic_enum_supported.
    If magic_enum used on unsupported compiler, occurs the compilation error. To suppress error define macro MAGIC_ENUM_NO_CHECK_SUPPORT.

  • To add custom enum or type names see the example.

  • To change the type of strings or ortional, use special macros:

    #include <my_lib/string.hpp>
#include <my_lib/string_view.hpp>
#define MAGIC_ENUM_USING_ALIAS_STRING using string = my_lib::String;
#define MAGIC_ENUM_USING_ALIAS_STRING_VIEW using string_view = my_lib::StringView;
#define MAGIC_ENUM_USING_ALIAS_OPTIONAL template <typename T> using optional = my_lib::Optional<T>;
#include <magic_enum.hpp>

  • Optionally define MAGIC_ENUM_CONFIG_FILE i.e., in your build system, with path to header file with defined macros or constants, for example:

    #define MAGIC_ENUM_CONFIG_FILE "my_magic_enum_cfg.hpp"

    my_magic_enum_cfg.hpp:

    #include <my_lib/string.hpp>
#include <my_lib/string_view.hpp>
#define MAGIC_ENUM_USING_ALIAS_STRING using string = my_lib::String;
#define MAGIC_ENUM_USING_ALIAS_STRING_VIEW using string_view = my_lib::StringView;
#define MAGIC_ENUM_USING_ALIAS_OPTIONAL template <typename T> using optional = my_lib::Optional<T>;
#define MAGIC_ENUM_RANGE_MIN 0
#define MAGIC_ENUM_RANGE_MAX 255

  • To add support for non-ASCII enumeration identifier, use special macros:

    #define MAGIC_ENUM_ENABLE_NONASCII
#include <magic_enum.hpp>

enum_cast

template <typename E>
constexpr optional<E> enum_cast(underlying_type_t<E> value) noexcept;

template <typename E>
constexpr optional<E> enum_cast(string_view value) noexcept;

template <typename E, typename BinaryPredicate>
constexpr optional<E> enum_cast(string_view value, BinaryPredicate p) noexcept(is_nothrow_invocable_v<BinaryPredicate>);

  • Obtains enum value from string or integer.

  • Returns optional<E>, using has_value() to check contains enum value and value() to get the enum value.

  • If argument does not enum value, returns empty optional.

  • Examples

    • String to enum value.

      string color_name{"GREEN"};
auto color = magic_enum::enum_cast<Color>(color_name);
if (color.has_value()) {
    // color.value() -> Color::GREEN
}

    • Integer to enum value.

      int color_integer = 2;
auto color = magic_enum::enum_cast<Color>(color_integer);
if (color.has_value()) {
    // color.value() -> Color::RED
}

enum_value

template <typename E>
constexpr E enum_value(size_t index) noexcept;

template <typename E, size_t I>
constexpr E enum_value() noexcept;

  • Returns enum value at specified index.

    • enum_value(value) no bounds checking is performed: the behavior is undefined if index >= number of enum values.
    • enum_value<value>() check if I >= number of enum values, occurs the compilation error magic_enum::enum_value out of range.

  • Examples

    int i = 1;
Color color = magic_enum::enum_value<Color>(i);
// color -> Color::BLUE
    Color color = magic_enum::enum_value<Color, 1>();
// color -> Color::BLUE

enum_values

template <typename E>
constexpr array<E, N> enum_values() noexcept;

  • Returns array<E, N> with all enum values where N = number of enum values, sorted by enum value.

  • Examples

    constexpr auto colors = magic_enum::enum_values<Color>();
// colors -> {Color::RED, Color::BLUE, Color::GREEN}
// colors[0] -> Color::RED

enum_count

template <typename E>
constexpr size_t enum_count() noexcept;

  • Returns number of enum values.

  • Examples

    constexpr auto color_count = magic_enum::enum_count<Color>();
// color_count -> 3

enum_integer

template <typename E>
constexpr underlying_type_t<E> enum_integer(E value) noexcept;

template <typename E>
constexpr underlying_type_t<E> enum_underlying(E value) noexcept;

  • Returns integer value from enum value.

  • Examples

    Color color = Color::RED;
auto color_integer = magic_enum::enum_integer(color);
// color -> 2

enum_name

template <typename E>
constexpr string_view enum_name(E value) noexcept;

template <auto V>
constexpr string_view enum_name() noexcept;

  • Returns name from enum value as string_view with null-terminated string.

    • If enum value does not have name or out of range, enum_name(value) returns empty string.
    • If enum value does not have name, enum_name<value>() occurs the compilation error magic_enum::enum_name enum value does not have a name.

  • enum_name<value>() is much lighter on the compile times and is not restricted to the enum_range limitation.

  • Examples

    Color color = Color::RED;
auto color_name = magic_enum::enum_name(color);
// color_name -> "RED"
    constexpr Color color = Color::BLUE;
constexpr auto color_name = magic_enum::enum_name<color>();
// color_name -> "BLUE"

enum_flags_name

template <typename E>
string enum_flags_name(E value);

  • Returns name from enum-flags value as string with null-terminated string.

  • If enum-flags value does not have name or out of range, returns empty string.

  • Examples

    auto directions_name = magic_enum::enum_flags_name(Directions::Up | Directions::Right);
// directions_name -> "Directions::Up | Directions::Right"

enum_names

template <typename E>
constexpr array<string_view, N> enum_names() noexcept;

  • Returns array<string_view, N> with all names where N = number of enum values, sorted by enum value.

  • Examples

    constexpr auto color_names = magic_enum::enum_names<Color>();
// color_names -> {"RED", "BLUE", "GREEN"}
// color_names[0] -> "RED"

enum_entries

template <typename E>
constexpr array<pair<E, string_view>, N> enum_entries() noexcept;

  • Returns array<pair<E, string_view>, N> with all pairs (value, name) where N = number of enum values, sorted by enum value.

  • Examples

    constexpr auto color_entries = magic_enum::enum_entries<Color>();
// color_entries -> {{Color::RED, "RED"}, {Color::BLUE, "BLUE"}, {Color::GREEN, "GREEN"}}
// color_entries[0].first -> Color::RED
// color_entries[0].second -> "RED"

enum_index

template <typename E>
constexpr optional<size_t> enum_index(E value) noexcept;

template <auto V>
constexpr size_t enum_index() noexcept;

  • Obtains index in enum values from enum value.

    • enum_index(value) returns optional<size_t> with index.
    • enum_index<value>() returns index. If enum value does not have a index, occurs the compilation error magic_enum::enum_index enum value does not have a index.

  • Examples

    constexpr auto color_index = magic_enum::enum_index(Color::BLUE);
// color_index.value() -> 1
// color_index.has_value() -> true
    constexpr auto color_index = magic_enum::enum_index<Color::BLUE>();
// color_index -> 1

enum_contains

template <typename E>
constexpr bool enum_contains(E value) noexcept;

template <typename E>
constexpr bool enum_contains(underlying_type_t<E> value) noexcept;

template <typename E>
constexpr bool enum_contains(string_view value) noexcept;

template <typename E, typename BinaryPredicate>
constexpr optional<E> enum_contains(string_view value, BinaryPredicate p) noexcept(is_nothrow_invocable_v<BinaryPredicate>);

  • Checks whether enum contains enumerator with such value.

  • Returns true is enum contains value, otherwise false.

  • Examples

    magic_enum::enum_contains(Color::GREEN); // -> true
magic_enum::enum_contains<Color>(2); // -> true
magic_enum::enum_contains<Color>(123); // -> false
magic_enum::enum_contains<Color>("GREEN"); // -> true
magic_enum::enum_contains<Color>("fda"); // -> false

enum_type_name

template <typename E>
constexpr string_view enum_type_name() noexcept;

  • Returns type name of enum as string_view null-terminated string.

  • Examples

    Color color = Color::RED;
auto type_name = magic_enum::enum_type_name<decltype(color)>();
// color_name -> "Color"

enum_fuse

template <typename... Es>
[[nodiscard]] constexpr optional<enum_fuse_t> enum_fuse(Es... values) noexcept;

  • You should add the required file <magic_enum_fuse.hpp>.

  • Returns a typesafe bijective mix of several enum values. This can be used to emulate 2D switch/case statements.

  • Return type is optional<enum_fuse_t> where enum_fuse_t is an incomplete enum, it is unique for any given combination of Es....

  • Switch/case statement over an incomplete enum is a Visual Studio warning C4064

    • You have to silent (/wd4064) or ignore it.
    • Alternatively, define MAGIC_ENUM_NO_TYPESAFE_ENUM_FUSE to disable type-safety (enum_fuse_t equals uintmax_t).

  • Examples

    switch (magic_enum::enum_fuse(color, direction).value()) {
  case magic_enum::enum_fuse(Color::RED, Directions::Up).value(): // ...
  case magic_enum::enum_fuse(Color::BLUE, Directions::Down).value(): // ...
  case magic_enum::enum_fuse(Directions::BLUE, Color::Down).value(): // Compilation error
// ...
}

enum_switch

template <typename Result = void, typename E, typename Lambda>
constexpr Result enum_switch(Lambda&& lambda, E value);

template <typename Result, typename E, typename Lambda>
constexpr Result enum_switch(Lambda&& lambda, E value, Result&& result);

template <typename E, typename Result = void, typename BinaryPredicate = std::equal_to<>, typename Lambda>
constexpr Result enum_switch(Lambda&& lambda, string_view name, BinaryPredicate&& p = {});

template <typename E, typename Result, typename BinaryPredicate = std::equal_to<>, typename Lambda>
constexpr Result enum_switch(Lambda&& lambda, string_view name, Result&& result, BinaryPredicate&& p = {});

template <typename E, typename Result = void, typename Lambda>
constexpr Result enum_switch(Lambda&& lambda, underlying_type_t<E> value);

template <typename E, typename Result, typename Lambda>
constexpr Result enum_switch(Lambda&& lambda, underlying_type_t<E> value, Result&& result);

enum_for_each

template <typename E, typename Lambda>
constexpr auto enum_for_each(Lambda&& lambda);

is_unscoped_enum

template <typename T>
struct is_unscoped_enum;

template <typename T>
inline constexpr bool is_unscoped_enum_v = is_unscoped_enum<T>::value;

  • Checks whether type is an Unscoped enumeration.

  • Provides the member constant value which is equal to true, if T is an Unscoped enumeration type.
    Otherwise, value is equal to false.

  • Examples

    magic_enum::is_unscoped_enum<color>::value -> true
magic_enum::is_unscoped_enum<Direction>::value -> false

// Helper variable template.
magic_enum::is_unscoped_enum_v<color> -> true

is_scoped_enum

template <typename T>
struct is_scoped_enum;

template <typename T>
inline constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value;

  • Checks whether type is an Scoped enumeration.

  • Provides the member constant value which is equal to true, if T is an Scoped enumeration type.
    Otherwise, value is equal to false.

  • Examples

    magic_enum::is_scoped_enum<color>::value -> false
magic_enum::is_scoped_enum<Direction>::value -> true

// Helper variable template.
magic_enum::is_scoped_enum_v<Direction> -> true

underlying_type

template <typename T>
struct underlying_type;

template <typename T>
using underlying_type_t = typename underlying_type<T>::type;

  • Improved UB-free "SFINAE-friendly" underlying_type.

  • If T is a complete enumeration type, provides a member typedef type that names the underlying type of T.
    Otherwise, if T is not an enumeration type, there is no member type.
    Otherwise (T is an incomplete enumeration type), the program is ill-formed.

  • Examples

    magic_enum::underlying_type<color>::type -> int

// Helper types.
magic_enum::underlying_type_t<Direction> -> int

ostream_operators

template <typename Char, typename Traits, typename E>
basic_ostream<Char, Traits>& operator<<(basic_ostream<Char, Traits>& os, E value);

template <typename Char, typename Traits, typename E>
basic_ostream<Char, Traits>& operator<<(basic_ostream<Char, Traits>& os, optional<E> value);

  • Out-of-the-box ostream operators for all enums.

  • Examples

    using namespace magic_enum::ostream_operators; // out-of-the-box ostream operators for enums.
Color color = Color::BLUE;
std::cout << color << std::endl; // "BLUE"

bitwise_operators

template <typename E>
constexpr E operator~(E rhs) noexcept;

template <typename E>
constexpr E operator|(E lhs, E rhs) noexcept;

template <typename E>
constexpr E operator&(E lhs, E rhs) noexcept;

template <typename E>
constexpr E operator^(E lhs, E rhs) noexcept;

template <typename E>
constexpr E& operator|=(E& lhs, E rhs) noexcept;

template <typename E>
constexpr E& operator&=(E& lhs, E rhs) noexcept;

template <typename E>
constexpr E& operator^=(E& lhs, E rhs) noexcept;

  • Out-of-the-box bitwise operators for all enums.

  • Examples

    enum class Flags { A = 1 << 0, B = 1 << 1, C = 1 << 2, D = 1 << 3 };
using namespace magic_enum::bitwise_operators; // out-of-the-box bitwise operators for enums.
// Support operators: ~, |, &, ^, |=, &=, ^=.
Flags flags = Flags::A | Flags::B & ~Flags::C;