Prefer "user-defined" over "generic" in formatting language

Some places refer to non-standard formatting types as "user-defined",
others as "generic". For consistency, use "user-defined" everywhere.
This avoids confusion with the similarly "general" floating-point
presentation type.

Author: trflynn89

fly/types/string/detail/format_parameter_type.hpp

@@ -11,7 +11,7 @@ namespace fly::detail {
  */
 enum class ParameterType : std::uint8_t
 {
-    Generic,
+    UserDefined,
     Character,
     String,
     Pointer,
@@ -59,7 +59,7 @@ constexpr ParameterType infer_parameter_type()
     }
     else
     {
-        return ParameterType::Generic;
+        return ParameterType::UserDefined;
     }
 }
 

fly/types/string/detail/format_parameters.hpp

@@ -197,7 +197,7 @@ class BasicFormatParameter
     enum class Type : std::uint8_t
     {
         Invalid,
-        Generic,
+        UserDefined,
         String,
         Pointer,
         SignedInt,
@@ -211,7 +211,7 @@ class BasicFormatParameter
     union Value
     {
         MonoState m_monostate;
-        UserDefinedValue<FormatContext> m_generic;
+        UserDefinedValue<FormatContext> m_user_defined;
         StringValue<FormatContext> m_string;
         StandardValue<FormatContext> m_standard;
     };
@@ -345,8 +345,8 @@ template <
         BasicFormatTraits::is_default_formatted_enum<T>>>
 constexpr inline BasicFormatParameter<FormatContext>::BasicFormatParameter(const T &value) noexcept
     :
-    m_type(Type::Generic),
-    m_value {.m_generic {&value, format_user_defined_value<FormatContext, T>}}
+    m_type(Type::UserDefined),
+    m_value {.m_user_defined {&value, format_user_defined_value<FormatContext, T>}}
 {
 }
 
@@ -442,8 +442,8 @@ constexpr inline void BasicFormatParameter<FormatContext>::format(FormatContext
 {
     switch (m_type)
     {
-        case Type::Generic:
-            m_value.m_generic.m_format(m_value.m_generic.m_value, context);
+        case Type::UserDefined:
+            m_value.m_user_defined.m_format(m_value.m_user_defined.m_value, context);
             break;
         case Type::String:
             m_value.m_string.m_format(m_value.m_string.m_value, m_value.m_string.m_size, context);
@@ -469,8 +469,8 @@ constexpr inline auto BasicFormatParameter<FormatContext>::visit(Visitor &&visit
 {
     switch (m_type)
     {
-        case Type::Generic:
-            return visitor(m_value.m_generic);
+        case Type::UserDefined:
+            return visitor(m_value.m_user_defined);
         case Type::String:
             return visitor(m_value.m_string);
         case Type::Pointer:

fly/types/string/detail/format_specifier.hpp

@@ -102,7 +102,7 @@ namespace fly::detail {
  *        Strong enumeration types - If an overload of operator<< is defined, valid presentations
  *        are: none, "s". Else, valid presentations are: none, "c", b", "B", "o", "d", "x", "X".
  *
- *        Other (generic) types - Valid presentations: none. An overload of operator<< must be
+ *        Other user-defined types - Valid presentations: none. An overload of operator<< must be
  *        defined for generic types.
  *
  *        For details on each presentation type, see the above links.

fly/types/string/detail/format_string.hpp

@@ -155,9 +155,9 @@ constexpr auto BasicFormatString<CharType, ParameterTypes...>::parse_specifier()
     FormatSpecifier specifier {};
     specifier.m_position = m_context.next_position();
 
-    // TODO: For now, generic format parameters must be formatted with "{}".
+    // TODO: For now, user-defined format parameters must be formatted with "{}".
     if (auto parameter_type = m_context.parameter_type(specifier.m_position);
-        parameter_type && parameter_type != ParameterType::Generic)
+        parameter_type && parameter_type != ParameterType::UserDefined)
     {
         if (m_context.lexer().consume_if(s_colon))
         {

fly/types/string/detail/string_traits.hpp

@@ -179,10 +179,10 @@ struct BasicFormatTraits
     static inline constexpr bool is_default_formatted_enum_v = is_default_formatted_enum<T>::value;
 
     /**
-     * Trait to classify a type as a generic type.
+     * Trait to classify a type as a user-defined type.
      */
     template <typename T, typename U = std::remove_cvref_t<T>>
-    using is_generic = std::negation<std::disjunction<
+    using is_user_defined = std::negation<std::disjunction<
         detail::is_like_supported_string<T>,
         is_pointer<T>,
         is_integral<T>,
@@ -191,7 +191,7 @@ struct BasicFormatTraits
         is_default_formatted_enum<T>>>;
 
     template <typename T>
-    static inline constexpr bool is_generic_v = is_generic<T>::value;
+    static inline constexpr bool is_user_defined_v = is_user_defined<T>::value;
 };
 
 } // namespace fly::detail

fly/types/string/string.hpp

@@ -422,12 +422,12 @@ class BasicString
      *       from the format string type. If the type differs, the format parameter is transcoded to
      *       the type of the format string.
      *
-     *    3. Any generic type for which an operator<< overload is defined will be converted to a
-     *       string using that overload.
+     *    3. Any user-defined type for which an operator<< overload is defined will be converted to
+     *       a string using that overload.
      *
      *    4. Formatting of strong enumeration types defaults to the format of the enumeration's
      *       underlying type. However, if an overload of operator<< is defined, the type is treated
-     *       as a generic type according to (3) above.
+     *       as a user-defined type according to (3) above.
      *
      *    5. This implementation is exceptionless. Any error encountered (such as failed transcoding
      *       in (2) above) results in the format parameter that caused the error to be dropped.

fly/types/string/string_formatters.hpp

@@ -35,14 +35,14 @@ template <typename T, typename CharType = char, typename SFINAE = bool>
 struct Formatter;
 
 template <typename T, typename CharType>
-struct Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_generic<T>>>
+struct Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_user_defined<T>>>
 {
     /**
-     * Format a single replacement field with the provided generic value.
+     * Format a single replacement field with the provided user-defined value.
      *
-     * Currently, rather than supporting a set of std::formatter specializations, the generic value
-     * will be converted to a string via the streaming operator. The resulting string will then be
-     * formatted using the string formatting overload.
+     * Currently, rather than supporting a set of std::formatter specializations, the user-defined
+     * value will be converted to a string via the streaming operator. The resulting string will
+     * then be formatted using the string formatting overload.
      *
      * @tparam FormatParameter The type of the formatting context.
      *
@@ -250,7 +250,7 @@ struct Formatter<T, CharType, fly::enable_if<std::is_same<T, bool>>>
 template <typename T, typename CharType>
 template <typename FormatContext>
 inline void
-Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_generic<T>>>::format(
+Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_user_defined<T>>>::format(
     const T &value,
     FormatContext &context)
 {

test/types/string/format.cpp

@@ -20,13 +20,13 @@ namespace {
 
 #define FMT(format) FLY_ARR(char_type, format)
 
-struct GenericType
+struct UserDefinedType
 {
 };
 
-[[maybe_unused]] std::ostream &operator<<(std::ostream &stream, const GenericType &)
+[[maybe_unused]] std::ostream &operator<<(std::ostream &stream, const UserDefinedType &)
 {
-    stream << "GenericType";
+    stream << "UserDefinedType";
     return stream;
 }
 
@@ -469,10 +469,10 @@ CATCH_TEMPLATE_TEST_CASE("FormatTypes", "[string]", char, wchar_t, char8_t, char
         return !value.empty();
     };
 
-    CATCH_SECTION("Generic types may be formatted without presentation type")
+    CATCH_SECTION("User-defined types may be formatted without presentation type")
     {
-        GenericType gt {};
-        test_format(FMT("{}"), FMT("GenericType"), gt);
+        UserDefinedType gt {};
+        test_format(FMT("{}"), FMT("UserDefinedType"), gt);
         test_format(FMT("{}"), FMT("One"), UserFormattedEnum::One);
         test_format(FMT("{}"), FMT("Two"), UserFormattedEnum::Two);
     }