初始化内容

third/magic_enum/example/CMakeLists.txt

@@ -0,0 +1,30 @@
+include(CheckCXXCompilerFlag)
+
+set(CMAKE_CXX_STANDARD 17)
+if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+    set(OPTIONS -Wall -Wextra -Wshadow -pedantic-errors -Werror)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    set(OPTIONS /W4 /WX)
+    if(HAS_PERMISSIVE_FLAG)
+        set(OPTIONS ${OPTIONS} /permissive-)
+    endif()
+endif()
+
+function(make_example target)
+    add_executable(${target} ${target}.cpp)
+    set_target_properties(${target} PROPERTIES CXX_EXTENSIONS OFF)
+    target_compile_features(${target} PRIVATE cxx_std_17)
+    target_compile_options(${target} PRIVATE ${OPTIONS})
+    target_link_libraries(${target} PRIVATE ${CMAKE_PROJECT_NAME})
+endfunction()
+
+make_example(example)
+make_example(enum_flag_example)
+make_example(example_containers_array)
+make_example(example_containers_bitset)
+make_example(example_containers_set)
+make_example(example_custom_name)
+make_example(example_switch)
+if(MAGIC_ENUM_OPT_ENABLE_NONASCII)
+    make_example(example_nonascii_name)
+endif()

third/magic_enum/example/enum_flag_example.cpp

@@ -0,0 +1,101 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <iostream>
+#include <string>
+
+#include <magic_enum/magic_enum.hpp>
+#include <magic_enum/magic_enum_iostream.hpp>
+
+enum class AnimalFlags : std::uint64_t { HasClaws = 1 << 10, CanFly = 1 << 20, EatsFish = 1 << 30, Endangered = std::uint64_t{1} << 40 };
+// Add specialization `is_flags` to define that enum are flags.
+template <>
+struct magic_enum::customize::enum_range<AnimalFlags> {
+  static constexpr bool is_flags = true;
+};
+
+int main() {
+  // Enum-flags variable to string name.
+  AnimalFlags f1 = AnimalFlags::Endangered;
+  auto f1_name = magic_enum::enum_name(f1);
+  std::cout << f1_name << std::endl; // Endangered
+
+  // String enum-flags name sequence.
+  constexpr auto names = magic_enum::enum_names<AnimalFlags>();
+  std::cout << "AnimalFlags names:";
+  for (const auto& n : names) {
+    std::cout << " " << n;
+  }
+  std::cout << std::endl;
+  // AnimalFlags names: HasClaws CanFly EatsFish Endangered
+
+  // String name to enum-flags value.
+  auto f2 = magic_enum::enum_flags_cast<AnimalFlags>("EatsFish|CanFly");
+  if (f2.has_value()) {
+    std::cout << "EatsFish|CanFly = " << magic_enum::enum_integer(f2.value()) << std::endl; // CanFly|EatsFish = 1074790400
+  }
+
+  // Integer value to enum-flags value.
+  auto f3 = magic_enum::enum_cast<AnimalFlags>(1073742848);
+  if (f3.has_value()) {
+    std::cout << magic_enum::enum_flags_name(f3.value()) << " = " << magic_enum::enum_integer(f3.value()) << std::endl; // HasClaws|EatsFish = 1073742848
+  }
+
+  // Enum-flags value to integer value.
+  auto f4_integer = magic_enum::enum_integer(AnimalFlags::HasClaws);
+  std::cout << "HasClaws = " << f4_integer << std::endl; // HasClaws = 1024
+
+  using magic_enum::iostream_operators::operator<<; // out-of-the-box ostream operator for enum-flags.
+  // Ostream operator for enum-flags.
+  std::cout << f1 << " " << f2 << " " << f3 << std::endl; // Endangered CanFly|EatsFish HasClaws|EatsFish
+
+  // Number of enum-flags values.
+  std::cout << "AnimalFlags enum size: " << magic_enum::enum_count<AnimalFlags>() << std::endl; // AnimalFlags enum size: 4
+
+  // Indexed access to enum-flags value.
+  std::cout << "AnimalFlags[0] = " << magic_enum::enum_value<AnimalFlags>(0) << std::endl; // AnimalFlags[0] = HasClaws
+
+  // Enum-flags value sequence.
+  constexpr auto values = magic_enum::enum_values<AnimalFlags>();
+  std::cout << "AnimalFlags values:";
+  for (const auto f : values) {
+    std::cout << " " << f; // Ostream operator for enum-flags.
+  }
+  std::cout << std::endl;
+  // AnimalFlags values: HasClaws CanFly EatsFish Endangered
+
+  using namespace magic_enum::bitwise_operators; // out-of-the-box bitwise operators for all enums.
+  // Support operators: ~, |, &, ^, |=, &=, ^=.
+  AnimalFlags flag = AnimalFlags::HasClaws | AnimalFlags::CanFly;
+  std::cout << flag << std::endl; // HasClaws|CanFly
+
+  // Enum-flags pair (value, string name) sequence.
+  constexpr auto entries = magic_enum::enum_entries<AnimalFlags>();
+  std::cout << "AnimalFlags entries:";
+  for (const auto& e : entries) {
+    std::cout << " "  << e.second << " = " << magic_enum::enum_integer(e.first);
+  }
+  std::cout << std::endl;
+  // AnimalFlags entries: AnimalFlags entries: HasClaws = 1024 CanFly = 1048576 EatsFish = 1073741824 Endangered = 1099511627776
+
+  return 0;
+}

third/magic_enum/example/example.cpp

@@ -0,0 +1,120 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <iostream>
+
+#include <magic_enum/magic_enum.hpp>
+#include <magic_enum/magic_enum_iostream.hpp>
+
+enum class Color : int { RED = -10, BLUE = 0, GREEN = 10 };
+
+template <typename E>
+auto to_integer(magic_enum::Enum<E> value) {
+  // magic_enum::Enum<E> - C++17 Concept for enum type.
+  return static_cast<magic_enum::underlying_type_t<E>>(value);
+}
+
+int main() {
+  // Enum variable to string name.
+  Color c1 = Color::RED;
+  auto c1_name = magic_enum::enum_name(c1);
+  std::cout << c1_name << std::endl; // RED
+
+  // String enum name sequence.
+  constexpr auto names = magic_enum::enum_names<Color>();
+  std::cout << "Color names:";
+  for (const auto& n : names) {
+    std::cout << " " << n;
+  }
+  std::cout << std::endl;
+  // Color names: RED BLUE GREEN
+
+  // String name to enum value.
+  auto c2 = magic_enum::enum_cast<Color>("BLUE");
+  if (c2.has_value()) {
+    std::cout << "BLUE = " << to_integer(c2.value()) << std::endl; // BLUE = 0
+  }
+
+  // Case insensitive enum_cast.
+  c2 = magic_enum::enum_cast<Color>("blue", magic_enum::case_insensitive);
+  if (c2.has_value()) {
+    std::cout << "BLUE = " << to_integer(c2.value()) << std::endl; // BLUE = 0
+  }
+
+  // Integer value to enum value.
+  auto c3 = magic_enum::enum_cast<Color>(10);
+  if (c3.has_value()) {
+    std::cout << "GREEN = " << magic_enum::enum_integer(c3.value()) << std::endl; // GREEN = 10
+  }
+
+  // Enum value to integer value.
+  auto c4_integer = magic_enum::enum_integer(Color::RED);
+  std::cout << "RED = " << c4_integer << std::endl; // RED = -10
+
+  using magic_enum::iostream_operators::operator<<; // out-of-the-box ostream operator for all enums.
+  // Ostream operator for enum.
+  std::cout << "Color: " << c1 << " " << c2 << " " << c3 << std::endl; // Color: RED BLUE GREEN
+
+  // Number of enum values.
+  std::cout << "Color enum size: " << magic_enum::enum_count<Color>() << std::endl; // Color size: 3
+
+  // Indexed access to enum value.
+  std::cout << "Color[0] = " << magic_enum::enum_value<Color>(0) << std::endl; // Color[0] = RED
+
+  // Enum value sequence.
+  constexpr auto values = magic_enum::enum_values<Color>();
+  std::cout << "Colors values:";
+  for (const auto c : values) {
+    std::cout << " " << c; // Ostream operator for enum.
+  }
+  std::cout << std::endl;
+  // Color values: RED BLUE GREEN
+
+  enum class Flags { A = 1, B = 2, C = 4, D = 8 };
+  using namespace magic_enum::bitwise_operators; // out-of-the-box bitwise operators for all enums.
+  // Support operators: ~, |, &, ^, |=, &=, ^=.
+  Flags flag = Flags::A | Flags::C;
+  std::cout << flag << std::endl; // 5
+
+  enum color { red, green, blue };
+
+  // Checks whether type is an Unscoped enumeration.
+  static_assert(magic_enum::is_unscoped_enum_v<color>);
+  static_assert(!magic_enum::is_unscoped_enum_v<Color>);
+  static_assert(!magic_enum::is_unscoped_enum_v<Flags>);
+
+  // Checks whether type is an Scoped enumeration.
+  static_assert(!magic_enum::is_scoped_enum_v<color>);
+  static_assert(magic_enum::is_scoped_enum_v<Color>);
+  static_assert(magic_enum::is_scoped_enum_v<Flags>);
+
+  // Enum pair (value enum, string enum name) sequence.
+  constexpr auto entries = magic_enum::enum_entries<Color>();
+  std::cout << "Colors entries:";
+  for (const auto& e : entries) {
+    std::cout << " "  << e.second << " = " << static_cast<int>(e.first);
+  }
+  std::cout << std::endl;
+  // Color entries: RED = -10 BLUE = 0 GREEN = 10
+
+  return 0;
+}

third/magic_enum/example/example_containers_array.cpp

@@ -0,0 +1,65 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.com>.
+// Copyright (c) 2022 - 2023 Bela Schaum <schaumb@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <iostream>
+
+#include <magic_enum/magic_enum_containers.hpp>
+
+enum class Color { RED = 1, GREEN = 2, BLUE = 4 };
+template <>
+struct magic_enum::customize::enum_range<Color> {
+  static constexpr bool is_flags = true;
+};
+
+struct RGB {
+
+  std::uint8_t r {};
+  std::uint8_t g {};
+  std::uint8_t b {};
+
+  [[nodiscard]] constexpr bool empty() { return std::equal_to{}(r, g) && std::equal_to{}(g, b) && std::equal_to{}(b, 0); }
+
+  [[nodiscard]] constexpr bool operator==(RGB rgb) const noexcept { return std::equal_to{}(r, rgb.r) && std::equal_to{}(g, rgb.g) && std::equal_to{}(b, rgb.b); }
+
+  friend std::ostream& operator<<(std::ostream& ostream, RGB rgb) {
+    ostream << "R=" << static_cast<std::uint32_t>(rgb.r) << " G=" << static_cast<std::uint32_t>(rgb.g) << " B=" << static_cast<std::uint32_t>(rgb.b);
+    return ostream;
+  }
+};
+
+constexpr std::uint8_t color_max = std::numeric_limits<std::uint8_t>::max();
+
+int main() {
+
+  constexpr magic_enum::containers::array<Color, RGB> color_rgb_initializer {{{{color_max, 0, 0}, {0, color_max, 0}, {0, 0, color_max}}}};
+
+  std::cout << magic_enum::containers::get<0>(color_rgb_initializer) << std::endl; // R=255 G=0 B=0
+  std::cout << magic_enum::containers::get<1>(color_rgb_initializer) << std::endl; // R=0 G=255 B=0
+  std::cout << magic_enum::containers::get<2>(color_rgb_initializer) << std::endl; // R=0 G=0 B=255
+
+  std::cout << magic_enum::containers::get<Color::RED>(color_rgb_initializer) << std::endl; // R=255 G=0 B=0
+  std::cout << magic_enum::containers::get<Color::GREEN>(color_rgb_initializer) << std::endl; // R=0 G=255 B=0
+  std::cout << magic_enum::containers::get<Color::BLUE>(color_rgb_initializer) << std::endl; // R=0 G=0 B=255
+
+  return 0;
+}

third/magic_enum/example/example_containers_bitset.cpp

@@ -0,0 +1,56 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.com>.
+// Copyright (c) 2022 - 2023 Bela Schaum <schaumb@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#if defined(_MSC_VER)
+#  pragma warning(push)
+#  pragma warning(disable : 4244) // warning C4244: 'argument': conversion from 'const T' to 'unsigned int', possible loss of data.
+#endif
+
+#include <iostream>
+
+#include <magic_enum/magic_enum_containers.hpp>
+
+enum class Color { RED = 1, GREEN = 2, BLUE = 4 };
+template <>
+struct magic_enum::customize::enum_range<Color> {
+  static constexpr bool is_flags = true;
+};
+
+int main() {
+
+  auto color_bitset = magic_enum::containers::bitset<Color>();
+  color_bitset.set(Color::GREEN);
+  color_bitset.set(Color::BLUE);
+
+  std::cout << std::boolalpha;
+  std::cout << color_bitset.size() << std::endl; // 3 == magic_enum::enum_count<Color>()
+  std::cout << color_bitset.all() << std::endl; // false
+  std::cout << color_bitset.any() << std::endl; // true
+  std::cout << color_bitset.none() << std::endl; // false
+  std::cout << color_bitset.count() << std::endl; // 2
+  std::cout << color_bitset.test(Color::RED) << std::endl; // false
+  std::cout << color_bitset.test(Color::GREEN) << std::endl; // true
+  std::cout << color_bitset.test(Color::BLUE) << std::endl; // true
+
+  return 0;
+}

third/magic_enum/example/example_containers_set.cpp

@@ -0,0 +1,56 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.com>.
+// Copyright (c) 2022 - 2023 Bela Schaum <schaumb@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#if defined(_MSC_VER)
+#  pragma warning(push)
+#  pragma warning(disable : 4244) // warning C4244: 'argument': conversion from 'const T' to 'unsigned int', possible loss of data.
+#endif
+
+#include <iostream>
+
+#include <magic_enum/magic_enum_containers.hpp>
+
+enum class Color { RED = 1, GREEN = 2, BLUE = 4 };
+template <>
+struct magic_enum::customize::enum_range<Color> {
+  static constexpr bool is_flags = true;
+};
+
+int main() {
+
+  std::cout << std::boolalpha;
+  magic_enum::containers::set color_set {Color::RED, Color::GREEN, Color::BLUE};
+  std::cout << color_set.empty() << std::endl; // false
+  std::cout << color_set.size() << std::endl; // 3
+
+  color_set.clear();
+  std::cout << color_set.empty() << std::endl; // true
+  std::cout << color_set.size() << std::endl; // 0
+
+  color_set.insert(Color::GREEN);
+  color_set.insert(Color::BLUE);
+  std::cout << color_set.empty() << std::endl; // false
+  std::cout << color_set.size() << std::endl; // 2
+
+  return 0;
+}

third/magic_enum/example/example_custom_name.cpp

@@ -0,0 +1,71 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2020 - 2024 Daniil Goncharov <neargye@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <iostream>
+
+#include <magic_enum/magic_enum.hpp>
+
+enum class Color : int { RED = -10, BLUE = 0, GREEN = 10 };
+
+// Сustom definitions of names for enum.
+// Specialization of `enum_name` must be injected in `namespace magic_enum::customize`.
+template <>
+constexpr magic_enum::customize::customize_t magic_enum::customize::enum_name<Color>(Color value) noexcept {
+  switch (value) {
+    case Color::RED:
+      return "the red color";
+    case Color::BLUE:
+      return "The BLUE";
+    case Color::GREEN:
+      return invalid_tag;
+  }
+  return default_tag;
+}
+
+enum class Numbers : int { One, Two, Three };
+
+// Сustom definitions of names for enum.
+// Specialization of `enum_name` must be injected in `namespace magic_enum::customize`.
+template <>
+constexpr magic_enum::customize::customize_t magic_enum::customize::enum_name<Numbers>(Numbers value) noexcept {
+  switch (value) {
+    case Numbers::One:
+      return "the one";
+    default:
+      return default_tag;
+  }
+}
+
+int main() {
+  std::cout << magic_enum::enum_name(Color::RED) << std::endl; // 'the red color'
+  std::cout << magic_enum::enum_name(Color::BLUE) << std::endl; // 'The BLUE'
+  std::cout << magic_enum::enum_name(Color::GREEN) << std::endl; // ''
+
+  std::cout << std::boolalpha;
+  std::cout << (magic_enum::enum_cast<Color>("the red color").value() == Color::RED) << std::endl; // true
+
+  std::cout << magic_enum::enum_name(Numbers::One) << std::endl; // 'the one'
+  std::cout << magic_enum::enum_name(Numbers::Two) << std::endl; // 'Two'
+  std::cout << magic_enum::enum_name(Numbers::Three) << std::endl; // 'Three'
+
+  return 0;
+}

third/magic_enum/example/example_nonascii_name.cpp

@@ -0,0 +1,45 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2020 - 2024 Daniil Goncharov <neargye@gmail.com>.
+// Copyright (c) 2020 - 2023 Uruha Komachin <uruhakomachin@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <iostream>
+
+#include <magic_enum/magic_enum.hpp>
+
+enum class Language : int {
+    日本語 = 10,
+    한국어 = 20,
+    English = 30,
+    😃 = 40,
+};
+
+int main() {
+  std::cout << magic_enum::enum_name(Language::日本語) << std::endl; // Japanese
+  std::cout << magic_enum::enum_name(Language::한국어) << std::endl; // Korean
+  std::cout << magic_enum::enum_name(Language::English) << std::endl; // English
+  std::cout << magic_enum::enum_name(Language::😃) << std::endl; // Emoji
+
+  std::cout << std::boolalpha;
+  std::cout << (magic_enum::enum_cast<Language>("日本語").value() == Language::日本語) << std::endl; // true
+
+  return 0;
+}

third/magic_enum/example/example_switch.cpp

@@ -0,0 +1,107 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.com>.
+// Copyright (c) 2022 - 2023 Bela Schaum <schaumb@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <iostream>
+
+#define MAGIC_ENUM_ENABLE_HASH
+#include <magic_enum/magic_enum_switch.hpp>
+
+enum class Color { RED, BLUE, GREEN };
+
+template <Color C>
+constexpr std::string_view DoWork() {
+  return "default";
+}
+
+template <>
+constexpr std::string_view DoWork<Color::GREEN>() {
+  return "override";
+}
+
+// Helper type for the visitor pattern.
+template <typename... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template <typename... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+int main() {
+  Color c = Color::RED;
+
+  auto lambda = [] (auto value) {
+    std::cout << DoWork<value>() << std::endl;
+  };
+
+  magic_enum::enum_switch(lambda, c); // prints "default"
+
+  c = Color::GREEN;
+
+  magic_enum::enum_switch(lambda, c); // prints "override"
+
+  // with object, explicit enum type
+  auto switcher1 = overloaded{
+    [] (magic_enum::enum_constant<Color::BLUE>) {
+      std::cout << "Blue" << std::endl;
+    },
+    [] (magic_enum::enum_constant<Color::RED>) {
+      std::cout << "Red" << std::endl;
+    }
+  };
+
+  magic_enum::enum_switch(switcher1, Color::GREEN); // prints nothing
+  magic_enum::enum_switch(switcher1, Color::BLUE); // prints "Blue"
+  magic_enum::enum_switch(switcher1, Color::RED); // prints "Red"
+
+  // explicit result type
+  auto switcher2 = overloaded{
+    [] (magic_enum::enum_constant<Color::GREEN>) {
+      return "called with green argument";
+    },
+    [] (Color other) { // default case
+      auto name = magic_enum::enum_name(other); // not empty
+      return "default: " + std::string{name};
+    }
+  };
+
+  std::cout << magic_enum::enum_switch<std::string>(switcher2, Color::GREEN) << std::endl; // prints "called with green argument"
+  std::cout << magic_enum::enum_switch<std::string>(switcher2, Color::RED) << std::endl; // prints "default: RED"
+
+  auto empty = magic_enum::enum_switch<std::string>(switcher2, static_cast<Color>(-3)); // returns an empty string
+  assert(empty.empty());
+
+  // result with default object
+  std::cout << magic_enum::enum_switch<std::string>(switcher2, static_cast<Color>(-3), "unrecognized") << std::endl; // prints "unrecognized"
+
+  auto switcher3 = overloaded{
+    [] (magic_enum::enum_constant<Color::RED>) -> std::optional<std::string> {
+      return "red result";
+    },
+    [] (magic_enum::enum_constant<Color::BLUE>) -> std::optional<std::string> {
+      return std::nullopt;
+    }
+  };
+
+  std::cout << std::boolalpha;
+  std::cout << magic_enum::enum_switch(switcher3, Color::GREEN, std::make_optional("cica")).value() << std::endl; // prints default: "cica"
+  std::cout << magic_enum::enum_switch(switcher3, Color::RED, std::make_optional("cica")).value() << std::endl; // prints: "red result"
+  std::cout << magic_enum::enum_switch(switcher3, Color::BLUE, std::make_optional("cica")).has_value() << std::endl; // prints: false
+
+  return 0;
+}