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 string name from enum 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.
• 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" std::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.

enum_cast

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

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

• Obtains enum value from string or integer.

• Returns std::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 std::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 (colo.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 std::array<E, N> with all enum value 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 std::string_view.

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

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

• Returns std::array<std::string_view, N> with all string enum name 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 std::array<std::pair<E, std::string_view>, N> with all std::pair (value enum, string enum 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 value sequence from enum value.

• Returns std::optional<std::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;
constexpr bool enum_contains(underlying_type_t<E> value) noexcept;
constexpr bool enum_contains(string_view value) noexcept;

• 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

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" std::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;