clean-up

example/example.cpp

@@ -129,8 +129,8 @@ int main() {
 
   // Nameof enum flags.
   AnimalFlags flag = static_cast<AnimalFlags>(AnimalFlags::CanFly | AnimalFlags::EatsFish);
-  std::cout << nameof::nameof_enum_flag(flag) << std::endl; // 'CanFly|EatsFish'
+  std::cout << nameof::nameof_enum_flags(flag) << std::endl; // 'CanFly|EatsFish'
-  std::cout << NAMEOF_ENUM_FLAG(flag) << std::endl; // 'CanFly|EatsFish'
+  std::cout << NAMEOF_ENUM_FLAGS(flag) << std::endl; // 'CanFly|EatsFish'
 #endif
 
   // Nameof.

include/nameof.hpp

@@ -43,23 +43,25 @@
 #include <iosfwd>
 #include <iterator>
 #include <limits>
-#include <string>
-#include <string_view>
 #include <type_traits>
 #include <utility>
 
+#if !defined(NAMEOF_USING_ALIAS_STRING)
+#include <string>
+#endif
+#if !defined(NAMEOF_USING_ALIAS_STRING_VIEW)
+#include <string_view>
+#endif
+
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
 #include <cstdlib>
-#include <string>
 #endif
 
 #if defined(__clang__)
 #  pragma clang diagnostic push
-#  pragma clang diagnostic ignored "-Wsign-conversion" // Implicit conversion changes signedness: 'int' to 'size_t'.
 #elif defined(__GNUC__)
 #  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wsign-conversion" // Implicit conversion changes signedness: 'int' to 'size_t'.
 #  pragma GCC diagnostic ignored "-Wstringop-overflow" // Missing terminating nul 'enum_name_v'.
 #elif defined(_MSC_VER)
 #  pragma warning(push)
@@ -96,6 +98,12 @@
 #  define NAMEOF_ENUM_SUPPORTED 1
 #endif
 
+// Checks nameof_enum compiler aliases compatibility.
+#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1920
+#  undef  NAMEOF_ENUM_SUPPORTED_ALIASES
+#  define NAMEOF_ENUM_SUPPORTED_ALIASES 1
+#endif
+
 // Enum value must be greater or equals than NAMEOF_ENUM_RANGE_MIN. By default NAMEOF_ENUM_RANGE_MIN = -128.
 // If need another min range for all enum types by default, redefine the macro NAMEOF_ENUM_RANGE_MIN.
 #if !defined(NAMEOF_ENUM_RANGE_MIN)
@@ -280,13 +288,27 @@ template <std::size_t N>
 
 template <typename Char, typename Traits, std::size_t N>
 std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const cstring<N>& srt) {
-  for (const auto c : std::string_view{srt}) {
+  for (const auto c : srt) {
     os.put(c);
   }
 
   return os;
 }
 
+// If need another optional type, define the macro NAMEOF_USING_ALIAS_STRING_VIEW.
+#if defined(NAMEOF_USING_ALIAS_STRING_VIEW)
+NAMEOF_USING_ALIAS_STRING_VIEW
+#else
+using string_view = std::string_view;
+#endif
+
+// If need another optional type, define the macro NAMEOF_USING_ALIAS_STRING.
+#if defined(NAMEOF_USING_ALIAS_STRING)
+NAMEOF_USING_ALIAS_STRING
+#else
+using string = std::string;
+#endif
+
 namespace detail {
 
 constexpr std::string_view pretty_name(std::string_view name, bool remove_template_suffix = true) noexcept {
@@ -368,6 +390,32 @@ constexpr std::string_view pretty_name(std::string_view name, bool remove_templa
   return {}; // Invalid name.
 }
 
+template <typename L, typename R>
+constexpr bool cmp_less(L lhs, R rhs) noexcept {
+  static_assert(std::is_integral_v<L> && std::is_integral_v<R>, "nameof::detail::cmp_less requires integral type.");
+
+  if constexpr (std::is_signed_v<L> == std::is_signed_v<R>) {
+    // If same signedness (both signed or both unsigned).
+    return lhs < rhs;
+  } else if constexpr (std::is_signed_v<R>) {
+    // If 'right' is negative, then result is 'false', otherwise cast & compare.
+    return rhs > 0 && lhs < static_cast<std::make_unsigned_t<R>>(rhs);
+  } else {
+    // If 'left' is negative, then result is 'true', otherwise cast & compare.
+    return lhs < 0 || static_cast<std::make_unsigned_t<L>>(lhs) < rhs;
+  }
+}
+
+template <typename I>
+constexpr I log2(I value) noexcept {
+  static_assert(std::is_integral_v<I>, "nameof::detail::log2 requires integral type.");
+
+  auto ret = I{0};
+  for (; value > I{1}; value >>= I{1}, ++ret) {};
+
+  return ret;
+}
+
 template <typename T>
 struct nameof_enum_supported
 #if defined(NAMEOF_ENUM_SUPPORTED) && NAMEOF_ENUM_SUPPORTED || defined(NAMEOF_ENUM_NO_CHECK_SUPPORT)
@@ -382,9 +430,6 @@ using enable_if_enum_t = std::enable_if_t<std::is_enum_v<std::decay_t<T>>, R>;
 template <typename T>
 inline constexpr bool is_enum_v = std::is_enum_v<T> && std::is_same_v<T, std::decay_t<T>>;
 
-#if defined(NEARGYE_MAGIC_ENUM_HPP)
-using ::magic_enum::detail::enum_name_v;
-#else
 template <typename E, E V>
 constexpr auto n() noexcept {
   static_assert(is_enum_v<E>, "nameof::detail::n requires enum type.");
@@ -406,7 +451,6 @@ constexpr auto n() noexcept {
 
 template <typename E, E V>
 inline constexpr auto enum_name_v = n<E, V>();
-#endif
 
 template <typename E, auto V>
 constexpr bool is_valid() noexcept {
@@ -415,188 +459,179 @@ constexpr bool is_valid() noexcept {
   return n<E, static_cast<E>(V)>().size() != 0;
 }
 
-template <typename L, typename R>
+template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
-constexpr bool cmp_less(L lhs, R rhs) noexcept {
+constexpr int reflected_min() noexcept {
-  static_assert(std::is_integral_v<L> && std::is_integral_v<R>, "nameof::detail::cmp_less requires integral type.");
-
-  if constexpr (std::is_signed_v<L> == std::is_signed_v<R>) {
-    // If same signedness (both signed or both unsigned).
-    return lhs < rhs;
-  } else if constexpr (std::is_signed_v<R>) {
-    // If 'right' is negative, then result is 'false', otherwise cast & compare.
-    return rhs > 0 && lhs < static_cast<std::make_unsigned_t<R>>(rhs);
-  } else {
-    // If 'left' is negative, then result is 'true', otherwise cast & compare.
-    return lhs < 0 || static_cast<std::make_unsigned_t<L>>(lhs) < rhs;
-  }
-}
-
-template <typename E, int Min, int Max>
-constexpr std::size_t range_size() noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::range_size requires enum type.");
-  constexpr auto size = Max - Min + 1;
-  static_assert(size > 0, "nameof::enum_range requires valid size.");
-  static_assert(size < (std::numeric_limits<std::uint16_t>::max)(), "nameof::enum_range requires valid size.");
-
-  return static_cast<std::size_t>(size);
-}
-
-template <typename E>
-constexpr auto reflected_min() noexcept {
   static_assert(is_enum_v<E>, "nameof::detail::reflected_min requires enum type.");
+
+  if constexpr (IsFlags) {
+    return 0;
+  } else {
     constexpr auto lhs = enum_range<E>::min;
     static_assert(lhs > (std::numeric_limits<std::int16_t>::min)(), "nameof::enum_range requires min must be greater than INT16_MIN.");
-  constexpr auto rhs = (std::numeric_limits<std::underlying_type_t<E>>::min)();
+    constexpr auto rhs = (std::numeric_limits<U>::min)();
 
-  return cmp_less(lhs, rhs) ? rhs : lhs;
+    if constexpr (cmp_less(lhs, rhs)) {
+      return rhs;
+    } else {
+      return lhs;
+    }
+  }
 }
 
-template <typename E>
+template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
-constexpr auto reflected_max() noexcept {
+constexpr int reflected_max() noexcept {
   static_assert(is_enum_v<E>, "nameof::detail::reflected_max requires enum type.");
+
+  if constexpr (IsFlags) {
+    return std::numeric_limits<U>::digits - 1;
+  } else {
     constexpr auto lhs = enum_range<E>::max;
     static_assert(lhs < (std::numeric_limits<std::int16_t>::max)(), "nameof::enum_range requires max must be less than INT16_MAX.");
-  constexpr auto rhs = (std::numeric_limits<std::underlying_type_t<E>>::max)();
+    constexpr auto rhs = (std::numeric_limits<U>::max)();
 
-  return cmp_less(lhs, rhs) ? lhs : rhs;
+    if constexpr (cmp_less(lhs, rhs)) {
-}
+      return lhs;
-
-template <typename E>
-inline constexpr auto reflected_min_v = reflected_min<E>();
-
-template <typename E>
-inline constexpr auto reflected_max_v = reflected_max<E>();
-
-template <typename E, int... I>
-constexpr auto values(std::integer_sequence<int, I...>) noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::values requires enum type.");
-  constexpr std::array<bool, sizeof...(I)> valid{{is_valid<E, I + reflected_min_v<E>>()...}};
-  constexpr int count = ((valid[I] ? 1 : 0) + ...);
-
-  std::array<E, count> values{};
-  for (int i = 0, v = 0; v < count; ++i) {
-    if (valid[i]) {
-      values[v++] = static_cast<E>(i + reflected_min_v<E>);
-    }
-  }
-
-  return values;
-}
-
-template <typename E>
-inline constexpr auto values_v = values<E>(std::make_integer_sequence<int, range_size<E, reflected_min_v<E>, reflected_max_v<E>>()>{});
-
-template <typename E>
-inline constexpr auto count_v = values_v<E>.size();
-
-template <typename E>
-inline constexpr auto min_v = static_cast<int>(values_v<E>.front());
-
-template <typename E>
-inline constexpr auto max_v = static_cast<int>(values_v<E>.back());
-
-template <typename E>
-inline constexpr auto range_size_v = range_size<E, min_v<E>, max_v<E>>();
-
-template <typename E>
-using index_t = std::conditional_t<range_size_v<E> < (std::numeric_limits<std::uint8_t>::max)(), std::uint8_t, std::uint16_t>;
-
-template <typename E>
-inline constexpr auto invalid_index_v = (std::numeric_limits<index_t<E>>::max)();
-
-template <typename E, int... I>
-constexpr auto indexes(std::integer_sequence<int, I...>) noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::indexes requires enum type.");
-  [[maybe_unused]] index_t<E> i = 0;
-
-  return std::array<index_t<E>, sizeof...(I)>{{(is_valid<E, I + min_v<E>>() ? i++ : invalid_index_v<E>)...}};
-}
-
-template <typename E>
-inline constexpr auto indexes_v = indexes<E>(std::make_integer_sequence<int, range_size_v<E>>{});
-
-template <typename E, int... I>
-constexpr auto strings(std::integer_sequence<int, I...>) noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::strings requires enum type.");
-
-  return std::array<const char*, sizeof...(I)>{{enum_name_v<E, static_cast<E>(I + min_v<E>)>.data()...}};
-}
-
-template <typename E, std::size_t... I>
-constexpr auto strings(std::index_sequence<I...>) noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::strings requires enum type.");
-
-  return std::array<const char*, sizeof...(I)>{{enum_name_v<E, values_v<E>[I]>.data()...}};
-}
-
-template <typename E>
-inline constexpr bool sparsity_v = (sizeof(const char*) * range_size_v<E>) > (sizeof(index_t<E>) * range_size_v<E> + sizeof(const char*) * count_v<E>);
-
-template <typename E>
-constexpr auto strings() noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::strings requires enum type.");
-
-  if constexpr (sparsity_v<E>) {
-    return strings<E>(std::make_index_sequence<count_v<E>>{});
     } else {
-    return strings<E>(std::make_integer_sequence<int, range_size_v<E>>{});
+      return rhs;
+    }
   }
 }
 
-template <typename E>
+template <typename E, bool IsFlags = false>
-inline static constexpr auto strings_v = strings<E>();
+inline constexpr auto reflected_min_v = reflected_min<E, IsFlags>();
 
-template <typename E, typename U = std::underlying_type_t<E>>
+template <typename E, bool IsFlags = false>
-constexpr std::uint8_t log2(E value) noexcept {
+inline constexpr auto reflected_max_v = reflected_max<E, IsFlags>();
-  auto ret = std::uint8_t{0};
-  for (auto x = static_cast<U>(value); x > static_cast<U>(1U); x >>= static_cast<U>(1U), ++ret) {};
 
-  return ret;
+template <typename E, int O, bool IsFlags = false, typename U = std::underlying_type_t<E>>
+constexpr E value(std::size_t i) noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::value requires enum type.");
+
+  if constexpr (IsFlags) {
+    return static_cast<E>(U{1} << static_cast<U>(static_cast<int>(i) + O));
+  } else {
+    return static_cast<E>(static_cast<int>(i) + O);
+  }
 }
 
-template <typename E, typename U = std::underlying_type_t<E>>
+template <typename E, bool IsFlags, int Min, std::size_t... I>
-constexpr E flag_value(std::size_t v) noexcept {
+constexpr auto values(std::index_sequence<I...>) noexcept {
-  return static_cast<E>(static_cast<U>(1U) << static_cast<U>(v));
+  static_assert(is_enum_v<E>, "nameof::detail::values requires enum type.");
-}
+  constexpr std::array<bool, sizeof...(I)> valid{{is_valid<E, value<E, Min, IsFlags>(I)>()...}};
-
+  constexpr std::size_t count = ((valid[I] ? std::size_t{1} : std::size_t{0}) + ...);
-template <typename E, typename U = std::underlying_type_t<E>, U... I>
-constexpr auto flags_values(std::integer_sequence<U, I...>) noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::flags_values requires enum type.");
-  constexpr std::array<bool, sizeof...(I)> valid{{is_valid<E, flag_value<E>(I)>()...}};
-  constexpr std::size_t count = (valid[I] + ...);
-  static_assert(count <= std::numeric_limits<U>::digits, "nameof::detail::flags_values requires valid count.");
 
   std::array<E, count> values{};
   for (std::size_t i = 0, v = 0; v < count; ++i) {
     if (valid[i]) {
-      values[v++] = flag_value<E>(i);
+      values[v++] = value<E, Min, IsFlags>(i);
     }
   }
 
   return values;
 }
 
-template <typename E, typename U = std::underlying_type_t<E>>
+template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
-inline constexpr auto flags_values_v = flags_values<E>(std::make_integer_sequence<U, std::numeric_limits<U>::digits>{});
+constexpr auto values() noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::values requires enum type.");
+  constexpr auto range_size = reflected_max_v<E, IsFlags> - reflected_min_v<E, IsFlags> + 1;
+  static_assert(range_size > 0, "nameof::enum_range requires valid size.");
+  static_assert(range_size < (std::numeric_limits<std::uint16_t>::max)(), "nameof::enum_range requires valid size.");
 
-template <typename E>
+  return values<E, IsFlags, reflected_min_v<E, IsFlags>>(std::make_index_sequence<range_size>{});
-inline constexpr auto flags_count_v = flags_values_v<E>.size();
-
-template <typename E>
-inline constexpr auto flags_min_v = log2<E>(flags_values_v<E>.front());
-
-template <typename E>
-inline constexpr auto flags_max_v = log2<E>(flags_values_v<E>.back());
-
-template <typename E, auto Min, typename U = std::underlying_type_t<E>, U... I>
-constexpr auto flags_strings(std::integer_sequence<U, I...>) noexcept {
-  static_assert(is_enum_v<E>, "nameof::detail::flags_strings requires enum type.");
-
-  return std::array<const char*, sizeof...(I)>{{enum_name_v<E, flag_value<E>(I + Min)>.data()...}};
 }
 
-template <typename E, typename U = std::underlying_type_t<E>>
+template <typename E, bool IsFlags = false>
-inline constexpr auto flags_strings_v = flags_strings<E, flags_min_v<E>>(std::make_integer_sequence<U, range_size<E, flags_min_v<E>, flags_max_v<E>>()>{});
+inline constexpr auto values_v = values<E, IsFlags>();
+
+template <typename E, bool IsFlags = false, typename D = std::decay_t<E>>
+using values_t = decltype((values_v<D, IsFlags>));
+
+template <typename E, bool IsFlags = false>
+inline constexpr auto count_v = values_v<E, IsFlags>.size();
+
+template <typename E, bool IsFlags = false, typename U = std::underlying_type_t<E>>
+inline constexpr auto min_v = static_cast<U>(values_v<E, IsFlags>.front());
+
+template <typename E, bool IsFlags = false, typename U = std::underlying_type_t<E>>
+inline constexpr auto max_v = static_cast<U>(values_v<E, IsFlags>.back());
+
+template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
+constexpr std::size_t range_size() noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::range_size requires enum type.");
+  constexpr auto max = IsFlags ? log2(max_v<E, IsFlags>) : max_v<E, IsFlags>;
+  constexpr auto min = IsFlags ? log2(min_v<E, IsFlags>) : min_v<E, IsFlags>;
+  constexpr auto range_size = max - min + U{1};
+  static_assert(range_size > 0, "nameof::enum_range requires valid size.");
+  static_assert(range_size < (std::numeric_limits<std::uint16_t>::max)(), "nameof::enum_range requires valid size.");
+
+  return static_cast<std::size_t>(range_size);
+}
+
+template <typename E, bool IsFlags = false>
+inline constexpr auto range_size_v = range_size<E, IsFlags>();
+
+template <typename E, bool IsFlags = false>
+using index_t = std::conditional_t<range_size_v<E, IsFlags> < (std::numeric_limits<std::uint8_t>::max)(), std::uint8_t, std::uint16_t>;
+
+template <typename E, bool IsFlags = false>
+inline constexpr auto invalid_index_v = (std::numeric_limits<index_t<E, IsFlags>>::max)();
+
+template <typename E, bool IsFlags, std::size_t... I>
+constexpr auto indexes(std::index_sequence<I...>) noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::indexes requires enum type.");
+  constexpr auto min = IsFlags ? log2(min_v<E, IsFlags>) : min_v<E, IsFlags>;
+  [[maybe_unused]] auto i = index_t<E, IsFlags>{0};
+
+  return std::array<decltype(i), sizeof...(I)>{{(is_valid<E, value<E, min, IsFlags>(I)>() ? i++ : invalid_index_v<E, IsFlags>)...}};
+}
+
+template <typename E, bool IsFlags = false>
+inline constexpr auto indexes_v = indexes<E, IsFlags>(std::make_index_sequence<range_size_v<E, IsFlags>>{});
+
+template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
+constexpr bool is_sparse() noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::is_sparse requires enum type.");
+
+  if constexpr (IsFlags) {
+    return (sizeof(const char*) * range_size_v<E, IsFlags>) > (sizeof(E) * count_v<E, IsFlags> + sizeof(const char*) * count_v<E, IsFlags>);
+  } else {
+    return (sizeof(const char*) * range_size_v<E, IsFlags>) > (sizeof(index_t<E>) * range_size_v<E, IsFlags> + sizeof(const char*) * count_v<E, IsFlags>);
+  }
+}
+
+template <typename E, bool IsFlags = false>
+inline constexpr bool is_sparse_v = is_sparse<E, IsFlags>();
+
+template <typename E, bool IsFlags, typename U = std::underlying_type_t<E>>
+[[nodiscard]] constexpr E get_value(std::size_t i) noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::strings requires enum type.");
+
+  if constexpr (is_sparse_v<E, IsFlags>) {
+    return values_v<E, IsFlags>[i];
+  } else {
+    constexpr auto min = IsFlags ? log2(min_v<E, IsFlags>) : min_v<E, IsFlags>;
+
+    return value<E, min, IsFlags>(i);
+  }
+}
+
+template <typename E, bool IsFlags, std::size_t... I>
+constexpr auto strings(std::index_sequence<I...>) noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::strings requires enum type.");
+
+  return std::array<const char*, sizeof...(I)>{{enum_name_v<E, get_value<E, IsFlags>(I)>.data()...}};
+}
+
+template <typename E, bool IsFlags>
+constexpr auto strings() noexcept {
+  static_assert(is_enum_v<E>, "nameof::detail::strings requires enum type.");
+  constexpr auto count = is_sparse_v<E, IsFlags> ? count_v<E, IsFlags> : range_size_v<E, IsFlags>;
+
+  return strings<E, IsFlags>(std::make_index_sequence<count>{});
+}
+
+template <typename E, bool IsFlags = false>
+inline static constexpr auto strings_v = strings<E, IsFlags>();
 
 template <typename... T>
 struct nameof_type_supported
@@ -606,17 +641,19 @@ struct nameof_type_supported
     : std::false_type {};
 #endif
 
+#if defined(_MSC_VER)
 template <typename T>
 struct identity {
   using type = T;
 };
+#else
+template <typename T>
+using identity = T;
+#endif
 
 template <typename T>
 using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
 
-#if defined(NEARGYE_MAGIC_ENUM_HPP)
-using ::magic_enum::detail::type_name_v;
-#else
 template <typename... T>
 constexpr auto n() noexcept {
 #if defined(NAMEOF_TYPE_SUPPORTED) && NAMEOF_TYPE_SUPPORTED
@@ -636,7 +673,6 @@ constexpr auto n() noexcept {
 
 template <typename... T>
 inline constexpr auto type_name_v = n<T...>();
-#endif
 
 #if __has_include(<cxxabi.h>)
 inline std::string demangle(const char* tn) {
@@ -670,7 +706,7 @@ template <typename E>
 
   if (const auto i = static_cast<int>(value) - detail::min_v<D>; static_cast<U>(value) >= static_cast<U>(detail::min_v<D>) &&
                                                                  static_cast<U>(value) <= static_cast<U>(detail::max_v<D>)) {
-    if constexpr (detail::sparsity_v<D>) {
+    if constexpr (detail::is_sparse_v<D>) {
       if (const auto idx = detail::indexes_v<D>[i]; idx != detail::invalid_index_v<D>) {
         return detail::strings_v<D>[idx];
       }
@@ -682,18 +718,21 @@ template <typename E>
   return {}; // Value out of range.
 }
 
-// Obtains simple (unqualified) string name of enum flag variable.
+// Obtains simple (unqualified) string name of enum-flags variable.
 template <typename E>
-[[nodiscard]] auto nameof_enum_flag(E value) -> detail::enable_if_enum_t<E, std::string> {
+[[nodiscard]] auto nameof_enum_flags(E value) -> detail::enable_if_enum_t<E, std::string> {
   using D = std::decay_t<E>;
   using U = std::underlying_type_t<D>;
-  static_assert(detail::nameof_enum_supported<D>::value, "nameof::nameof_enum_flag unsupported compiler (https://github.com/Neargye/nameof#compiler-compatibility).");
+  static_assert(detail::nameof_enum_supported<D>::value, "nameof::nameof_enum_flags unsupported compiler (https://github.com/Neargye/nameof#compiler-compatibility).");
-  static_assert(detail::flags_count_v<D> > 0, "nameof::nameof_enum_flag requires enum flag implementation.");
+  static_assert(detail::count_v<D, true> > 0, "nameof::nameof_enum_flags requires enum flag implementation.");
+  constexpr auto size = detail::is_sparse_v<D, true> ? detail::count_v<D, true> : detail::range_size_v<D, true>;
 
   std::string name;
-  for (auto i = detail::flags_min_v<D>; i <= detail::flags_max_v<D>; ++i) {
+  auto check_value = U{0};
-    if (const auto v = (static_cast<U>(1U) << static_cast<U>(i)); (static_cast<U>(value) & v) != 0) {
+  for (std::size_t i = 0; i < size; ++i) {
-      if (const auto n = detail::flags_strings_v<D>[i]; n != nullptr) {
+    if (const auto v = static_cast<U>(detail::get_value<D, true>(i)); (static_cast<U>(value) & v) != 0) {
+      if (const auto n = detail::strings_v<D, true>[i]; n != nullptr) {
+        check_value |= v;
         if (!name.empty()) {
           name.append(1, '|');
         }
@@ -704,9 +743,13 @@ template <typename E>
     }
   }
 
+  if (check_value != 0 && check_value == static_cast<U>(value)) {
     return name;
   }
 
+  return {}; // Invalid value or out of range.
+}
+
 // Obtains simple (unqualified) string name of static storage enum variable.
 // This version is much lighter on the compile times and is not restricted to the enum_range limitation.
 template <auto V>
@@ -723,11 +766,7 @@ template <auto V>
 template <typename T>
 [[nodiscard]] constexpr std::string_view nameof_type() noexcept {
   static_assert(detail::nameof_type_supported<T>::value, "nameof::nameof_type unsupported compiler (https://github.com/Neargye/nameof#compiler-compatibility).");
-#if defined(_MSC_VER)
   using U = detail::identity<detail::remove_cvref_t<T>>;
-#else
-  using U = detail::remove_cvref_t<T>;
-#endif
   constexpr std::string_view name = detail::type_name_v<U>;
   static_assert(name.size() > 0, "Type does not have a name.");
 
@@ -738,11 +777,7 @@ template <typename T>
 template <typename T>
 [[nodiscard]] constexpr std::string_view nameof_full_type() noexcept {
   static_assert(detail::nameof_type_supported<T>::value, "nameof::nameof_type unsupported compiler (https://github.com/Neargye/nameof#compiler-compatibility).");
-#if defined(_MSC_VER)
   using U = detail::identity<T>;
-#else
-  using U = T;
-#endif
   constexpr std::string_view name = detail::type_name_v<U>;
   static_assert(name.size() > 0, "Type does not have a name.");
 
@@ -786,7 +821,7 @@ template <typename T>
 #define NAMEOF_CONST_ENUM(...) ::nameof::nameof_enum<__VA_ARGS__>()
 
 // Obtains simple (unqualified) string name of enum flag variable.
-#define NAMEOF_ENUM_FLAG(...) ::nameof::nameof_enum_flag<::std::decay_t<decltype(__VA_ARGS__)>>(__VA_ARGS__)
+#define NAMEOF_ENUM_FLAGS(...) ::nameof::nameof_enum_flags<::std::decay_t<decltype(__VA_ARGS__)>>(__VA_ARGS__)
 
 // Obtains string name of type, reference and cv-qualifiers are ignored.
 #define NAMEOF_TYPE(...) ::nameof::nameof_type<__VA_ARGS__>()

test/test.cpp

@@ -373,56 +373,64 @@ TEST_CASE("nameof_enum") {
   }
 }
 
-TEST_CASE("nameof_enum_flag") {
+TEST_CASE("nameof_enum_flags") {
   constexpr AnimalFlags af = AnimalFlags::HasClaws;
-  auto af_name = nameof::nameof_enum_flag(af);
+  auto af_name = nameof::nameof_enum_flags(af);
   AnimalFlags afm[3] = {AnimalFlags::HasClaws, AnimalFlags::CanFly, AnimalFlags::EatsFish};
   REQUIRE(af_name == "HasClaws");
-  REQUIRE(nameof::nameof_enum_flag(AnimalFlags::EatsFish) == "EatsFish");
+  REQUIRE(nameof::nameof_enum_flags(AnimalFlags::EatsFish) == "EatsFish");
-  REQUIRE(nameof::nameof_enum_flag(afm[1]) == "CanFly");
+  REQUIRE(nameof::nameof_enum_flags(afm[1]) == "CanFly");
-  REQUIRE(nameof::nameof_enum_flag(static_cast<AnimalFlags>(0)).empty());
+  REQUIRE(nameof::nameof_enum_flags(static_cast<AnimalFlags>(0)).empty());
-  REQUIRE(nameof::nameof_enum_flag(static_cast<AnimalFlags>(1 | 2)) == "HasClaws|CanFly");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<AnimalFlags>(1 | 2)) == "HasClaws|CanFly");
-  REQUIRE(nameof::nameof_enum_flag(static_cast<AnimalFlags>(1 | 2 | 4)) == "HasClaws|CanFly|EatsFish");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<AnimalFlags>(1 | 2 | 4)) == "HasClaws|CanFly|EatsFish");
-  REQUIRE(nameof::nameof_enum_flag(static_cast<AnimalFlags>(1 | 0 | 8)) == "HasClaws|Endangered");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<AnimalFlags>(1 | 0 | 8)) == "HasClaws|Endangered");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<AnimalFlags>(0)).empty());
 
   constexpr BigFlags bf = BigFlags::A;
-  auto bf_name = nameof::nameof_enum_flag(bf);
+  auto bf_name = nameof::nameof_enum_flags(bf);
   BigFlags bfm[3] = {BigFlags::A, BigFlags::B, BigFlags::C};
   REQUIRE(bf_name == "A");
-  REQUIRE(nameof::nameof_enum_flag(BigFlags::C) == "C");
+  REQUIRE(nameof::nameof_enum_flags(BigFlags::C) == "C");
-  REQUIRE(nameof::nameof_enum_flag(bfm[1]) == "B");
+  REQUIRE(nameof::nameof_enum_flags(bfm[1]) == "B");
-  REQUIRE(nameof::nameof_enum_flag(static_cast<BigFlags>(0)).empty());
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>(0)).empty());
-  REQUIRE(nameof::nameof_enum_flag(static_cast<BigFlags>(1 | 2)).empty());
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>(1 | 2)).empty());
-  REQUIRE(nameof::nameof_enum_flag(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20))) == "A|B");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20))) == "A|B");
-  REQUIRE(nameof::nameof_enum_flag(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20) | (static_cast<std::uint64_t>(0x1) << 63))) == "A|B|D");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20) | (static_cast<std::uint64_t>(0x1) << 63))) == "A|B|D");
-  REQUIRE(nameof::nameof_enum_flag(static_cast<BigFlags>(1 | 0 | (static_cast<std::uint64_t>(0x1) << 40))) == "A|C");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>(1 | 0 | (static_cast<std::uint64_t>(0x1) << 40))) == "A|C");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>(1 | 0 | (static_cast<std::uint64_t>(0x1) << 40))) == "A|C");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>((static_cast<std::uint64_t>(0x1) << 63) | 1)) == "A|D");
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>(2)).empty());
+  REQUIRE(nameof::nameof_enum_flags(static_cast<BigFlags>((static_cast<std::uint64_t>(0x1) << 63) | 2)).empty());
 }
 
-TEST_CASE("NAMEOF_ENUM_FLAG") {
+TEST_CASE("NAMEOF_ENUM_FLAGS") {
   constexpr AnimalFlags af = AnimalFlags::HasClaws;
-  auto af_name = NAMEOF_ENUM_FLAG(af);
+  auto af_name = NAMEOF_ENUM_FLAGS(af);
   AnimalFlags afm[3] = {AnimalFlags::HasClaws, AnimalFlags::CanFly, AnimalFlags::EatsFish};
   REQUIRE(af_name == "HasClaws");
-  REQUIRE(NAMEOF_ENUM_FLAG(afm[1]) == "CanFly");
+  REQUIRE(NAMEOF_ENUM_FLAGS(afm[1]) == "CanFly");
-  REQUIRE(NAMEOF_ENUM_FLAG(AnimalFlags::EatsFish) == "EatsFish");
+  REQUIRE(NAMEOF_ENUM_FLAGS(AnimalFlags::EatsFish) == "EatsFish");
-  REQUIRE(NAMEOF_ENUM_FLAG(AnimalFlags::Endangered) == "Endangered");
+  REQUIRE(NAMEOF_ENUM_FLAGS(AnimalFlags::Endangered) == "Endangered");
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<AnimalFlags>(0)).empty());
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<AnimalFlags>(0)).empty());
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<AnimalFlags>(1 | 2)) == "HasClaws|CanFly");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<AnimalFlags>(1 | 2)) == "HasClaws|CanFly");
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<AnimalFlags>(1 | 2 | 4)) == "HasClaws|CanFly|EatsFish");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<AnimalFlags>(1 | 2 | 4)) == "HasClaws|CanFly|EatsFish");
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<AnimalFlags>(1 | 0 | 8)) == "HasClaws|Endangered");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<AnimalFlags>(1 | 0 | 8)) == "HasClaws|Endangered");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<AnimalFlags>(0)).empty());
 
   constexpr BigFlags bf = BigFlags::A;
-  auto bf_name = NAMEOF_ENUM_FLAG(bf);
+  auto bf_name = NAMEOF_ENUM_FLAGS(bf);
   BigFlags bfm[3] = {BigFlags::A, BigFlags::B, BigFlags::C};
   REQUIRE(bf_name == "A");
-  REQUIRE(NAMEOF_ENUM_FLAG(bfm[1]) == "B");
+  REQUIRE(NAMEOF_ENUM_FLAGS(bfm[1]) == "B");
-  REQUIRE(NAMEOF_ENUM_FLAG(BigFlags::C) == "C");
+  REQUIRE(NAMEOF_ENUM_FLAGS(BigFlags::C) == "C");
-  REQUIRE(NAMEOF_ENUM_FLAG(BigFlags::D) == "D");
+  REQUIRE(NAMEOF_ENUM_FLAGS(BigFlags::D) == "D");
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<BigFlags>(0)).empty());
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<BigFlags>(0)).empty());
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<BigFlags>(1 | 2)).empty());
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<BigFlags>(1 | 2)).empty());
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20))) == "A|B");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20))) == "A|B");
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20) | (static_cast<std::uint64_t>(0x1) << 63))) == "A|B|D");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<BigFlags>(1 | (static_cast<std::uint64_t>(0x1) << 20) | (static_cast<std::uint64_t>(0x1) << 63))) == "A|B|D");
-  REQUIRE(NAMEOF_ENUM_FLAG(static_cast<BigFlags>(1 | 0 | (static_cast<std::uint64_t>(0x1) << 40))) == "A|C");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<BigFlags>((static_cast<std::uint64_t>(0x1) << 63) | 1)) == "A|D");
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<BigFlags>(2)).empty());
+  REQUIRE(NAMEOF_ENUM_FLAGS(static_cast<BigFlags>((static_cast<std::uint64_t>(0x1) << 63) | 2)).empty());
 }
 
 #endif