Bump libfmt; enable Qt 6 build; add std::format support

qt/CMakeLists.txt

@@ -18,6 +18,7 @@ add_subdirectory(singleshot_connect)
 add_subdirectory(tabWindow)
 add_subdirectory(ui_watchdog)
 add_subdirectory(qt6_natvis)
+add_subdirectory(qt_fmt)
 
 if(LINUX)
     add_subdirectory(asan_assert_fail_qt)
@@ -26,7 +27,4 @@ endif()
 if(QT_VERSION_MAJOR EQUAL 5)
     # Qt6 has it's own QStringTokenizer
     add_subdirectory(stringtokenizer)
-
-    # fails to build with with Qt6
-    add_subdirectory(qt_fmt)
 endif()

qt/qt_fmt/CMakeLists.txt

@@ -1,11 +1,15 @@
 # This file is part of KDToolBox.
 #
-# SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+# SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
 #
 # SPDX-License-Identifier: MIT
 #
 include(CheckSubmoduleExists)
 
 check_submodule_exists(fmt fmt)
 
-add_subdirectory(test)
+add_subdirectory(testfmt)
+
+if(KDTOOLBOX_CXX20)
+    add_subdirectory(teststd)
+endif()

qt/qt_fmt/qt_fmt.h

@@ -1,75 +1,17 @@
 /*
   This file is part of KDToolBox.
 
-  SPDX-FileCopyrightText: 2019 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+  SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
 
   SPDX-License-Identifier: MIT
 */
 
 #pragma once
 
-#include <fmt/format.h>
-
-#include <type_traits>
+#include "qt_fmt_helpers.h"
 
+#include <fmt/format.h>
 #include <QDebug>
-#include <QString>
-
-namespace Qt_fmt
-{
-namespace detail
-{
-
-template<typename T, template<typename...> typename Primary>
-struct is_specialization_of : std::false_type
-{
-};
-
-template<template<typename...> typename Primary, typename... Args>
-struct is_specialization_of<Primary<Args...>, Primary> : std::true_type
-{
-};
-
-} // namespace detail
-
-// Offering this as a customization point for users who might want to
-// define both QDebug streaming and fmt formatters, so they need a way
-// to shut down this path.
-//
-// Note: keeping this in sync between fmt and QDebug sounds like a
-// nightmare.
-// clang-format off
-template<typename T, typename Enable = void>
-struct exclude_from_qdebug_fmt
-    : std::disjunction<std::is_fundamental<T>,
-                       // QByteArray is a thorn in the side.
-                       // fmt handles automatically types that convert to const char *,
-                       // but not types that convert to const void *. QByteArray by default
-                       // converts to both; so be careful about it here.
-                       std::conjunction<
-                           std::is_convertible<T, const void *>,
-                           std::negation<std::is_same<std::remove_cv_t<T>, QByteArray>>
-                       >,
-                       std::conjunction<
-                           std::is_convertible<T, const char *>,
-                           std::negation<std::is_same<std::remove_cv_t<T>, QByteArray>>
-                       >,
-                       // Re-include char-arrays, since the above would exclude them
-                       std::conjunction<
-                           std::is_array<T>,
-                           std::is_same<std::remove_cv_t<T>, char>
-                       >,
-                       // fmt doesn't necessarily offer these as builtins, but let's be conservative
-                       detail::is_specialization_of<T, std::pair>,
-                       detail::is_specialization_of<T, std::vector>,
-                       detail::is_specialization_of<T, std::list>,
-                       detail::is_specialization_of<T, std::map>,
-                       detail::is_specialization_of<T, std::multimap>>
-{
-};
-// clang-format on
-
-} // namespace Qt_fmt
 
 template<typename T>
 struct fmt::formatter<T, char,
@@ -86,7 +28,7 @@ struct fmt::formatter<T, char,
     }
 
     template<typename FormatContext>
-    auto format(const T &t, FormatContext &ctx)
+    auto format(const T &t, FormatContext &ctx) const
     {
         // This is really expensive (lots of allocations). Unfortunately
         // there isn't something as easy to do that also performs better.

qt/qt_fmt/qt_fmt_helpers.h

@@ -0,0 +1,87 @@
+/*
+  This file is part of KDToolBox.
+
+  SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+
+  SPDX-License-Identifier: MIT
+*/
+
+#pragma once
+
+#include <type_traits>
+
+#include <QDebug>
+#include <QString>
+#include <QByteArray>
+#include <utility>
+#include <vector>
+#include <map>
+#include <set>
+#include <list>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace Qt_fmt
+{
+namespace detail
+{
+
+template<typename T, template<typename...> typename Primary>
+struct is_specialization_of : std::false_type
+{
+};
+
+template<template<typename...> typename Primary, typename... Args>
+struct is_specialization_of<Primary<Args...>, Primary> : std::true_type
+{
+};
+
+} // namespace detail
+
+// Offering this as a customization point for users who might want to
+// define both QDebug streaming and fmt formatters, so they need a way
+// to shut down this path.
+//
+// Note: keeping this in sync between fmt and QDebug sounds like a
+// nightmare.
+// clang-format off
+template<typename T, typename Enable = void>
+struct exclude_from_qdebug_fmt
+    : std::disjunction<std::is_fundamental<T>,
+                       // QByteArray is a thorn in the side.
+                       // fmt handles automatically types that convert to const char *,
+                       // but not types that convert to const void *. QByteArray by default
+                       // converts to both; so be careful about it here.
+                       std::conjunction<
+                           std::is_convertible<T, const void *>,
+                           std::negation<std::is_same<std::remove_cv_t<T>, QByteArray>>
+                       >,
+                       std::conjunction<
+                           std::is_convertible<T, const char *>,
+                           std::negation<std::is_same<std::remove_cv_t<T>, QByteArray>>
+                       >,
+                       // Re-include char-arrays, since the above would exclude them
+                       std::conjunction<
+                           std::is_array<T>,
+                           std::is_same<std::remove_cv_t<T>, char>
+                       >,
+                       // fmt doesn't necessarily offer these as builtins, but let's be conservative
+                       detail::is_specialization_of<T, std::pair>,
+                       detail::is_specialization_of<T, std::tuple>,
+                       detail::is_specialization_of<T, std::vector>,
+                       detail::is_specialization_of<T, std::list>,
+                       detail::is_specialization_of<T, std::map>,
+                       detail::is_specialization_of<T, std::multimap>,
+                       detail::is_specialization_of<T, std::set>,
+                       detail::is_specialization_of<T, std::multiset>,
+                       detail::is_specialization_of<T, std::unordered_map>,
+                       detail::is_specialization_of<T, std::unordered_set>,
+                       detail::is_specialization_of<T, std::unordered_multimap>,
+                       detail::is_specialization_of<T, std::unordered_multiset>
+>
+{
+};
+// clang-format on
+
+} // namespace Qt_fmt
+

qt/qt_fmt/qt_std_format.h

@@ -0,0 +1,52 @@
+/*
+  This file is part of KDToolBox.
+
+  SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+
+  SPDX-License-Identifier: MIT
+*/
+
+#pragma once
+
+#if __cplusplus < 202002L
+#error "This header requires C++20"
+#endif
+
+#include <format>
+#include <QDebug>
+#include "qt_fmt_helpers.h"
+
+namespace Qt_fmt::detail
+{
+template<typename T>
+concept IsFormattableViaQDebug = requires(QDebug &d, const T &t)
+{
+    d << t;
+    requires !Qt_fmt::exclude_from_qdebug_fmt<T>::value;
+};
+}
+
+template<typename T>
+    requires Qt_fmt::detail::IsFormattableViaQDebug<T>
+struct std::formatter<T, char>
+{
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext &ctx)
+    {
+        auto it = ctx.begin();
+        auto end = ctx.end();
+        if (it != end && *it != '}')
+            throw std::format_error("Only {} is supported");
+        return it;
+    }
+
+    template<typename FormatContext>
+    auto format(const T &t, FormatContext &ctx) const
+    {
+        // See the comment in the libfmt formatter
+        QString buffer;
+        QDebug debug(&buffer);
+        debug.noquote().nospace() << t;
+        return std::format_to(ctx.out(), "{}", buffer.toStdString());
+    }
+};

qt/qt_fmt/test/CMakeLists.txt → qt/qt_fmt/testfmt/CMakeLists.txt

@@ -1,6 +1,6 @@
 # This file is part of KDToolBox.
 #
-# SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+# SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
 #
 # SPDX-License-Identifier: MIT
 #
@@ -19,7 +19,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include_directories(../fmt/include/)
 
-set(test_tmp_2_SOURCES ../fmt/src/format.cc tst_qt_fmt.cpp)
+set(test_qt_fmt_SOURCES ../fmt/src/format.cc tst_qt_fmt.cpp)
 
-add_executable(test_tmp_2 ${test_tmp_2_SOURCES})
-target_link_libraries(test_tmp_2 PUBLIC Qt::Core Qt::Gui Qt::Test)
+add_executable(test_qt_fmt ${test_qt_fmt_SOURCES})
+target_link_libraries(test_qt_fmt PUBLIC Qt::Core Qt::Gui Qt::Test)

qt/qt_fmt/test/tst_qt_fmt.cpp → qt/qt_fmt/testfmt/tst_qt_fmt.cpp

@@ -50,7 +50,7 @@ struct fmt::formatter<BothFmtAndQDebugClass, char>
         return it;
     }
     template<typename FormatContext>
-    auto format(const BothFmtAndQDebugClass &, FormatContext &ctx)
+    auto format(const BothFmtAndQDebugClass &, FormatContext &ctx) const
     {
         return fmt::format_to(ctx.out(), "BothFmtAndQDebugClass via fmt");
     }

qt/qt_fmt/teststd/CMakeLists.txt

@@ -0,0 +1,23 @@
+# This file is part of KDToolBox.
+#
+# SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+#
+# SPDX-License-Identifier: MIT
+#
+find_package(
+    Qt${QT_VERSION_MAJOR}
+    ${QT_REQUIRED_VERSION}
+    CONFIG
+    REQUIRED
+    Core
+    Gui
+    Test
+)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(test_qt_std_format_SOURCES tst_qt_std_format.cpp)
+
+add_executable(test_qt_std_format ${test_qt_std_format_SOURCES})
+target_link_libraries(test_qt_std_format PUBLIC Qt::Core Qt::Gui Qt::Test)