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

trflynn89 · trflynn89 · commit ff37b6c6b1c4 · 2021-04-28T07:20:32.000-04:00
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.
diff --git a/fly/types/string/detail/format_parameter_type.hpp b/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;
     }
 }
 
diff --git a/fly/types/string/detail/format_parameters.hpp b/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:
diff --git a/fly/types/string/detail/format_specifier.hpp b/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.
diff --git a/fly/types/string/detail/format_string.hpp b/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))
         {
diff --git a/fly/types/string/detail/string_traits.hpp b/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
diff --git a/fly/types/string/string.hpp b/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.
diff --git a/fly/types/string/string_formatters.hpp b/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)
 {
diff --git a/test/types/string/format.cpp b/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);
     }
diff --git a/test/types/string/format_string.cpp b/test/types/string/format_string.cpp

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace fly::detail {`
`11`	`11`	`*/`
`12`	`12`	`enum class ParameterType : std::uint8_t`
`13`	`13`	`{`
`14`		`- Generic,`
	`14`	`+ UserDefined,`
`15`	`15`	`Character,`
`16`	`16`	`String,`
`17`	`17`	`Pointer,`
`@@ -59,7 +59,7 @@ constexpr ParameterType infer_parameter_type()`
`59`	`59`	`}`
`60`	`60`	`else`
`61`	`61`	`{`
`62`		`- return ParameterType::Generic;`
	`62`	`+ return ParameterType::UserDefined;`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ class BasicFormatParameter`
`197`	`197`	`enum class Type : std::uint8_t`
`198`	`198`	`{`
`199`	`199`	`Invalid,`
`200`		`- Generic,`
	`200`	`+ UserDefined,`
`201`	`201`	`String,`
`202`	`202`	`Pointer,`
`203`	`203`	`SignedInt,`
`@@ -211,7 +211,7 @@ class BasicFormatParameter`
`211`	`211`	`union Value`
`212`	`212`	`{`
`213`	`213`	`MonoState m_monostate;`
`214`		`- UserDefinedValue<FormatContext> m_generic;`
	`214`	`+ UserDefinedValue<FormatContext> m_user_defined;`
`215`	`215`	`StringValue<FormatContext> m_string;`
`216`	`216`	`StandardValue<FormatContext> m_standard;`
`217`	`217`	`};`
`@@ -345,8 +345,8 @@ template <`
`345`	`345`	`BasicFormatTraits::is_default_formatted_enum<T>>>`
`346`	`346`	`constexpr inline BasicFormatParameter<FormatContext>::BasicFormatParameter(const T &value) noexcept`
`347`	`347`	`:`
`348`		`- m_type(Type::Generic),`
`349`		`- m_value {.m_generic {&value, format_user_defined_value<FormatContext, T>}}`
	`348`	`+ m_type(Type::UserDefined),`
	`349`	`+ m_value {.m_user_defined {&value, format_user_defined_value<FormatContext, T>}}`
`350`	`350`	`{`
`351`	`351`	`}`
`352`	`352`
`@@ -442,8 +442,8 @@ constexpr inline void BasicFormatParameter<FormatContext>::format(FormatContext`
`442`	`442`	`{`
`443`	`443`	`switch (m_type)`
`444`	`444`	`{`
`445`		`- case Type::Generic:`
`446`		`- m_value.m_generic.m_format(m_value.m_generic.m_value, context);`
	`445`	`+ case Type::UserDefined:`
	`446`	`+ m_value.m_user_defined.m_format(m_value.m_user_defined.m_value, context);`
`447`	`447`	`break;`
`448`	`448`	`case Type::String:`
`449`	`449`	`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`
`469`	`469`	`{`
`470`	`470`	`switch (m_type)`
`471`	`471`	`{`
`472`		`- case Type::Generic:`
`473`		`- return visitor(m_value.m_generic);`
	`472`	`+ case Type::UserDefined:`
	`473`	`+ return visitor(m_value.m_user_defined);`
`474`	`474`	`case Type::String:`
`475`	`475`	`return visitor(m_value.m_string);`
`476`	`476`	`case Type::Pointer:`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ namespace fly::detail {`
`102`	`102`	`* Strong enumeration types - If an overload of operator<< is defined, valid presentations`
`103`	`103`	`* are: none, "s". Else, valid presentations are: none, "c", b", "B", "o", "d", "x", "X".`
`104`	`104`	`*`
`105`		`- * Other (generic) types - Valid presentations: none. An overload of operator<< must be`
	`105`	`+ * Other user-defined types - Valid presentations: none. An overload of operator<< must be`
`106`	`106`	`* defined for generic types.`
`107`	`107`	`*`
`108`	`108`	`* For details on each presentation type, see the above links.`
Original file line number	Diff line number	Diff line change
`@@ -155,9 +155,9 @@ constexpr auto BasicFormatString<CharType, ParameterTypes...>::parse_specifier()`
`155`	`155`	`FormatSpecifier specifier {};`
`156`	`156`	`specifier.m_position = m_context.next_position();`
`157`	`157`
`158`		`- // TODO: For now, generic format parameters must be formatted with "{}".`
	`158`	`+ // TODO: For now, user-defined format parameters must be formatted with "{}".`
`159`	`159`	`if (auto parameter_type = m_context.parameter_type(specifier.m_position);`
`160`		`- parameter_type && parameter_type != ParameterType::Generic)`
	`160`	`+ parameter_type && parameter_type != ParameterType::UserDefined)`
`161`	`161`	`{`
`162`	`162`	`if (m_context.lexer().consume_if(s_colon))`
`163`	`163`	`{`
Original file line number	Diff line number	Diff line change
`@@ -422,12 +422,12 @@ class BasicString`
`422`	`422`	`* from the format string type. If the type differs, the format parameter is transcoded to`
`423`	`423`	`* the type of the format string.`
`424`	`424`	`*`
`425`		`- * 3. Any generic type for which an operator<< overload is defined will be converted to a`
`426`		`- * string using that overload.`
	`425`	`+ * 3. Any user-defined type for which an operator<< overload is defined will be converted to`
	`426`	`+ * a string using that overload.`
`427`	`427`	`*`
`428`	`428`	`* 4. Formatting of strong enumeration types defaults to the format of the enumeration's`
`429`	`429`	`* underlying type. However, if an overload of operator<< is defined, the type is treated`
`430`		`- * as a generic type according to (3) above.`
	`430`	`+ * as a user-defined type according to (3) above.`
`431`	`431`	`*`
`432`	`432`	`* 5. This implementation is exceptionless. Any error encountered (such as failed transcoding`
`433`	`433`	`* in (2) above) results in the format parameter that caused the error to be dropped.`
Original file line number	Diff line number	Diff line change
`@@ -35,14 +35,14 @@ template <typename T, typename CharType = char, typename SFINAE = bool>`
`35`	`35`	`struct Formatter;`
`36`	`36`
`37`	`37`	`template <typename T, typename CharType>`
`38`		`-struct Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_generic<T>>>`
	`38`	`+struct Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_user_defined<T>>>`
`39`	`39`	`{`
`40`	`40`	`/**`
`41`		`- * Format a single replacement field with the provided generic value.`
	`41`	`+ * Format a single replacement field with the provided user-defined value.`
`42`	`42`	`*`
`43`		`- * Currently, rather than supporting a set of std::formatter specializations, the generic value`
`44`		`- * will be converted to a string via the streaming operator. The resulting string will then be`
`45`		`- * formatted using the string formatting overload.`
	`43`	`+ * Currently, rather than supporting a set of std::formatter specializations, the user-defined`
	`44`	`+ * value will be converted to a string via the streaming operator. The resulting string will`
	`45`	`+ * then be formatted using the string formatting overload.`
`46`	`46`	`*`
`47`	`47`	`* @tparam FormatParameter The type of the formatting context.`
`48`	`48`	`*`
`@@ -250,7 +250,7 @@ struct Formatter<T, CharType, fly::enable_if<std::is_same<T, bool>>>`
`250`	`250`	`template <typename T, typename CharType>`
`251`	`251`	`template <typename FormatContext>`
`252`	`252`	`inline void`
`253`		`-Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_generic<T>>>::format(`
	`253`	`+Formatter<T, CharType, fly::enable_if<detail::BasicFormatTraits::is_user_defined<T>>>::format(`
`254`	`254`	`const T &value,`
`255`	`255`	`FormatContext &context)`
`256`	`256`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,13 +20,13 @@ namespace {`
`20`	`20`
`21`	`21`	`#define FMT(format) FLY_ARR(char_type, format)`
`22`	`22`
`23`		`-struct GenericType`
	`23`	`+struct UserDefinedType`
`24`	`24`	`{`
`25`	`25`	`};`
`26`	`26`
`27`		`-[[maybe_unused]] std::ostream &operator<<(std::ostream &stream, const GenericType &)`
	`27`	`+[[maybe_unused]] std::ostream &operator<<(std::ostream &stream, const UserDefinedType &)`
`28`	`28`	`{`
`29`		`- stream << "GenericType";`
	`29`	`+ stream << "UserDefinedType";`
`30`	`30`	`return stream;`
`31`	`31`	`}`
`32`	`32`
`@@ -469,10 +469,10 @@ CATCH_TEMPLATE_TEST_CASE("FormatTypes", "[string]", char, wchar_t, char8_t, char`
`469`	`469`	`return !value.empty();`
`470`	`470`	`};`
`471`	`471`
`472`		`- CATCH_SECTION("Generic types may be formatted without presentation type")`
	`472`	`+ CATCH_SECTION("User-defined types may be formatted without presentation type")`
`473`	`473`	`{`
`474`		`- GenericType gt {};`
`475`		`- test_format(FMT("{}"), FMT("GenericType"), gt);`
	`474`	`+ UserDefinedType gt {};`
	`475`	`+ test_format(FMT("{}"), FMT("UserDefinedType"), gt);`
`476`	`476`	`test_format(FMT("{}"), FMT("One"), UserFormattedEnum::One);`
`477`	`477`	`test_format(FMT("{}"), FMT("Two"), UserFormattedEnum::Two);`
`478`	`478`	`}`