Add std::format_args support; Bump version to 1.0.5

Author: kzhdev

CHANGELOG

@@ -1,4 +1,11 @@
-# 
+# v1.0.5 - 02-10-2026
+- Add `std::format_args` support: pass a pre-built `std::format_args` object directly to any log call
+  - Arguments are unpacked and copied into the log entry on the calling thread (safe across thread boundary)
+  - Supports all standard `std::basic_format_arg` types: bool, char, int, unsigned, long long, unsigned long long, float, double, long double, const char*, string_view, and void*
+  - Custom formatter types (`std::formatter` handle) are not supported; they will be logged as `<handle>`
+  - Fix `const void*` handling in `enqueue_argument` (also benefits regular pointer logging)
+
+#
 - Updated cmake config template to avoid cmake config warning
 
 # v1.0.4 - 01-11-2026

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.20)
 
-project(slick-logger 
-    VERSION 1.0.4
+project(slick-logger
+    VERSION 1.0.5
     LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)

README.md

@@ -181,6 +181,27 @@ int main() {
 - **Extensible**: Easy to add custom formatters for user-defined types
 - **Standard**: Part of C++20 standard library, no external dependencies
 
+### Passing std::format_args
+
+You can pass a pre-built `std::format_args` object as the single argument to any log call. This lets you capture format arguments once and reuse them, or forward a pre-built arg pack from another function:
+
+```cpp
+int count = 42;
+double price = 9.99;
+std::string_view name = "widget";
+
+// Capture args once, pass to logger
+auto args = std::make_format_args(count, price, name);
+LOG_INFO("count={} price={:.2f} name={}", args);
+
+// Also works inline
+LOG_DEBUG("x={} y={}", std::make_format_args(x, y));
+```
+
+> **Note:** `std::make_format_args` requires all arguments to be lvalues. Pass temporary values via a named variable.
+
+> **Limitation:** Custom formatter types (types requiring a `std::formatter` specialization, represented as `handle` inside `std::format_args`) are not supported. They will be logged as `<handle>`. Use the normal variadic log call for custom-formatted types.
+
 ### Multi-Sink Usage
 
 ```cpp

include/slick/logger.hpp

@@ -195,6 +195,16 @@ enum class ArgType : uint8_t {
     STRING_DYNAMIC   // std::string - stored in separate queue
 };
 
+// True when Args... is exactly one type convertible to std::format_args —
+// used to detect the pre-built format_args overload in log_to_sink.
+// std::make_format_args() returns an implementation-defined store type
+// (e.g. std::_Format_arg_store on MSVC) that converts to std::format_args,
+// so we check convertibility rather than exact type identity.
+template<typename... Args>
+inline constexpr bool is_single_format_args_v =
+    sizeof...(Args) == 1 &&
+    (std::is_convertible_v<std::decay_t<Args>, std::format_args> || ...);
+
 #pragma pack(push, 1)
 struct StringRef {
     const char* ptr;    // Pointer to string data
@@ -624,6 +634,8 @@ class Logger {
     template<typename T>
     void enqueue_argument(LogArgument& arg, T&& value);
 
+    void enqueue_format_args(LogEntry& entry, std::format_args fa);
+
     StringRef store_string_in_queue(std::string_view str);
 
     std::unique_ptr<slick::SlickQueue<LogEntry>> log_queue_;
@@ -1429,13 +1441,20 @@ inline void Logger::log_to_sink(int sink_index, LogLevel level, FormatT&& format
     entry.sink_index = sink_index;
     if constexpr (IS_STRING_LITERAL(format)) {
         entry.format_ptr = format;  // String literal - safe to store pointer
-        entry.arg_count = sizeof...(args);
 
-        // push arguments
-        size_t arg_idx = 0;
-        static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
-        (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
-    } 
+        if constexpr (is_single_format_args_v<Args...>) {
+            // Pre-built std::format_args: unpack values into the entry on the
+            // calling thread (format_args holds non-owning references).
+            enqueue_format_args(entry,
+                std::get<0>(std::forward_as_tuple(std::forward<Args>(args)...)));
+        } else {
+            // Normal path: push individual arguments
+            entry.arg_count = sizeof...(args);
+            size_t arg_idx = 0;
+            static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
+            (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
+        }
+    }
     else {
         // Store dynamic string in string queue
         static_assert(sizeof...(args) == 0, "Dynamic format strings are only supported when there are no arguments, to avoid dangling pointers.");
@@ -1559,6 +1578,10 @@ inline void Logger::enqueue_argument(LogArgument& arg, T&& value) {
         arg.type = ArgType::STRING_DYNAMIC;
         arg.value.dynamic_str = store_string_in_queue(value);
     }
+    else if constexpr (std::is_same_v<DecayedT, const void*>) {
+        arg.type = ArgType::PTR;
+        arg.value.ptr = const_cast<void*>(value);
+    }
     else if constexpr (std::is_pointer_v<DecayedT>) {
         arg.type = ArgType::PTR;
         arg.value.ptr = static_cast<void*>(value);
@@ -1590,6 +1613,29 @@ inline StringRef Logger::store_string_in_queue(std::string_view str) {
     return StringRef{dest, length};
 }
 
+inline void Logger::enqueue_format_args(LogEntry& entry, std::format_args fa) {
+    size_t arg_idx = 0;
+    while (arg_idx < SLICK_LOGGER_MAX_ARGS) {
+        auto arg = fa.get(arg_idx);
+        bool is_monostate = false;
+        std::visit_format_arg([&]<typename T>(T&& v) {
+            using DT = std::decay_t<T>;
+            if constexpr (std::is_same_v<DT, std::monostate>) {
+                is_monostate = true;
+            } else if constexpr (std::is_same_v<DT, typename std::basic_format_arg<std::format_context>::handle>) {
+                // Custom type via handle: std::format_context is not publicly
+                // constructible, so store a placeholder instead.
+                enqueue_argument(entry.args[arg_idx], std::string_view{"<handle>"});
+            } else {
+                enqueue_argument(entry.args[arg_idx], std::forward<T>(v));
+            }
+        }, arg);
+        if (is_monostate) break;
+        ++arg_idx;
+    }
+    entry.arg_count = static_cast<uint8_t>(arg_idx);
+}
+
 inline void Logger::shutdown(bool clear_sinks) {
     if (running_.load(std::memory_order_relaxed)) {
         running_.store(false, std::memory_order_release);

src/logger.hpp

@@ -193,6 +193,16 @@ enum class ArgType : uint8_t {
     STRING_DYNAMIC   // std::string - stored in separate queue
 };
 
+// True when Args... is exactly one type convertible to std::format_args —
+// used to detect the pre-built format_args overload in log_to_sink.
+// std::make_format_args() returns an implementation-defined store type
+// (e.g. std::_Format_arg_store on MSVC) that converts to std::format_args,
+// so we check convertibility rather than exact type identity.
+template<typename... Args>
+inline constexpr bool is_single_format_args_v =
+    sizeof...(Args) == 1 &&
+    (std::is_convertible_v<std::decay_t<Args>, std::format_args> || ...);
+
 #pragma pack(push, 1)
 struct StringRef {
     const char* ptr;    // Pointer to string data
@@ -622,6 +632,8 @@ class Logger {
     template<typename T>
     void enqueue_argument(LogArgument& arg, T&& value);
 
+    void enqueue_format_args(LogEntry& entry, std::format_args fa);
+
     StringRef store_string_in_queue(std::string_view str);
 
     std::unique_ptr<slick::SlickQueue<LogEntry>> log_queue_;
@@ -1427,13 +1439,20 @@ inline void Logger::log_to_sink(int sink_index, LogLevel level, FormatT&& format
     entry.sink_index = sink_index;
     if constexpr (IS_STRING_LITERAL(format)) {
         entry.format_ptr = format;  // String literal - safe to store pointer
-        entry.arg_count = sizeof...(args);
 
-        // push arguments
-        size_t arg_idx = 0;
-        static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
-        (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
-    } 
+        if constexpr (is_single_format_args_v<Args...>) {
+            // Pre-built std::format_args: unpack values into the entry on the
+            // calling thread (format_args holds non-owning references).
+            enqueue_format_args(entry,
+                std::get<0>(std::forward_as_tuple(std::forward<Args>(args)...)));
+        } else {
+            // Normal path: push individual arguments
+            entry.arg_count = sizeof...(args);
+            size_t arg_idx = 0;
+            static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
+            (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
+        }
+    }
     else {
         // Store dynamic string in string queue
         static_assert(sizeof...(args) == 0, "Dynamic format strings are only supported when there are no arguments, to avoid dangling pointers.");
@@ -1557,6 +1576,10 @@ inline void Logger::enqueue_argument(LogArgument& arg, T&& value) {
         arg.type = ArgType::STRING_DYNAMIC;
         arg.value.dynamic_str = store_string_in_queue(value);
     }
+    else if constexpr (std::is_same_v<DecayedT, const void*>) {
+        arg.type = ArgType::PTR;
+        arg.value.ptr = const_cast<void*>(value);
+    }
     else if constexpr (std::is_pointer_v<DecayedT>) {
         arg.type = ArgType::PTR;
         arg.value.ptr = static_cast<void*>(value);
@@ -1588,6 +1611,29 @@ inline StringRef Logger::store_string_in_queue(std::string_view str) {
     return StringRef{dest, length};
 }
 
+inline void Logger::enqueue_format_args(LogEntry& entry, std::format_args fa) {
+    size_t arg_idx = 0;
+    while (arg_idx < SLICK_LOGGER_MAX_ARGS) {
+        auto arg = fa.get(arg_idx);
+        bool is_monostate = false;
+        std::visit_format_arg([&]<typename T>(T&& v) {
+            using DT = std::decay_t<T>;
+            if constexpr (std::is_same_v<DT, std::monostate>) {
+                is_monostate = true;
+            } else if constexpr (std::is_same_v<DT, typename std::basic_format_arg<std::format_context>::handle>) {
+                // Custom type via handle: std::format_context is not publicly
+                // constructible, so store a placeholder instead.
+                enqueue_argument(entry.args[arg_idx], std::string_view{"<handle>"});
+            } else {
+                enqueue_argument(entry.args[arg_idx], std::forward<T>(v));
+            }
+        }, arg);
+        if (is_monostate) break;
+        ++arg_idx;
+    }
+    entry.arg_count = static_cast<uint8_t>(arg_idx);
+}
+
 inline void Logger::shutdown(bool clear_sinks) {
     if (running_.load(std::memory_order_relaxed)) {
         running_.store(false, std::memory_order_release);

tests/test_logger.cpp

@@ -18,6 +18,7 @@ class SlickLoggerTest : public ::testing::Test {
         std::filesystem::remove("test_char_array.log");
         std::filesystem::remove("test_single_string.log");
         std::filesystem::remove("test_empty_string.log");
+        std::filesystem::remove("test_format_args.log");
     }
 };
 
@@ -370,6 +371,38 @@ TEST_F(SlickLoggerTest, EmptyStringView) {
     EXPECT_EQ(line.find(" [INFO] Log empty string: "), 26);
 }
 
+TEST_F(SlickLoggerTest, FormatArgsLogging) {
+    std::filesystem::remove("test_format_args.log");
+
+    slick::logger::Logger::instance().init("test_format_args.log", 1024);
+
+    int i = 42;
+    double d = 3.14;
+    std::string_view sv = "hello";
+    bool b = true;
+    void* p = &d;
+
+    // Pre-build format_args and pass to logger
+    LOG_INFO("int={} double={:.2f} str={} bool={} pointer={:p}", std::make_format_args(i, d, sv, b, p));
+
+    slick::logger::Logger::instance().shutdown();
+
+    ASSERT_TRUE(std::filesystem::exists("test_format_args.log"));
+
+    std::ifstream log_file("test_format_args.log");
+    std::string file_contents;
+    std::string line;
+    std::getline(log_file, line); // first line is the logger's version
+    while (std::getline(log_file, line)) {
+        file_contents += line + "\n";
+    }
+
+    EXPECT_NE(file_contents.find("int=42 double=3.14 str=hello bool=true"), std::string::npos);
+
+    log_file.close();
+    std::filesystem::remove("test_format_args.log");
+}
+
 int main(int argc, char **argv) {
     testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();