magic_enum/doc/reference.md

Reference

• enum_cast obtains enum value from string or integer.
• enum_value returns enum value at specified index.
• enum_values obtains enum value sequence.
• enum_count returns number of enum values.
• enum_integer obtains integer value from enum value.
• enum_name returns name from enum value.
• enum_flags_name returns name from enum-flags value.
• enum_names obtains string enum name sequence.
• enum_entries obtains pair (value enum, string enum name) sequence.
• enum_index obtains index in enum value sequence from enum value.
• enum_contains checks whether enum contains enumerator with such value.
• enum_type_name returns type name of enum.
• enum_fuse returns a bijective mix of enum values.
• is_unscoped_enum checks whether type is an Unscoped enumeration.
• is_scoped_enum checks whether type is an Scoped enumeration.
• underlying_type improved UB-free "SFINAE-friendly" underlying_type.
• ostream_operators ostream operators for enums.
• bitwise_operators bitwise operators for enums.

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;

• Returns enum value at specified index.

• No bounds checking is performed: the behavior is undefined if index >= number of enum values.

• Examples

  int i = 1;
  Color color = magic_enum::enum_value<Color>(i);
  // 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;

• 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 "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

  • Enum value to string.

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

  • Static storage enum variable to string.

    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() noexcept;

• Obtains index in enum values from enum value.

• Returns optional<size_t> with index.

• Examples

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

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 size_t enum_fuse(Es ... values);

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

• Examples

  switch (magic_enum::enum_fuse(color1, color2)) {
  case magic_enum::enum_fuse(RED, BLUE): // ...
  case magic_enum::enum_fuse(RED, RED):  // ...
  // ...
  }
  

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;