updated format macros again to have better naming.

Author: Lukas Thomann

cth/incl/cth/io/keybd/keys.hpp

@@ -254,7 +254,7 @@ cxpr std::string_view to_utf8_string(Key key) {
 
 CTH_GEN_ENUM_DEREF_OVERLOAD(cth::io::Key)
 
-CTH_FORMAT_CLASS_ATTRIBUTES(
+CTH_FORMAT_CLASS(
     cth::io::Key,
     "{}",
     ([](cth::io::Key const& key) { return cth::io::to_utf8_string(key); })
@@ -288,19 +288,19 @@ struct key_update {
 
 }
 
-CTH_FORMAT_CLASS_ATTRIBUTES(
+CTH_FORMAT_CLASS(
     cth::io::ex_key,
     "{}, right: {}",
     ([](cth::io::ex_key const& key) { return std::tie(key.key, key.right); })
 );
 
-CTH_FORMAT_CLASS_ATTRIBUTES(
+CTH_FORMAT_CLASS(
     cth::io::key_state,
     "{}, down: {}",
     ([](cth::io::key_state const& key) { return std::tie(key.exKey, key.down); })
 );
 
-CTH_FORMAT_CLASS_ATTRIBUTES(
+CTH_FORMAT_CLASS(
     cth::io::key_update,
     "{}, time: {}",
     (

cth/incl/cth/io/log.hpp

@@ -643,7 +643,7 @@ inline auto x = []() {
         CTH_ASSERT(false, "invalid CTH_LOG_LEVEL macro value defined");
         static_assert(false);
         return 10;
-    }();
+}();
 #endif
 
 #endif

cth/incl/cth/meta/concepts.hpp

@@ -4,10 +4,6 @@
 #include <tuple>
 
 
-#define CPT(concept)                                                                                         \
-    []<concept> {}
-
-
 namespace cth::mta {
 template<class T, auto TCpt>
 concept satisfies = requires { TCpt.template operator()<T>(); };

cth/incl/cth/string/format.hpp

@@ -30,7 +30,7 @@
  * @param fmt_string The format string (e.g., "ID: {}, Val: {}")
  * @param tie_func An expression involving 'obj' that returns a tuple/tie
  */
-#define CTH_FORMAT_CLASS(type, fmt_string, tie_func)                                                \
+#define CTH_FORMAT_CLASS_CUSTOM(type, fmt_string, tie_func)                                         \
 template<>                                                                                          \
 struct std::formatter<type> {                                                                       \
     [[nodiscard]] constexpr auto parse(std::format_parse_context& ctx) {                            \
@@ -55,13 +55,13 @@ struct std::formatter<type> {
 }
 
 /**
- * creates a format overload for a class, implicitly includes type name with type[<fmt_string>]
+ * creates a format overload for a class, implicitly includes type name with type{<fmt_string>}
  * @param type The class/struct type to format
  * @param fmt_string The format string (e.g., "ID: {}, Val: {}")
  * @param tie_func An expression involving 'obj' that returns a tuple/tie
  */
-#define CTH_FORMAT_CLASS_ATTRIBUTES(type, fmt_string, tie_func)\
-    CTH_FORMAT_CLASS(type, #type "[" fmt_string "]", tie_func)
+#define CTH_FORMAT_CLASS(type, fmt_string, tie_func)\
+    CTH_FORMAT_CLASS_CUSTOM(type, #type "{{" fmt_string "}}", tie_func)
 
 /**
  * @brief creates a format overload for the concept

cth/tests/src/format_test.cpp

@@ -8,43 +8,57 @@
 namespace test {
 
 
-enum Test1 {
-    VALUE1,
+struct Test1 {
+    int x;
+    int y;
 };
 enum Test2 { VALUE2 };
 
 
-constexpr std::string_view to_string(Test1 e) {
+
+constexpr std::string_view to_string(Test2 const& e) {
     switch(e) {
-        case VALUE1: return "VALUE1";
+        case VALUE2: return "VALUE2";
         default: return "unknown";
     }
 }
 
+struct Test3 {
+    Test1 a;
+};
 
 template<class T>
-concept test_concept = std::is_same_v<T, Test2>;
-constexpr std::string_view to_string(Test2 e) {
-    switch(e) {
-        case VALUE2: return "VALUE2";
-        default: return "unknown";
-    }
-}
+concept test_concept = std::same_as<T, Test3>;
 }
 
 
-CTH_FORMAT_CLASS(test::Test1, "{}", test::to_string);
+CTH_FORMAT_CLASS(test::Test1, "x: {}, y: {}", ([](test::Test1 const& test) {return std::tie(test.x, test.y); }));
+CTH_FORMAT_CLASS_CUSTOM(test::Test2, "{}", test::to_string);
+
+namespace test {
+std::string to_string(Test3 const& e) { return std::format("{}", e.a); }
+}
+
 CTH_FORMAT_CPT(test::test_concept, test::to_string);
 
 
 namespace cth::fmt {
-FMT_TEST(CTH_FORMAT_CLASS, main) {
-    auto const str = std::format("{}", ::test::VALUE1);
+::test::Test1 x{1, 2};
 
-    ASSERT_EQ("test::Test1{VALUE1}", str);
+FMT_TEST(CTH_FORMAT_CLASS_CUSTOM, main) {
+    auto const str = std::format("{}", ::test::VALUE2);
+    ASSERT_EQ(str, "VALUE2");
+}
+
+FMT_TEST(CTH_FORMAT_CLASS, main) {
+    auto const str = std::format("{}", x);
+    auto const expected = std::format("test::Test1{{x: {}, y: {}}}", x.x, x.y);
+    ASSERT_EQ(str, expected);
 }
 FMT_TEST(CTH_FORMAT_CPT, main) {
-    auto const str = std::format("{}", ::test::VALUE2);
-    ASSERT_EQ("test::test_concept{VALUE2}", str);
+    auto const str = std::format("{}", ::test::Test3{x});
+    auto const expected = std::format("test::test_concept{{{}}}", x);
+
+    ASSERT_EQ(str, expected);
 }
 }