From b1c49e705bb4d15836b1fc632781c560be868a2f Mon Sep 17 00:00:00 2001 From: Mars Date: Sat, 28 Sep 2024 14:54:39 -0400 Subject: [PATCH] Finished validation layer stuffs --- .clang-format | 2 +- .envrc | 3 +- flake.nix | 3 + src/main.cpp | 146 +++- src/util/magic_enum.hpp | 1709 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 1841 insertions(+), 22 deletions(-) create mode 100644 src/util/magic_enum.hpp diff --git a/.clang-format b/.clang-format index 93a31a9..9d2cbde 100644 --- a/.clang-format +++ b/.clang-format @@ -9,7 +9,7 @@ AllowShortLoopsOnASingleLine: true BasedOnStyle: Chromium BinPackArguments: false BinPackParameters: false -ColumnLimit: 100 +ColumnLimit: 110 ConstructorInitializerIndentWidth: 2 ContinuationIndentWidth: 2 Cpp11BracedListStyle: false diff --git a/.envrc b/.envrc index c4b17d7..ae39e78 100644 --- a/.envrc +++ b/.envrc @@ -1 +1,2 @@ -use_flake +export NIXPKGS_ALLOW_UNSUPPORTED_SYSTEM=1 +use_flake . --impure diff --git a/flake.nix b/flake.nix index de0fb47..1b33f41 100644 --- a/flake.nix +++ b/flake.nix @@ -111,6 +111,9 @@ ] ++ deps; + VULKAN_SDK = "${vulkan-headers}"; + VK_LAYER_PATH = "${vulkan-validation-layers}/share/vulkan/explicit_layer.d"; + shellHook = '' export PATH="${llvmPackages_18.clang-tools.override {enableLibcxx = true;}}/bin:$PATH" ''; diff --git a/src/main.cpp b/src/main.cpp index e80bc71..60d387d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,11 +1,14 @@ #include #include #include +#include +#include #define GLFW_INCLUDE_NONE #define GLFW_INCLUDE_VULKAN #include +#include "util/magic_enum.hpp" #include "util/types.h" constexpr u32 WIDTH = 800; @@ -19,6 +22,35 @@ const bool enableValidationLayers = false; const bool enableValidationLayers = true; #endif +fn CreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pDebugMessenger +) -> VkResult { + auto func = std::bit_cast( + vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT") + ); + + if (func == nullptr) + return VK_ERROR_EXTENSION_NOT_PRESENT; + + return func(instance, pCreateInfo, pAllocator, pDebugMessenger); +} + +fn DestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT debugMessenger, + const VkAllocationCallbacks* pAllocator +) -> void { + auto func = std::bit_cast( + vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT") + ); + + if (func != nullptr) + func(instance, debugMessenger, pAllocator); +} + class Application { public: fn run() -> void { @@ -29,8 +61,9 @@ class Application { } private: - VkInstance mInstance; - GLFWwindow* mWindow; + VkDebugUtilsMessengerEXT mDebugMessenger; + VkInstance mInstance; + GLFWwindow* mWindow; static fn checkValidationLayerSupport() -> bool { u32 layerCount = 0; @@ -44,8 +77,7 @@ class Application { for (const auto& layerProperties : availableLayers) { if (strcmp( - static_cast(layerName), - static_cast(layerProperties.layerName) + static_cast(layerName), static_cast(layerProperties.layerName) ) == 0) { layerFound = true; break; @@ -69,10 +101,49 @@ class Application { return extensions; } + static fn getRequiredExtensions() -> std::vector { + u32 glfwExtensionCount = 0; + const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); + + std::vector extensions; + + if (glfwExtensions) { + std::span extSpan(glfwExtensions, glfwExtensionCount); + extensions.assign(extSpan.begin(), extSpan.end()); + } + + if (enableValidationLayers) + extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); + + return extensions; + } + + static VKAPI_ATTR fn VKAPI_CALL debugCallback( + // Severity - verbose, info, warning, error + VkDebugUtilsMessageSeverityFlagBitsEXT /*messageSeverity*/, + + // Message Type - general, validation, performance + VkDebugUtilsMessageTypeFlagsEXT /*messageType*/, + + // Callback Data - Contains details of the message + // * pMessage - The message as a null-terminated string + // * pObjects - Array of related objects + // * objectCount - Number of related objects + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + + // User Data - Any extra data the user may want to pass to the function + void* /*pUserData*/ + ) -> VkBool32 /* If true, abort the call */ { + std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl; + + return VK_FALSE; + } + fn createInstance() -> void { if (enableValidationLayers && !checkValidationLayerSupport()) throw std::runtime_error("Validation layers requested, but not available!"); + // General Metadata VkApplicationInfo appInfo {}; appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; // Used for pNext appInfo.pApplicationName = "Hello Triangle"; @@ -81,33 +152,38 @@ class Application { appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); appInfo.apiVersion = VK_API_VERSION_1_0; - uint32_t glfwExtensionCount = 0; - const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); - + // Information used by vkCreateInstance VkInstanceCreateInfo createInfo {}; - createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; - createInfo.pApplicationInfo = &appInfo; - createInfo.enabledExtensionCount = glfwExtensionCount; - createInfo.ppEnabledExtensionNames = glfwExtensions; + createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + createInfo.pApplicationInfo = &appInfo; + + VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo {}; if (enableValidationLayers) { createInfo.enabledLayerCount = static_cast(validationLayers.size()); createInfo.ppEnabledLayerNames = validationLayers.data(); + + populateDebugMessengerCreateInfo(debugCreateInfo); + createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo; } else { createInfo.enabledLayerCount = 0; + + createInfo.pNext = nullptr; } - std::vector requiredExtensions; - - requiredExtensions.emplace_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); + // Fixes macOS crashes + std::vector extensions = getRequiredExtensions(); + extensions.emplace_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; + createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.ppEnabledExtensionNames = extensions.data(); - createInfo.enabledExtensionCount = static_cast(requiredExtensions.size()); - createInfo.ppEnabledExtensionNames = requiredExtensions.data(); - - if (vkCreateInstance(&createInfo, nullptr, &mInstance) != VK_SUCCESS) - throw std::runtime_error("failed to create instance!"); + // Finally, create the instance (and throw an error if it fails) + if (auto result = vkCreateInstance(&createInfo, nullptr, &mInstance); result != VK_SUCCESS) + throw std::runtime_error( + string("Failed to create instance! Error: ") + string(magic_enum::enum_name(result)) + ); } fn initWindow() -> void { @@ -123,13 +199,43 @@ class Application { mWindow = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr); } - fn initVulkan() -> void { createInstance(); } + fn initVulkan() -> void { + createInstance(); + setupDebugMessenger(); + } + + static fn populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) -> void { + createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; + createInfo.pfnUserCallback = debugCallback; + } + + fn setupDebugMessenger() -> void { + if (!enableValidationLayers) + return; + + VkDebugUtilsMessengerCreateInfoEXT createInfo; + populateDebugMessengerCreateInfo(createInfo); + + if (CreateDebugUtilsMessengerEXT(mInstance, &createInfo, nullptr, &mDebugMessenger) != VK_SUCCESS) { + throw std::runtime_error("Failed to set up debug messenger!"); + } + } fn mainLoop() -> void { while (!glfwWindowShouldClose(mWindow)) glfwPollEvents(); } fn cleanup() -> void { + if (enableValidationLayers) + DestroyDebugUtilsMessengerEXT(mInstance, mDebugMessenger, nullptr); + vkDestroyInstance(mInstance, nullptr); glfwDestroyWindow(mWindow); glfwTerminate(); diff --git a/src/util/magic_enum.hpp b/src/util/magic_enum.hpp new file mode 100644 index 0000000..20ca352 --- /dev/null +++ b/src/util/magic_enum.hpp @@ -0,0 +1,1709 @@ +// __ __ _ ______ _____ +// | \/ | (_) | ____| / ____|_ _ +// | \ / | __ _ __ _ _ ___ | |__ _ __ _ _ _ __ ___ | | _| |_ _| |_ +// | |\/| |/ _` |/ _` | |/ __| | __| | '_ \| | | | '_ ` _ \ | | |_ _|_ _| +// | | | | (_| | (_| | | (__ | |____| | | | |_| | | | | | | | |____|_| |_| +// |_| |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_| \_____| +// __/ | https://github.com/Neargye/magic_enum +// |___/ version 0.9.6 +// +// Licensed under the MIT License . +// SPDX-License-Identifier: MIT +// Copyright (c) 2019 - 2024 Daniil Goncharov . +// +// 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. + +#ifndef NEARGYE_MAGIC_ENUM_HPP +#define NEARGYE_MAGIC_ENUM_HPP + +#define MAGIC_ENUM_VERSION_MAJOR 0 +#define MAGIC_ENUM_VERSION_MINOR 9 +#define MAGIC_ENUM_VERSION_PATCH 6 + +#ifndef MAGIC_ENUM_USE_STD_MODULE +#include +#include +#include +#include +#include +#include +#include +#endif + +#if defined(MAGIC_ENUM_CONFIG_FILE) +#include MAGIC_ENUM_CONFIG_FILE +#endif + +#ifndef MAGIC_ENUM_USE_STD_MODULE +#if !defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) +#include +#endif +#if !defined(MAGIC_ENUM_USING_ALIAS_STRING) +#include +#endif +#if !defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) +#include +#endif +#endif + +#if defined(MAGIC_ENUM_NO_ASSERT) +#define MAGIC_ENUM_ASSERT(...) static_cast(0) +#elif !defined(MAGIC_ENUM_ASSERT) +#include +#define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__)) +#endif + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunknown-warning-option" +#pragma clang diagnostic ignored "-Wenum-constexpr-conversion" +#pragma clang diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast('\0')' for + // char_type = char (common on Linux). +#elif defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // May be used uninitialized 'return {};'. +#pragma GCC diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast('\0')' for + // char_type = char (common on Linux). +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable : 26495) // Variable 'static_str::chars_' is uninitialized. +#pragma warning(disable : 28020) // Arithmetic overflow: Using operator '-' on a 4 byte value and + // then casting the result to a 8 byte value. +#pragma warning(disable : 26451 \ +) // The expression '0<=_Param_(1)&&_Param_(1)<=1-1' is not true at this call. +#pragma warning(disable : 4514) // Unreferenced inline function has been removed. +#endif + +// Checks magic_enum compiler compatibility. +#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || \ + defined(_MSC_VER) && _MSC_VER >= 1910 || defined(__RESHARPER__) +#undef MAGIC_ENUM_SUPPORTED +#define MAGIC_ENUM_SUPPORTED 1 +#endif + +// Checks magic_enum compiler aliases compatibility. +#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || \ + defined(_MSC_VER) && _MSC_VER >= 1920 +#undef MAGIC_ENUM_SUPPORTED_ALIASES +#define MAGIC_ENUM_SUPPORTED_ALIASES 1 +#endif + +// Enum value must be greater or equals than MAGIC_ENUM_RANGE_MIN. By default MAGIC_ENUM_RANGE_MIN = +// -128. If need another min range for all enum types by default, redefine the macro +// MAGIC_ENUM_RANGE_MIN. +#if !defined(MAGIC_ENUM_RANGE_MIN) +#define MAGIC_ENUM_RANGE_MIN -128 +#endif + +// Enum value must be less or equals than MAGIC_ENUM_RANGE_MAX. By default MAGIC_ENUM_RANGE_MAX = +// 127. If need another max range for all enum types by default, redefine the macro +// MAGIC_ENUM_RANGE_MAX. +#if !defined(MAGIC_ENUM_RANGE_MAX) +#define MAGIC_ENUM_RANGE_MAX 127 +#endif + +// Improve ReSharper C++ intellisense performance with builtins, avoiding unnecessary template +// instantiations. +#if defined(__RESHARPER__) +#undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN +#undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN +#if __RESHARPER__ >= 20230100 +#define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) __rscpp_enumerator_name(V) +#define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) __rscpp_type_name() +#else +#define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) nullptr +#define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) nullptr +#endif +#endif + +namespace magic_enum { + +// If need another optional type, define the macro MAGIC_ENUM_USING_ALIAS_OPTIONAL. +#if defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) + MAGIC_ENUM_USING_ALIAS_OPTIONAL +#else + using std::optional; +#endif + +// If need another string_view type, define the macro MAGIC_ENUM_USING_ALIAS_STRING_VIEW. +#if defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) + MAGIC_ENUM_USING_ALIAS_STRING_VIEW +#else + using std::string_view; +#endif + +// If need another string type, define the macro MAGIC_ENUM_USING_ALIAS_STRING. +#if defined(MAGIC_ENUM_USING_ALIAS_STRING) + MAGIC_ENUM_USING_ALIAS_STRING +#else + using std::string; +#endif + + using char_type = string_view::value_type; + static_assert( + std::is_same_v, + "magic_enum::customize requires same string_view::value_type and string::value_type" + ); + static_assert( + [] { + if constexpr (std::is_same_v) { + constexpr const char c[] = + "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|"; + constexpr const wchar_t wc[] = + L"abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|"; + static_assert( + std::size(c) == std::size(wc), + "magic_enum::customize identifier characters are multichars in wchar_t." + ); + + for (std::size_t i = 0; i < std::size(c); ++i) { + if (c[i] != wc[i]) { + return false; + } + } + } + return true; + }(), + "magic_enum::customize wchar_t is not compatible with ASCII." + ); + + namespace customize { + + // Enum value must be in range [MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]. By default + // MAGIC_ENUM_RANGE_MIN = -128, MAGIC_ENUM_RANGE_MAX = 127. If need another range for all enum + // types by default, redefine the macro MAGIC_ENUM_RANGE_MIN and MAGIC_ENUM_RANGE_MAX. If need + // another range for specific enum type, add specialization enum_range for necessary enum type. + template + struct enum_range { + static constexpr int min = MAGIC_ENUM_RANGE_MIN; + static constexpr int max = MAGIC_ENUM_RANGE_MAX; + }; + + static_assert( + MAGIC_ENUM_RANGE_MAX > MAGIC_ENUM_RANGE_MIN, + "MAGIC_ENUM_RANGE_MAX must be greater than MAGIC_ENUM_RANGE_MIN." + ); + + namespace detail { + + enum class customize_tag { default_tag, invalid_tag, custom_tag }; + + } // namespace magic_enum::customize::detail + + class customize_t : public std::pair { + public: + constexpr customize_t(string_view srt) + : std::pair { detail::customize_tag::custom_tag, srt } { + } + constexpr customize_t(const char_type* srt) : customize_t { string_view { srt } } {} + constexpr customize_t(detail::customize_tag tag) + : std::pair { tag, string_view {} } { + MAGIC_ENUM_ASSERT(tag != detail::customize_tag::custom_tag); + } + }; + + // Default customize. + inline constexpr auto default_tag = customize_t { detail::customize_tag::default_tag }; + // Invalid customize. + inline constexpr auto invalid_tag = customize_t { detail::customize_tag::invalid_tag }; + + // If need custom names for enum, add specialization enum_name for necessary enum type. + template + constexpr customize_t enum_name(E) noexcept { + return default_tag; + } + + // If need custom type name for enum, add specialization enum_type_name for necessary enum type. + template + constexpr customize_t enum_type_name() noexcept { + return default_tag; + } + + } // namespace magic_enum::customize + + namespace detail { + + template + struct supported +#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED || defined(MAGIC_ENUM_NO_CHECK_SUPPORT) + : std::true_type { + }; +#else + : std::false_type { + }; +#endif + + template < + auto V, + typename E = std::decay_t, + std::enable_if_t, int> = 0> + using enum_constant = std::integral_constant; + + template + inline constexpr bool always_false_v = false; + + template + struct has_is_flags : std::false_type {}; + + template + struct has_is_flags::is_flags)>> + : std::bool_constant< + std::is_same_v::is_flags)>>> {}; + + template + struct range_min : std::integral_constant {}; + + template + struct range_min::min)>> + : std::integral_constant< + decltype(customize::enum_range::min), + customize::enum_range::min> {}; + + template + struct range_max : std::integral_constant {}; + + template + struct range_max::max)>> + : std::integral_constant< + decltype(customize::enum_range::max), + customize::enum_range::max> {}; + + struct str_view { + const char* str_ = nullptr; + std::size_t size_ = 0; + }; + + template + class static_str { + public: + constexpr explicit static_str(str_view str) noexcept + : static_str { str.str_, std::make_integer_sequence {} } { + MAGIC_ENUM_ASSERT(str.size_ == N); + } + + constexpr explicit static_str(string_view str) noexcept + : static_str { str.data(), std::make_integer_sequence {} } { + MAGIC_ENUM_ASSERT(str.size() == N); + } + + constexpr const char_type* data() const noexcept { return chars_; } + + constexpr std::uint16_t size() const noexcept { return N; } + + constexpr operator string_view() const noexcept { return { data(), size() }; } + + private: + template + constexpr static_str(const char* str, std::integer_sequence) noexcept + : chars_ { static_cast(str[I])..., static_cast('\0') } {} + + template + constexpr static_str(string_view str, std::integer_sequence) noexcept + : chars_ { str[I]..., static_cast('\0') } {} + + char_type chars_[static_cast(N) + 1]; + }; + + template <> + class static_str<0> { + public: + constexpr explicit static_str() = default; + + constexpr explicit static_str(str_view) noexcept {} + + constexpr explicit static_str(string_view) noexcept {} + + constexpr const char_type* data() const noexcept { return nullptr; } + + constexpr std::uint16_t size() const noexcept { return 0; } + + constexpr operator string_view() const noexcept { return {}; } + }; + + template > + class case_insensitive { + static constexpr char_type to_lower(char_type c) noexcept { + return (c >= static_cast('A') && c <= static_cast('Z')) + ? static_cast( + c + (static_cast('a') - static_cast('A')) + ) + : c; + } + + public: + template + constexpr auto operator()(L lhs, R rhs) const noexcept + -> std::enable_if_t< + std::is_same_v, char_type> && std::is_same_v, char_type>, + bool> { + return Op {}(to_lower(lhs), to_lower(rhs)); + } + }; + + constexpr std::size_t find(string_view str, char_type c) noexcept { +#if defined(__clang__) && __clang_major__ < 9 && defined(__GLIBCXX__) || \ + defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) + // https://stackoverflow.com/questions/56484834/constexpr-stdstring-viewfind-last-of-doesnt-work-on-clang-8-with-libstdc + // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html + constexpr bool workaround = true; +#else + constexpr bool workaround = false; +#endif + + if constexpr (workaround) { + for (std::size_t i = 0; i < str.size(); ++i) { + if (str[i] == c) { + return i; + } + } + + return string_view::npos; + } else { + return str.find(c); + } + } + + template + constexpr bool is_default_predicate() noexcept { + return std:: + is_same_v, std::equal_to> || + std::is_same_v, std::equal_to<>>; + } + + template + constexpr bool is_nothrow_invocable() { + return is_default_predicate() || + std::is_nothrow_invocable_r_v; + } + + template + constexpr bool cmp_equal( + string_view lhs, + string_view rhs, + [[maybe_unused]] BinaryPredicate&& p + ) noexcept(is_nothrow_invocable()) { +#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) + // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html + // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html + constexpr bool workaround = true; +#else + constexpr bool workaround = false; +#endif + + if constexpr (!is_default_predicate() || workaround) { + if (lhs.size() != rhs.size()) { + return false; + } + + const auto size = lhs.size(); + for (std::size_t i = 0; i < size; ++i) { + if (!p(lhs[i], rhs[i])) { + return false; + } + } + + return true; + } else { + return lhs == rhs; + } + } + + template + constexpr bool cmp_less(L lhs, R rhs) noexcept { + static_assert( + std::is_integral_v && std::is_integral_v, + "magic_enum::detail::cmp_less requires integral type." + ); + + if constexpr (std::is_signed_v == std::is_signed_v) { + // If same signedness (both signed or both unsigned). + return lhs < rhs; + } else if constexpr (std::is_same_v) { // bool special case + return static_cast(lhs) < rhs; + } else if constexpr (std::is_same_v) { // bool special case + return lhs < static_cast(rhs); + } else if constexpr (std::is_signed_v) { + // If 'right' is negative, then result is 'false', otherwise cast & compare. + return rhs > 0 && lhs < static_cast>(rhs); + } else { + // If 'left' is negative, then result is 'true', otherwise cast & compare. + return lhs < 0 || static_cast>(lhs) < rhs; + } + } + + template + constexpr I log2(I value) noexcept { + static_assert(std::is_integral_v, "magic_enum::detail::log2 requires integral type."); + + if constexpr (std::is_same_v) { // bool special case + return MAGIC_ENUM_ASSERT(false), value; + } else { + auto ret = I { 0 }; + for (; value > I { 1 }; value >>= I { 1 }, ++ret) {} + + return ret; + } + } + +#if defined(__cpp_lib_array_constexpr) && __cpp_lib_array_constexpr >= 201603L +#define MAGIC_ENUM_ARRAY_CONSTEXPR 1 +#else + template + constexpr std::array, N> + to_array(T (&a)[N], std::index_sequence) noexcept { + return { { a[I]... } }; + } +#endif + + template + inline constexpr bool is_enum_v = std::is_enum_v && std::is_same_v>; + + template + constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + if constexpr (supported::value) { +#if defined(MAGIC_ENUM_GET_TYPE_NAME_BUILTIN) + constexpr auto name_ptr = MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(E); + constexpr auto name = + name_ptr ? str_view { name_ptr, std::char_traits::length(name_ptr) } : str_view {}; +#elif defined(__clang__) + str_view name; + if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { + static_assert(always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__."); + return str_view {}; + } else { + name.size_ = sizeof(__PRETTY_FUNCTION__) - 36; + name.str_ = __PRETTY_FUNCTION__ + 34; + } +#elif defined(__GNUC__) + auto name = str_view { __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1 }; + if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { + static_assert(always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__."); + return str_view {}; + } else if (name.str_[name.size_ - 1] == ']') { + name.size_ -= 50; + name.str_ += 49; + } else { + name.size_ -= 40; + name.str_ += 37; + } +#elif defined(_MSC_VER) + // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284). + str_view name; + name.str_ = __FUNCSIG__; + name.str_ += 40; + name.size_ += sizeof(__FUNCSIG__) - 57; +#else + auto name = str_view {}; +#endif + std::size_t p = 0; + for (std::size_t i = name.size_; i > 0; --i) { + if (name.str_[i] == ':') { + p = i + 1; + break; + } + } + if (p > 0) { + name.size_ -= p; + name.str_ += p; + } + return name; + } else { + return str_view {}; // Unsupported compiler or Invalid customize. + } + } + + template + constexpr auto type_name() noexcept { + [[maybe_unused]] constexpr auto custom = customize::enum_type_name(); + static_assert( + std::is_same_v, customize::customize_t>, + "magic_enum::customize requires customize_t type." + ); + if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { + constexpr auto name = custom.second; + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return static_str { name }; + } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) { + return static_str<0> {}; + } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { + constexpr auto name = n(); + return static_str { name }; + } else { + static_assert(always_false_v, "magic_enum::customize invalid."); + } + } + + template + inline constexpr auto type_name_v = type_name(); + + template + constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + if constexpr (supported::value) { +#if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN) + constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V); + auto name = + name_ptr ? str_view { name_ptr, std::char_traits::length(name_ptr) } : str_view {}; +#elif defined(__clang__) + str_view name; + if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { + static_assert( + always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__." + ); + return str_view {}; + } else { + name.size_ = sizeof(__PRETTY_FUNCTION__) - 36; + name.str_ = __PRETTY_FUNCTION__ + 34; + } + if (name.size_ > 22 && name.str_[0] == '(' && name.str_[1] == 'a' && name.str_[10] == ' ' && + name.str_[22] == ':') { + name.size_ -= 23; + name.str_ += 23; + } + if (name.str_[0] == '(' || name.str_[0] == '-' || + (name.str_[0] >= '0' && name.str_[0] <= '9')) { + name = str_view {}; + } +#elif defined(__GNUC__) + auto name = str_view { __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1 }; + if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { + static_assert( + always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__." + ); + return str_view {}; + } else if (name.str_[name.size_ - 1] == ']') { + name.size_ -= 55; + name.str_ += 54; + } else { + name.size_ -= 40; + name.str_ += 37; + } + if (name.str_[0] == '(') { + name = str_view {}; + } +#elif defined(_MSC_VER) + str_view name; + if ((__FUNCSIG__[5] == '_' && __FUNCSIG__[35] != '(') || + (__FUNCSIG__[5] == 'c' && __FUNCSIG__[41] != '(')) { + // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284). + name.str_ = __FUNCSIG__; + name.str_ += 35; + name.size_ = sizeof(__FUNCSIG__) - 52; + } +#else + auto name = str_view {}; +#endif + std::size_t p = 0; + for (std::size_t i = name.size_; i > 0; --i) { + if (name.str_[i] == ':') { + p = i + 1; + break; + } + } + if (p > 0) { + name.size_ -= p; + name.str_ += p; + } + return name; + } else { + return str_view {}; // Unsupported compiler or Invalid customize. + } + } + +#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1920 +#define MAGIC_ENUM_VS_2017_WORKAROUND 1 +#endif + +#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) + template + constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + +#if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN) + constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V); + auto name = + name_ptr ? str_view { name_ptr, std::char_traits::length(name_ptr) } : str_view {}; +#else + // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284). + str_view name; + name.str_ = __FUNCSIG__; + name.size_ = sizeof(__FUNCSIG__) - 17; + std::size_t p = 0; + for (std::size_t i = name.size_; i > 0; --i) { + if (name.str_[i] == ',' || name.str_[i] == ':') { + p = i + 1; + break; + } + } + if (p > 0) { + name.size_ -= p; + name.str_ += p; + } + if (name.str_[0] == '(' || name.str_[0] == '-' || + (name.str_[0] >= '0' && name.str_[0] <= '9')) { + name = str_view {}; + } + return name; +#endif + } +#endif + + template + constexpr auto enum_name() noexcept { + [[maybe_unused]] constexpr auto custom = customize::enum_name(V); + static_assert( + std::is_same_v, customize::customize_t>, + "magic_enum::customize requires customize_t type." + ); + if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { + constexpr auto name = custom.second; + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return static_str { name }; + } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) { + return static_str<0> {}; + } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { +#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) + constexpr auto name = n(); +#else + constexpr auto name = n(); +#endif + return static_str { name }; + } else { + static_assert(always_false_v, "magic_enum::customize invalid."); + } + } + + template + inline constexpr auto enum_name_v = enum_name(); + + template + constexpr bool is_valid() noexcept { +#if defined(__clang__) && __clang_major__ >= 16 + // https://reviews.llvm.org/D130058, https://reviews.llvm.org/D131307 + constexpr E v = __builtin_bit_cast(E, V); +#else + constexpr E v = static_cast(V); +#endif + [[maybe_unused]] constexpr auto custom = customize::enum_name(v); + static_assert( + std::is_same_v, customize::customize_t>, + "magic_enum::customize requires customize_t type." + ); + if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { + constexpr auto name = custom.second; + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return name.size() != 0; + } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { +#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) + return n().size_ != 0; +#else + return n().size_ != 0; +#endif + } else { + return false; + } + } + + enum class enum_subtype { common, flags }; + + template > + constexpr U ualue(std::size_t i) noexcept { + if constexpr (std::is_same_v) { // bool special case + static_assert(O == 0, "magic_enum::detail::ualue requires valid offset."); + + return static_cast(i); + } else if constexpr (S == enum_subtype::flags) { + return static_cast(U { 1 } << static_cast(static_cast(i) + O)); + } else { + return static_cast(static_cast(i) + O); + } + } + + template > + constexpr E value(std::size_t i) noexcept { + return static_cast(ualue(i)); + } + + template > + constexpr int reflected_min() noexcept { + if constexpr (S == enum_subtype::flags) { + return 0; + } else { + constexpr auto lhs = range_min::value; + constexpr auto rhs = (std::numeric_limits::min)(); + + if constexpr (cmp_less(rhs, lhs)) { + return lhs; + } else { + return rhs; + } + } + } + + template > + constexpr int reflected_max() noexcept { + if constexpr (S == enum_subtype::flags) { + return std::numeric_limits::digits - 1; + } else { + constexpr auto lhs = range_max::value; + constexpr auto rhs = (std::numeric_limits::max)(); + + if constexpr (cmp_less(lhs, rhs)) { + return lhs; + } else { + return rhs; + } + } + } + +#define MAGIC_ENUM_FOR_EACH_256(T) \ + T(0) \ + T(1) T(2) T(3) T(4) T(5) T(6) T(7) T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15) T(16) T(17) \ + T(18) T(19) T(20) T(21) T(22) T(23) T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31) T(32) \ + T(33) T(34) T(35) T(36) T(37) T(38) T(39) T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47) \ + T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55) T(56) T(57) T(58) T(59) T(60) T(61) T(62) \ + T(63) T(64) T(65) T(66) T(67) T(68) T(69) T(70) T(71) T(72) T(73) T(74) T(75) T(76) \ + T(77) T(78) T(79) T(80) T(81) T(82) T(83) T(84) T(85) T(86) T(87) T(88) T(89) T(90) \ + T(91) T(92) T(93) T(94) T(95) T(96) T(97) T(98) T(99) T(100) T(101) T(102) T(103) \ + T(104) T(105) T(106) T(107) T(108) T(109) T(110) T(111) T(112) T(113) T(114) \ + T(115) T(116) T(117) T(118) T(119) T(120) T(121) T(122) T(123) T(124) T(125) \ + T(126) T(127) T(128) T(129) T(130) T(131) T(132) T(133) T(134) T(135) T(136) \ + T(137) T(138) T(139) T(140) T(141) T(142) T(143) T(144) T(145) T(146) T(147) \ + T(148) T(149) T(150) T(151) T(152) T(153) T(154) T(155) T(156) T(157) \ + T(158) T(159) T(160) T(161) T(162) T(163) T(164) T(165) T(166) T(167) \ + T(168) T(169) T(170) T(171) T(172) T(173) T(174) T(175) T(176) T(177) \ + T(178) T(179) T(180) T(181) T(182) T(183) T(184) T(185) T(186) \ + T(187) T(188) T(189) T(190) T(191) T(192) T(193) T(194) T(195) \ + T(196) T(197) T(198) T(199) T(200) T(201) T(202) T(203) T(204) \ + T(205) T(206) T(207) T(208) T(209) T(210) T(211) T(212) T(213) \ + T(214) T(215) T(216) T(217) T(218) T(219) T(220) T(221) \ + T(222) T(223) T(224) T(225) T(226) T(227) T(228) T(229) \ + T(230) T(231) T(232) T(233) T(234) T(235) T(236) T(237) \ + T(238) T(239) T(240) T(241) T(242) T(243) T(244) \ + T(245) T(246) T(247) T(248) T(249) T(250) T(251) \ + T(252) T(253) T(254) T(255) + + template + constexpr void valid_count(bool* valid, std::size_t& count) noexcept { +#define MAGIC_ENUM_V(O) \ + if constexpr ((I + O) < Size) { \ + if constexpr (is_valid(I + O)>()) { \ + valid[I + O] = true; \ + ++count; \ + } \ + } + + MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_V) + + if constexpr ((I + 256) < Size) { + valid_count(valid, count); + } +#undef MAGIC_ENUM_V + } + + template + struct valid_count_t { + std::size_t count = 0; + bool valid[N] = {}; + }; + + template + constexpr auto valid_count() noexcept { + valid_count_t vc; + valid_count(vc.valid, vc.count); + return vc; + } + + template + constexpr auto values() noexcept { + constexpr auto vc = valid_count(); + + if constexpr (vc.count > 0) { +#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR) + std::array values = {}; +#else + E values[vc.count] = {}; +#endif + for (std::size_t i = 0, v = 0; v < vc.count; ++i) { + if (vc.valid[i]) { + values[v++] = value(i); + } + } +#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR) + return values; +#else + return to_array(values, std::make_index_sequence {}); +#endif + } else { + return std::array {}; + } + } + + template > + constexpr auto values() noexcept { + constexpr auto min = reflected_min(); + constexpr auto max = reflected_max(); + constexpr auto range_size = max - min + 1; + static_assert(range_size > 0, "magic_enum::enum_range requires valid size."); + + return values(); + } + + template > + constexpr enum_subtype subtype(std::true_type) noexcept { + if constexpr (std::is_same_v) { // bool special case + return enum_subtype::common; + } else if constexpr (has_is_flags::value) { + return customize::enum_range::is_flags ? enum_subtype::flags : enum_subtype::common; + } else { +#if defined(MAGIC_ENUM_AUTO_IS_FLAGS) + constexpr auto flags_values = values(); + constexpr auto default_values = values(); + if (flags_values.size() == 0 || default_values.size() > flags_values.size()) { + return enum_subtype::common; + } + for (std::size_t i = 0; i < default_values.size(); ++i) { + const auto v = static_cast(default_values[i]); + if (v != 0 && (v & (v - 1)) != 0) { + return enum_subtype::common; + } + } + return enum_subtype::flags; +#else + return enum_subtype::common; +#endif + } + } + + template + constexpr enum_subtype subtype(std::false_type) noexcept { + // For non-enum type return default common subtype. + return enum_subtype::common; + } + + template > + inline constexpr auto subtype_v = subtype(std::is_enum {}); + + template + inline constexpr auto values_v = values(); + + template > + using values_t = decltype((values_v)); + + template + inline constexpr auto count_v = values_v.size(); + + template > + inline constexpr auto min_v = + (count_v > 0) ? static_cast(values_v.front()) : U { 0 }; + + template > + inline constexpr auto max_v = + (count_v > 0) ? static_cast(values_v.back()) : U { 0 }; + + template + constexpr auto names(std::index_sequence) noexcept { + constexpr auto names = + std::array { { enum_name_v[I]>... } }; + return names; + } + + template + inline constexpr auto names_v = names(std::make_index_sequence> {}); + + template > + using names_t = decltype((names_v)); + + template + constexpr auto entries(std::index_sequence) noexcept { + constexpr auto entries = std::array, sizeof...(I)> { + { { values_v[I], enum_name_v[I]> }... } + }; + return entries; + } + + template + inline constexpr auto entries_v = entries(std::make_index_sequence> {}); + + template > + using entries_t = decltype((entries_v)); + + template > + constexpr bool is_sparse() noexcept { + if constexpr (count_v == 0) { + return false; + } else if constexpr (std::is_same_v) { // bool special case + return false; + } else { + constexpr auto max = (S == enum_subtype::flags) ? log2(max_v) : max_v; + constexpr auto min = (S == enum_subtype::flags) ? log2(min_v) : min_v; + constexpr auto range_size = max - min + 1; + + return range_size != count_v; + } + } + + template > + inline constexpr bool is_sparse_v = is_sparse(); + + template + struct is_reflected +#if defined(MAGIC_ENUM_NO_CHECK_REFLECTED_ENUM) + : std::true_type { + }; +#else + : std::bool_constant && (count_v != 0)> { + }; +#endif + + template + inline constexpr bool is_reflected_v = is_reflected, S> {}; + + template + struct enable_if_enum {}; + + template + struct enable_if_enum { + using type = R; + static_assert( + supported::value, + "magic_enum unsupported compiler " + "(https://github.com/Neargye/magic_enum#compiler-compatibility)." + ); + }; + + template < + typename T, + typename R, + typename BinaryPredicate = std::equal_to<>, + typename D = std::decay_t> + using enable_if_t = typename enable_if_enum< + std::is_enum_v && std::is_invocable_r_v, + R>::type; + + template >, int> = 0> + using enum_concept = T; + + template > + struct is_scoped_enum : std::false_type {}; + + template + struct is_scoped_enum + : std::bool_constant>> {}; + + template > + struct is_unscoped_enum : std::false_type {}; + + template + struct is_unscoped_enum + : std::bool_constant>> {}; + + template >> + struct underlying_type {}; + + template + struct underlying_type : std::underlying_type> {}; + +#if defined(MAGIC_ENUM_ENABLE_HASH) || defined(MAGIC_ENUM_ENABLE_HASH_SWITCH) + + template + struct constexpr_hash_t; + + template + struct constexpr_hash_t>> { + constexpr auto operator()(Value value) const noexcept { + using U = typename underlying_type::type; + if constexpr (std::is_same_v) { // bool special case + return static_cast(value); + } else { + return static_cast(value); + } + } + using secondary_hash = constexpr_hash_t; + }; + + template + struct constexpr_hash_t>> { + static constexpr std::uint32_t crc_table[256] { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, + 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, + 0xe7b82d07L, 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, + 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, + 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, 0x35b5a8faL, 0x42b2986cL, + 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, + 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL, + 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, + 0xb6662d3dL, 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, + 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, + 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, + 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, + 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L, + 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, + 0xce61e49fL, 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, + 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, + 0x9dd277afL, 0x04db2615L, 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, + 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, + 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, 0xd6d6a3e8L, + 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, + 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, + 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, + 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, + 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, + 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L, 0x88085ae6L, + 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, + 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, + 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, + 0x47b2cf7fL, 0x30b5ffe9L, 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, + 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL + }; + constexpr std::uint32_t operator()(string_view value) const noexcept { + auto crc = static_cast(0xffffffffL); + for (const auto c : value) { + crc = (crc >> 8) ^ crc_table[(crc ^ static_cast(c)) & 0xff]; + } + return crc ^ 0xffffffffL; + } + + struct secondary_hash { + constexpr std::uint32_t operator()(string_view value) const noexcept { + auto acc = static_cast(2166136261ULL); + for (const auto c : value) { + acc = + ((acc ^ static_cast(c)) * static_cast(16777619ULL)) & + (std::numeric_limits::max)(); + } + return static_cast(acc); + } + }; + }; + + template + inline constexpr Hash hash_v {}; + + template + constexpr auto calculate_cases(std::size_t Page) noexcept { + constexpr std::array values = *GlobValues; + constexpr std::size_t size = values.size(); + + using switch_t = std::invoke_result_t; + static_assert(std::is_integral_v && !std::is_same_v); + const std::size_t values_to = (std::min)(static_cast(256), size - Page); + + std::array result {}; + auto fill = result.begin(); + { + auto first = values.begin() + static_cast(Page); + auto last = values.begin() + static_cast(Page + values_to); + while (first != last) { *fill++ = hash_v(*first++); } + } + + // dead cases, try to avoid case collisions + for (switch_t last_value = result[values_to - 1]; + fill != result.end() && last_value != (std::numeric_limits::max)(); + *fill++ = ++last_value) {} + + { + auto it = result.begin(); + auto last_value = (std::numeric_limits::min)(); + for (; fill != result.end(); *fill++ = last_value++) { + while (last_value == *it) { ++last_value, ++it; } + } + } + + return result; + } + + template + constexpr R + invoke_r(F&& f, Args&&... args) noexcept(std::is_nothrow_invocable_r_v) { + if constexpr (std::is_void_v) { + std::forward(f)(std::forward(args)...); + } else { + return static_cast(std::forward(f)(std::forward(args)...)); + } + } + + enum class case_call_t { index, value }; + + template + inline constexpr auto default_result_type_lambda = + []() noexcept(std::is_nothrow_default_constructible_v) { return T {}; }; + + template <> + inline constexpr auto default_result_type_lambda = []() noexcept {}; + + template + constexpr bool has_duplicate() noexcept { + using value_t = std::decay_t; + using hash_value_t = std::invoke_result_t; + std::arraysize()> hashes {}; + std::size_t size = 0; + for (auto elem : *Arr) { + hashes[size] = hash_v(elem); + for (auto i = size++; i > 0; --i) { + if (hashes[i] < hashes[i - 1]) { + auto tmp = hashes[i]; + hashes[i] = hashes[i - 1]; + hashes[i - 1] = tmp; + } else if (hashes[i] == hashes[i - 1]) { + return false; + } else { + break; + } + } + } + return true; + } + +#define MAGIC_ENUM_CASE(val) \ + case cases[val]: \ + if constexpr ((val) + Page < size) { \ + if (!pred(values[val + Page], searched)) { \ + break; \ + } \ + if constexpr (CallValue == case_call_t::index) { \ + if constexpr (std::is_invocable_r_v< \ + result_t, \ + Lambda, \ + std::integral_constant>) { \ + return detail::invoke_r( \ + std::forward(lambda), std::integral_constant {} \ + ); \ + } else if constexpr (std::is_invocable_v< \ + Lambda, \ + std::integral_constant>) { \ + MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type."); \ + } \ + } else if constexpr (CallValue == case_call_t::value) { \ + if constexpr (std:: \ + is_invocable_r_v>) { \ + return detail::invoke_r( \ + std::forward(lambda), enum_constant {} \ + ); \ + } else if constexpr (std::is_invocable_r_v< \ + result_t, \ + Lambda, \ + enum_constant>) { \ + MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type."); \ + } \ + } \ + break; \ + } else \ + [[fallthrough]]; + + template < + auto* GlobValues, + case_call_t CallValue, + std::size_t Page = 0, + typename Hash = constexpr_hash_t::value_type>, + typename BinaryPredicate = std::equal_to<>, + typename Lambda, + typename ResultGetterType> + constexpr decltype(auto) constexpr_switch( + Lambda&& lambda, + typename std::decay_t::value_type searched, + ResultGetterType&& def, + BinaryPredicate&& pred = {} + ) { + using result_t = std::invoke_result_t; + using hash_t = + std::conditional_t(), Hash, typename Hash::secondary_hash>; + static_assert( + has_duplicate(), + "magic_enum::detail::constexpr_switch duplicated hash found, please report it: " + "https://github.com/Neargye/magic_enum/issues." + ); + constexpr std::array values = *GlobValues; + constexpr std::size_t size = values.size(); + constexpr std::array cases = calculate_cases(Page); + + switch (hash_v(searched)) { + MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_CASE) + default: + if constexpr (size > 256 + Page) { + return constexpr_switch( + std::forward(lambda), searched, std::forward(def) + ); + } + break; + } + return def(); + } + +#undef MAGIC_ENUM_CASE + +#endif + + } // namespace magic_enum::detail + + // Checks is magic_enum supported compiler. + inline constexpr bool is_magic_enum_supported = detail::supported::value; + + template + using Enum = detail::enum_concept; + + // Checks whether T is an Unscoped enumeration type. + // Provides the member constant value which is equal to true, if T is an [Unscoped + // enumeration](https://en.cppreference.com/w/cpp/language/enum#Unscoped_enumeration) type. + // Otherwise, value is equal to false. + template + struct is_unscoped_enum : detail::is_unscoped_enum {}; + + template + inline constexpr bool is_unscoped_enum_v = is_unscoped_enum::value; + + // Checks whether T is an Scoped enumeration type. + // Provides the member constant value which is equal to true, if T is an [Scoped + // enumeration](https://en.cppreference.com/w/cpp/language/enum#Scoped_enumerations) type. + // Otherwise, value is equal to false. + template + struct is_scoped_enum : detail::is_scoped_enum {}; + + template + inline constexpr bool is_scoped_enum_v = is_scoped_enum::value; + + // 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. + template + struct underlying_type : detail::underlying_type {}; + + template + using underlying_type_t = typename underlying_type::type; + + template + using enum_constant = detail::enum_constant; + + // Returns type name of enum. + template + [[nodiscard]] constexpr auto enum_type_name() noexcept -> detail::enable_if_t { + constexpr string_view name = detail::type_name_v>; + static_assert(!name.empty(), "magic_enum::enum_type_name enum type does not have a name."); + + return name; + } + + // Returns number of enum values. + template > + [[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t { + return detail::count_v, S>; + } + + // Returns enum value at specified index. + // No bounds checking is performed: the behavior is undefined if index >= number of enum values. + template > + [[nodiscard]] constexpr auto enum_value(std::size_t index + ) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + if constexpr (detail::is_sparse_v) { + return MAGIC_ENUM_ASSERT(index < detail::count_v), detail::values_v[index]; + } else { + constexpr auto min = (S == detail::enum_subtype::flags) ? detail::log2(detail::min_v) + : detail::min_v; + + return MAGIC_ENUM_ASSERT(index < detail::count_v), detail::value(index); + } + } + + // Returns enum value at specified index. + template > + [[nodiscard]] constexpr auto enum_value() noexcept -> detail::enable_if_t> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + static_assert(I < detail::count_v, "magic_enum::enum_value out of range."); + + return enum_value(I); + } + + // Returns std::array with enum values, sorted by enum value. + template > + [[nodiscard]] constexpr auto enum_values() noexcept + -> detail::enable_if_t> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + return detail::values_v; + } + + // Returns integer value from enum value. + template + [[nodiscard]] constexpr auto enum_integer(E value + ) noexcept -> detail::enable_if_t> { + return static_cast>(value); + } + + // Returns underlying value from enum value. + template + [[nodiscard]] constexpr auto enum_underlying(E value + ) noexcept -> detail::enable_if_t> { + return static_cast>(value); + } + + // Obtains index in enum values from enum value. + // Returns optional with index. + template > + [[nodiscard]] constexpr auto enum_index(E value + ) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + using U = underlying_type_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + if constexpr (detail::is_sparse_v || (S == detail::enum_subtype::flags)) { +#if defined(MAGIC_ENUM_ENABLE_HASH) + return detail::constexpr_switch< + &detail::values_v, + detail::case_call_t:: + index>([](std::size_t i) { return optional { i }; }, value, detail::default_result_type_lambda>); +#else + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (enum_value(i) == value) { + return i; + } + } + return {}; // Invalid value or out of range. +#endif + } else { + const auto v = static_cast(value); + if (v >= detail::min_v && v <= detail::max_v) { + return static_cast(v - detail::min_v); + } + return {}; // Invalid value or out of range. + } + } + + // Obtains index in enum values from enum value. + // Returns optional with index. + template + [[nodiscard]] constexpr auto enum_index(E value + ) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + return enum_index(value); + } + + // Obtains index in enum values from static storage enum variable. + template >> + [[nodiscard]] constexpr auto enum_index() noexcept + -> detail::enable_if_t { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + constexpr auto index = enum_index(V); + static_assert(index, "magic_enum::enum_index enum value does not have a index."); + + return *index; + } + + // Returns name from static storage enum variable. + // This version is much lighter on the compile times and is not restricted to the enum_range + // limitation. + template + [[nodiscard]] constexpr auto enum_name() noexcept + -> detail::enable_if_t { + constexpr string_view name = detail::enum_name_v, V>; + static_assert(!name.empty(), "magic_enum::enum_name enum value does not have a name."); + + return name; + } + + // Returns name from enum value. + // If enum value does not have name or value out of range, returns empty string. + template > + [[nodiscard]] constexpr auto enum_name(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + if (const auto i = enum_index(value)) { + return detail::names_v[*i]; + } + return {}; + } + + // Returns name from enum value. + // If enum value does not have name or value out of range, returns empty string. + template + [[nodiscard]] constexpr auto enum_name(E value) -> detail::enable_if_t { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + return enum_name(value); + } + + // Returns std::array with names, sorted by enum value. + template > + [[nodiscard]] constexpr auto enum_names() noexcept + -> detail::enable_if_t> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + return detail::names_v; + } + + // Returns std::array with pairs (value, name), sorted by enum value. + template > + [[nodiscard]] constexpr auto enum_entries() noexcept + -> detail::enable_if_t> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + return detail::entries_v; + } + + // Allows you to write magic_enum::enum_cast("bar", magic_enum::case_insensitive); + inline constexpr auto case_insensitive = detail::case_insensitive<> {}; + + // Obtains enum value from integer value. + // Returns optional with enum value. + template > + [[nodiscard]] constexpr auto enum_cast(underlying_type_t value + ) noexcept -> detail::enable_if_t>> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + + if constexpr (detail::is_sparse_v || (S == detail::enum_subtype::flags)) { +#if defined(MAGIC_ENUM_ENABLE_HASH) + return detail::constexpr_switch< + &detail::values_v, + detail::case_call_t:: + value>([](D v) { return optional { v }; }, static_cast(value), detail::default_result_type_lambda>); +#else + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (value == static_cast>(enum_value(i))) { + return static_cast(value); + } + } + return {}; // Invalid value or out of range. +#endif + } else { + if (value >= detail::min_v && value <= detail::max_v) { + return static_cast(value); + } + return {}; // Invalid value or out of range. + } + } + + // Obtains enum value from name. + // Returns optional with enum value. + template < + typename E, + detail::enum_subtype S = detail::subtype_v, + typename BinaryPredicate = std::equal_to<>> + [[nodiscard]] constexpr auto enum_cast( + string_view value, + [[maybe_unused]] BinaryPredicate p = {} + ) noexcept(detail::is_nothrow_invocable() + ) -> detail::enable_if_t>, BinaryPredicate> { + using D = std::decay_t; + static_assert( + detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min." + ); + +#if defined(MAGIC_ENUM_ENABLE_HASH) + if constexpr (detail::is_default_predicate()) { + return detail::constexpr_switch<&detail::names_v, detail::case_call_t::index>( + [](std::size_t i) { return optional { detail::values_v[i] }; }, + value, + detail::default_result_type_lambda>, + [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); } + ); + } +#endif + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (detail::cmp_equal(value, detail::names_v[i], p)) { + return enum_value(i); + } + } + return {}; // Invalid value or out of range. + } + + // Checks whether enum contains value with such value. + template > + [[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + using U = underlying_type_t; + + return static_cast(enum_cast(static_cast(value))); + } + + // Checks whether enum contains value with such value. + template + [[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + using U = underlying_type_t; + + return static_cast(enum_cast(static_cast(value))); + } + + // Checks whether enum contains value with such integer value. + template > + [[nodiscard]] constexpr auto enum_contains(underlying_type_t value + ) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + return static_cast(enum_cast(value)); + } + + // Checks whether enum contains enumerator with such name. + template < + typename E, + detail::enum_subtype S = detail::subtype_v, + typename BinaryPredicate = std::equal_to<>> + [[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate p = {}) noexcept( + detail::is_nothrow_invocable() + ) -> detail::enable_if_t { + using D = std::decay_t; + + return static_cast(enum_cast(value, std::move(p))); + } + + // Returns true if the enum integer value is in the range of values that can be reflected. + template > + [[nodiscard]] constexpr auto enum_reflected(underlying_type_t value + ) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + if constexpr (detail::is_reflected_v) { + constexpr auto min = detail::reflected_min(); + constexpr auto max = detail::reflected_max(); + return value >= min && value <= max; + } else { + return false; + } + } + + // Returns true if the enum value is in the range of values that can be reflected. + template > + [[nodiscard]] constexpr auto enum_reflected(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + return enum_reflected(static_cast>(value)); + } + + // Returns true if the enum value is in the range of values that can be reflected. + template + [[nodiscard]] constexpr auto enum_reflected(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + return enum_reflected(value); + } + + template + inline constexpr auto as_flags = + AsFlags ? detail::enum_subtype::flags : detail::enum_subtype::common; + + template + inline constexpr auto as_common = + AsFlags ? detail::enum_subtype::common : detail::enum_subtype::flags; + + namespace bitwise_operators { + + template = 0> + constexpr E operator~(E rhs) noexcept { + return static_cast(~static_cast>(rhs)); + } + + template = 0> + constexpr E operator|(E lhs, E rhs) noexcept { + return static_cast( + static_cast>(lhs) | static_cast>(rhs) + ); + } + + template = 0> + constexpr E operator&(E lhs, E rhs) noexcept { + return static_cast( + static_cast>(lhs) & static_cast>(rhs) + ); + } + + template = 0> + constexpr E operator^(E lhs, E rhs) noexcept { + return static_cast( + static_cast>(lhs) ^ static_cast>(rhs) + ); + } + + template = 0> + constexpr E& operator|=(E& lhs, E rhs) noexcept { + return lhs = (lhs | rhs); + } + + template = 0> + constexpr E& operator&=(E& lhs, E rhs) noexcept { + return lhs = (lhs & rhs); + } + + template = 0> + constexpr E& operator^=(E& lhs, E rhs) noexcept { + return lhs = (lhs ^ rhs); + } + + } // namespace magic_enum::bitwise_operators + +} // namespace magic_enum + +#if defined(__clang__) +#pragma clang diagnostic pop +#elif defined(__GNUC__) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif + +#undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN +#undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN +#undef MAGIC_ENUM_VS_2017_WORKAROUND +#undef MAGIC_ENUM_ARRAY_CONSTEXPR +#undef MAGIC_ENUM_FOR_EACH_256 + +#endif // NEARGYE_MAGIC_ENUM_HPP