merge_into as member function

Signed-off-by: Martijn Govers <[email protected]>

Author: mgovers

power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp

@@ -85,14 +85,17 @@ class CalculationInfo : public Logger {
   public:
     Report report() const { return data_; }
     void clear() { data_.clear(); }
-};
 
-inline Logger& merge_into(Logger& destination, CalculationInfo const& source) {
-    for (const auto& [tag, value] : source.report()) {
-        destination.log(tag, value);
+    template <std::derived_from<Logger> T> T& merge_into(T& destination) const {
+        if (&destination == this) {
+            return destination; // nothing to do
+        }
+        for (const auto& [tag, value] : report()) {
+            destination.log(tag, value);
+        }
+        return destination;
     }
-    return destination;
-}
+};
 
 class MultiThreadedCalculationInfo : public MultiThreadedLoggerImpl<CalculationInfo> {
   public:

power_grid_model_c/power_grid_model/include/power_grid_model/common/dummy_logging.hpp

@@ -24,8 +24,8 @@ class NoLogger : public Logger {
     void log(LogEvent /*tag*/, Idx /*value*/) override {
         // no logging
     }
-};
 
-inline Logger& merge_into(Logger& destination, NoLogger const& /*source*/) { return destination; }
+    template <std::derived_from<Logger> T> T& merge_into(T& destination) const { return destination; }
+};
 
 } // namespace power_grid_model::common::logging

power_grid_model_c/power_grid_model/include/power_grid_model/common/multi_threaded_logging.hpp

@@ -6,13 +6,14 @@
 
 #include "dummy_logging.hpp"
 
+#include <cassert>
 #include <mutex>
 
 namespace power_grid_model::common::logging {
 
 template <std::derived_from<Logger> LoggerType>
     requires requires(LoggerType& destination, LoggerType const& source) {
-        { merge_into(destination, source) };
+        { source.merge_into(destination) };
     }
 class MultiThreadedLoggerImpl : public MultiThreadedLogger {
   public:
@@ -46,8 +47,10 @@ class MultiThreadedLoggerImpl : public MultiThreadedLogger {
     std::mutex mutex_;
 
     void sync(ThreadLogger const& logger) {
+        assert(&logger != &log_);
+
         std::lock_guard const lock{mutex_};
-        merge_into(log_, static_cast<LoggerType const&>(logger));
+        logger.merge_into(log_);
     }
 };
 

tests/benchmark_cpp/benchmark.cpp

@@ -153,7 +153,7 @@ struct PowerGridBenchmark {
         try {
             // calculate
             main_model->calculate(model_options, output.get_dataset(), batch_data.get_dataset());
-            common::logging::merge_into(info, main_model->calculation_info());
+            main_model->calculation_info().merge_into(info);
         } catch (std::exception const& e) {
             std::cout << std::format("\nAn exception was raised during execution: {}\n", e.what());
         }

tests/cpp_unit_tests/test_job_dispatch.cpp

@@ -129,26 +129,29 @@ class TestLogger : public common::logging::Logger {
 
     Data const& report() const { return log_; }
 
+    template <std::derived_from<Logger> T> T& merge_into(T& destination) const {
+        if (&destination == this) {
+            return destination; // nothing to do
+        }
+        for (const auto& entry : report()) {
+            std::visit(
+                [&destination, event = entry.event](auto&& arg) {
+                    using U = std::decay_t<decltype(arg)>;
+                    if constexpr (std::same_as<U, TestLogger::EmptyEvent>) {
+                        destination.log(event);
+                    } else {
+                        destination.log(event, arg);
+                    }
+                },
+                entry.data);
+        }
+        return destination;
+    }
+
   private:
     Data log_;
 };
 
-inline Logger& merge_into(Logger& destination, TestLogger const& source) {
-    for (const auto& entry : source.report()) {
-        std::visit(
-            [&destination, event = entry.event](auto&& arg) {
-                using T = std::decay_t<decltype(arg)>;
-                if constexpr (std::same_as<T, TestLogger::EmptyEvent>) {
-                    destination.log(event);
-                } else {
-                    destination.log(event, arg);
-                }
-            },
-            entry.data);
-    }
-    return destination;
-}
-
 class MultiThreadedTestLogger : public common::logging::MultiThreadedLoggerImpl<TestLogger> {
   public:
     using MultiThreadedLoggerImpl::MultiThreadedLoggerImpl;