clang-tidy

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

Author: mgovers

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

@@ -21,14 +21,18 @@ class MultiThreadedLoggerImpl : public MultiThreadedLogger {
     class ThreadLogger : public SubThreadLogger {
       public:
         ThreadLogger(MultiThreadedLoggerImpl& parent) : parent_{&parent} {}
+        ThreadLogger(ThreadLogger const&) = default;
+        ThreadLogger& operator=(ThreadLogger const&) = default;
+        ThreadLogger(ThreadLogger&&) noexcept = default;
+        ThreadLogger& operator=(ThreadLogger&&) noexcept = default;
         ~ThreadLogger() override { sync(); }
         void sync() const { parent_->sync(*this); }
 
       private:
         MultiThreadedLoggerImpl* parent_;
     };
 
-    virtual std::unique_ptr<Logger> create_child() override { return std::make_unique<ThreadLogger>(*this); }
+    std::unique_ptr<Logger> create_child() override { return std::make_unique<ThreadLogger>(*this); }
     LoggerType& get() { return log_; }
     LoggerType const& get() const { return log_; }
 
@@ -44,7 +48,7 @@ class MultiThreadedLoggerImpl : public MultiThreadedLogger {
     std::mutex mutex_;
 
     void sync(ThreadLogger const& logger) {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         merge_into(log_, static_cast<SubThreadLogger const&>(logger));
     }
 };

power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp

@@ -49,7 +49,7 @@ class JobDispatch {
         std::vector<std::string> exceptions(n_scenarios, "");
 
         adapter.prepare_job_dispatch(update_data);
-        auto single_job = single_thread_job(adapter, result_data, update_data, exceptions, log);
+        auto single_job = JobDispatch::single_thread_job(adapter, result_data, update_data, exceptions, log);
 
         job_dispatch(single_job, n_scenarios, threading);
 
@@ -74,6 +74,23 @@ class JobDispatch {
         return batch_calculation(adapter, result_data, update_data, sequential);
     }
 
+    // Lippincott pattern
+    static auto scenario_exception_handler(std::vector<std::string>& messages) {
+        return [&messages](Idx scenario_idx) -> void {
+            assert(0 <= scenario_idx);
+            assert(scenario_idx < messages.size());
+
+            std::exception_ptr const ex_ptr = std::current_exception();
+            try {
+                std::rethrow_exception(ex_ptr);
+            } catch (std::exception const& ex) {
+                messages[scenario_idx] = ex.what();
+            } catch (...) {
+                messages[scenario_idx] = "unknown exception";
+            }
+        };
+    }
+
     template <typename Adapter, typename ResultDataset, typename UpdateDataset>
     static auto single_thread_job(Adapter& base_adapter, ResultDataset const& result_data,
                                   UpdateDataset const& update_data, std::vector<std::string>& exceptions,
@@ -113,9 +130,9 @@ class JobDispatch {
 
             auto run = [&adapter, &result_data](Idx scenario_idx) { adapter.calculate(result_data, scenario_idx); };
 
-            auto calculate_scenario =
-                JobDispatch::call_with<Idx>(std::move(run), std::move(setup), std::move(winddown),
-                                            scenario_exception_handler(exceptions), std::move(recover_from_bad));
+            auto calculate_scenario = JobDispatch::call_with<Idx>(std::move(run), std::move(setup), std::move(winddown),
+                                                                  JobDispatch::scenario_exception_handler(exceptions),
+                                                                  std::move(recover_from_bad));
 
             for (Idx scenario_idx = start; scenario_idx < n_scenarios; scenario_idx += stride) {
                 Timer const t_total_single{thread_info, LogEvent::total_single_calculation_in_thread};
@@ -187,20 +204,6 @@ class JobDispatch {
         };
     }
 
-    // Lippincott pattern
-    static auto scenario_exception_handler(std::vector<std::string>& messages) {
-        return [&messages](Idx scenario_idx) {
-            std::exception_ptr const ex_ptr = std::current_exception();
-            try {
-                std::rethrow_exception(ex_ptr);
-            } catch (std::exception const& ex) {
-                messages[scenario_idx] = ex.what();
-            } catch (...) {
-                messages[scenario_idx] = "unknown exception";
-            }
-        };
-    }
-
     static void handle_batch_exceptions(std::vector<std::string> const& exceptions) {
         std::string combined_error_message;
         IdxVector failed_scenarios;

power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -75,8 +75,8 @@ template <typename Adapter> class JobInterface {
         static_cast<Adapter*>(this)->set_logger_impl(log);
     }
 
-  protected:
-    // Protected & defaulted special members — CRTP: only the derived can create/copy/move this base
+  private:
+    friend Adapter; // CRTP compliance
     JobInterface() = default;
     JobInterface(const JobInterface& /*other*/) = default;
     JobInterface& operator=(const JobInterface& /*other*/) = default;

tests/cpp_unit_tests/test_job_dispatch.cpp

@@ -52,20 +52,15 @@ class JobAdapterMock : public JobInterface<JobAdapterMock> {
     JobAdapterMock(std::shared_ptr<CallCounter> counter) : counter_{std::move(counter)} {
         REQUIRE_MESSAGE(counter_ != nullptr, "Counter must not be null or all getters will fail later on");
     }
-    JobAdapterMock(JobAdapterMock const& other) : counter_{other.counter_}, logger_{nullptr} {}
+    JobAdapterMock(JobAdapterMock const& other) : counter_{other.counter_} {}
     JobAdapterMock& operator=(JobAdapterMock const& other) {
         if (this != &other) {
             counter_ = other.counter_;
             logger_ = nullptr; // reset logger
         }
         return *this;
     };
-    JobAdapterMock(JobAdapterMock&& other) noexcept {
-        counter_ = std::move(other.counter_);
-        other.counter_ = nullptr;
-        logger_ = other.logger_;
-        other.logger_ = nullptr;
-    };
+    JobAdapterMock(JobAdapterMock&& other) noexcept : counter_{std::move(other.counter_)}, logger_{other.logger_} {}
     JobAdapterMock& operator=(JobAdapterMock&& other) noexcept {
         if (this != &other) {
             counter_ = std::move(other.counter_);