Add fmt::format wrapper macros/functions

Author: Ozaq

src/eckit/CMakeLists.txt

@@ -840,15 +840,22 @@ list( APPEND eckit_testing_srcs
     testing/Test.h
 )
 
+list( APPEND eckit_format_srcs
+    format/Format.h
+    format/Format.cc
+)
+
 list( APPEND eckit_dirs
     bases
     compat
     config
     container
     exception
     filesystem
+    format
     io
     log
+    maths
     memory
     message
     net
@@ -857,14 +864,13 @@ list( APPEND eckit_dirs
     persist
     runtime
     serialisation
-    thread
-    transaction
-    value
-    maths
     system
     testing
+    thread
+    transaction
     types
     utils
+    value
 )
 
 foreach( dir ${eckit_dirs} )
@@ -945,14 +951,14 @@ ecbuild_add_library(
               "${CURL_LIBRARIES}"
               "${AIO_LIBRARIES}"
               "${RADOS_LIBRARIES}"
-              fmt::fmt
 
           PUBLIC_LIBS
               ${CMATH_LIBRARIES}
               ${RT_LIBRARIES}
               ${THREADS_LIBRARIES}
               ${CMAKE_DL_LIBS}
               ${ECKIT_SYSTEM_EXTRA_LIBS}
+              fmt::fmt
 
           LINKER_LANGUAGE CXX )
 

src/eckit/format/Format.cc

@@ -0,0 +1,3 @@
+#include "Format.h"
+
+namespace eckit {}

src/eckit/format/Format.h

@@ -0,0 +1,52 @@
+/*
+ * (C) Copyright 2025- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+#pragma once
+
+#include <fmt/chrono.h>
+#include <fmt/compile.h>
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+#include <fmt/std.h>
+
+#define ENABLE_FORMAT(typ) \
+    template <>            \
+    struct fmt::formatter<typ> : fmt::ostream_formatter {}
+
+/// Format a string with compile time checks.
+/// @param formatString to use, see: <https://fmt.dev/11.1/syntax/> for description of syntax.
+///        Must be known at compiletime
+/// @param ... args to be upplied into formatString
+#define eckit_format(str, ...) fmt::format(FMT_STRING(str), ##__VA_ARGS__)
+
+/// Format s string with compile time optimizations.
+/// Converts formatString into a format string that will be parsed at compile time and converted into efficient
+/// formatting code.
+/// @note Format string compilation can generate more binary code compared to the default API and is only recommended in
+/// places where formatting is a performance bottleneck.
+/// @param formatString to use, see: <https://fmt.dev/11.1/syntax/> for description of syntax.
+/// @param ... args to be upplied into formatString
+/// @throws fm::format_error if args cannot be applied to formatString or formatString syntax is invalid.
+#define eckit_format_cc(str, ...) fmt::format(FMT_COMPILE(str), ##__VA_ARGS__)
+
+
+namespace eckit {
+
+/// Format a string with compile time checks.
+/// @param formatString to use, see: <https://fmt.dev/11.1/syntax/> for description of syntax.
+///        Must be known at compiletime
+/// @param ... args to be upplied into formatString
+/// @throws fmt::format_error
+template <typename StringType, typename... Args>
+std::string format(StringType&& formatString, Args&&... args) {
+    return fmt::format(fmt::runtime(std::forward<StringType>(formatString)), std::forward<Args>(args)...);
+}
+
+
+}  // namespace eckit

tests/CMakeLists.txt

@@ -2,6 +2,7 @@ add_subdirectory( config )
 add_subdirectory( container )
 add_subdirectory( exception )
 add_subdirectory( filesystem )
+add_subdirectory( format )
 add_subdirectory( geometry )
 add_subdirectory( io )
 add_subdirectory( large_file )

tests/format/CMakeLists.txt

@@ -0,0 +1,4 @@
+ecbuild_add_test( TARGET      eckit_test_format
+                  SOURCES     test_format.cc
+                  LIBS        eckit )
+

tests/format/test_format.cc

@@ -0,0 +1,61 @@
+/*
+ * (C) Copyright 2025- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+#include <eckit/testing/Test.h>
+
+#include "eckit/format/Format.h"
+
+CASE("Can use eckit_format macro") {
+    EXPECT_EQUAL(eckit_format("Hello {} {}", 1, 2), std::string("Hello 1 2"));
+    EXPECT_EQUAL(eckit_format(std::string_view("Hello {} {}"), 1, 2), std::string("Hello 1 2"));
+}
+
+CASE("Can use eckit::format") {
+    EXPECT_EQUAL(eckit::format("Hello {} {}", 1, 2), std::string("Hello 1 2"));
+    EXPECT_EQUAL(eckit::format(std::string_view("Hello {} {}"), 1, 2), std::string("Hello 1 2"));
+    EXPECT_EQUAL(eckit::format(std::string("Hello {} {}"), 1, 2), std::string("Hello 1 2"));
+    std::string str("Hello {} {}");
+    std::string_view str_v(str);
+    EXPECT_EQUAL(eckit::format(str_v, 1, 2), std::string("Hello 1 2"));
+}
+
+CASE("eckit::format throws on format erors") {
+    EXPECT_THROWS_AS(eckit::format("Hello {} {} {}", 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format(std::string("Hello {} {} {}"), 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format(std::string_view("Hello {} {} {}"), 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format("Hello {} {} {", 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format(std::string("Hello {} {} {"), 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format(std::string_view("Hello {} {} {"), 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format("Hello {:p} {} {}", 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format(std::string("Hello {:p} {} {}"), 1, 2), fmt::format_error);
+    EXPECT_THROWS_AS(eckit::format(std::string_view("Hello {:p} {} {}"), 1, 2), fmt::format_error);
+}
+
+struct MyType {
+    int x{5};
+};
+std::ostream& operator<<(std::ostream& out, const MyType& mt) {
+    return out << "MyType{" << mt.x << "}";
+}
+ENABLE_FORMAT(MyType);
+
+CASE("ENABLE_FORMAT works") {
+    EXPECT_EQUAL(eckit::format("Hello {}", MyType{}), std::string("Hello MyType{5}"));
+}
+
+ENABLE_FORMAT(eckit::CodeLocation);
+CASE("ENABLE_FORMAT CodeLocation") {
+    // This is just an example
+    std::cout << eckit::format("{}", Here());
+}
+
+
+int main(int argc, char** argv) {
+    return eckit::testing::run_tests(argc, argv);
+}