Merge pull request #1111 from PowerGridModel/feature/clang-tidy

mgovers · web-flow · commit 38a142134d02 · 2025-09-03T12:21:49.000Z
Clean-up main model: fix windows clang-tidy
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp
@@ -84,8 +84,8 @@ template <typename Adapter> class JobInterface {
         static_cast<Adapter*>(this)->thread_safe_add_calculation_info_impl(info);
     }
 
-  protected:
-    // Protected & defaulted special members — CRTP: only the derived can create/copy/move this base
+  private:
+    friend Adapter;
     JobInterface() = default;
     JobInterface(const JobInterface& /*other*/) = default;
     JobInterface& operator=(const JobInterface& /*other*/) = default;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
@@ -9,6 +9,8 @@
 
 #include "../all_components.hpp"
 
+#include <concepts>
+
 namespace power_grid_model::main_core {
 
 namespace detail {
@@ -103,7 +105,7 @@ template <typename Component, typename IndexType, class ComponentContainer, std:
 constexpr void produce_output(MainModelState<ComponentContainer> const& state, ComponentOutput&& output,
                               ResFunc&& func) {
     std::ranges::transform(get_component_citer<Component>(state), comp_base_sequence<Component>(state),
-                           std::ranges::begin(output), std::forward<ResFunc>(func));
+                           std::ranges::begin(std::forward<ComponentOutput>(output)), std::forward<ResFunc>(func));
 }
 
 } // namespace detail
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -180,7 +180,7 @@ constexpr void register_topology_components(ComponentContainer const& components
 
 template <std::same_as<Branch> Component, class ComponentContainer>
     requires common::component_container_c<ComponentContainer, Component>
-constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+constexpr void register_connections_components(ComponentContainer const& components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.branch_connected, [](Branch const& branch) {
         return BranchConnected{static_cast<IntS>(branch.from_status()), static_cast<IntS>(branch.to_status())};
     });
@@ -189,7 +189,7 @@ constexpr void register_connections_components(ComponentContainer components, Co
 }
 template <std::same_as<Branch3> Component, class ComponentContainer>
     requires common::component_container_c<ComponentContainer, Component>
-constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+constexpr void register_connections_components(ComponentContainer const& components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.branch3_connected, [](Branch3 const& branch3) {
         return Branch3Connected{static_cast<IntS>(branch3.status_1()), static_cast<IntS>(branch3.status_2()),
                                 static_cast<IntS>(branch3.status_3())};
@@ -200,7 +200,7 @@ constexpr void register_connections_components(ComponentContainer components, Co
 
 template <std::same_as<Source> Component, class ComponentContainer>
     requires common::component_container_c<ComponentContainer, Component>
-constexpr void register_connections_components(ComponentContainer components, ComponentConnections& comp_conn) {
+constexpr void register_connections_components(ComponentContainer const& components, ComponentConnections& comp_conn) {
     apply_registration<Component>(components, comp_conn.source_connected,
                                   [](Source const& source) { return source.status(); });
 }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/y_bus.hpp
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "../common/common.hpp"
+
 namespace power_grid_model::main_core {
 
 template <symmetry_tag sym, typename ComponentContainer, typename... ComponentType>
@@ -47,7 +49,7 @@ void prepare_y_bus(MainModelState<ComponentContainer> const& state_, Idx n_math_
 
 template <symmetry_tag sym, typename ComponentContainer, typename... ComponentType>
 static std::vector<MathModelParamIncrement> get_math_param_increment(
-    MainModelState<ComponentContainer> received_state, Idx n_math_solvers_,
+    MainModelState<ComponentContainer>& received_state, Idx n_math_solvers_,
     std::array<std::vector<Idx2D>, main_core::utils::n_types<ComponentType...>> const& parameter_changed_components_) {
     using AddToIncrement =
         void (*)(std::vector<MathModelParamIncrement>&, MainModelState<ComponentContainer> const&, Idx2D const&);
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
@@ -264,7 +264,8 @@ struct YBusStructure {
         // construct transpose entry
         lu_transpose_entry.resize(nnz_counter_lu);
         // default transpose_entry[i] = i
-        std::iota(lu_transpose_entry.begin(), lu_transpose_entry.end(), 0);
+        std::iota( // NOLINT(modernize-use-ranges) // not yet supported by some compilers
+            lu_transpose_entry.begin(), lu_transpose_entry.end(), 0);
         // fill off-diagonal, loop all the branches
         for (auto const [entry_1, entry_2] : off_diag_map) {
             // for each branch entry tf and ft, they are transpose to each other
diff --git a/tests/benchmark_cpp/benchmark.cpp b/tests/benchmark_cpp/benchmark.cpp
@@ -104,25 +104,26 @@ std::string make_key(LogEvent code) {
 }
 
 auto get_benchmark_run_title(Option const& option, MainModelOptions const& model_options) {
-    auto const mv_ring_type = option.has_mv_ring ? "meshed grid" : "radial grid";
+    using namespace std::string_literals;
+    auto const mv_ring_type = option.has_mv_ring ? "meshed grid"s : "radial grid"s;
     auto const sym_type =
-        model_options.calculation_symmetry == CalculationSymmetry::symmetric ? "symmetric" : "asymmetric";
+        model_options.calculation_symmetry == CalculationSymmetry::symmetric ? "symmetric"s : "asymmetric"s;
     auto const method = [calculation_method = model_options.calculation_method] {
         using enum CalculationMethod;
 
         switch (calculation_method) {
         case newton_raphson:
-            return "Newton-Raphson method";
+            return "Newton-Raphson method"s;
         case linear:
-            return "Linear method";
+            return "Linear method"s;
         case linear_current:
-            return "Linear current method";
+            return "Linear current method"s;
         case iterative_current:
-            return "Iterative current method";
+            return "Iterative current method"s;
         case iterative_linear:
-            return "Iterative linear method";
+            return "Iterative linear method"s;
         case iec60909:
-            return "IEC 60909 method";
+            return "IEC 60909 method"s;
         default:
             throw MissingCaseForEnumError{"get_benchmark_run_title", calculation_method};
         }
@@ -171,15 +172,18 @@ struct PowerGridBenchmark {
         auto const run = [this, &model_options, &info](Idx batch_size_) {
             switch (model_options.calculation_type) {
             case short_circuit:
-                return run_calculation<ShortCircuitOutputData>(model_options, batch_size_, info);
+                run_calculation<ShortCircuitOutputData>(model_options, batch_size_, info);
+                break;
             case power_flow:
                 [[fallthrough]];
             case state_estimation: {
                 switch (model_options.calculation_symmetry) {
                 case CalculationSymmetry::symmetric:
-                    return run_calculation<OutputData<symmetric_t>>(model_options, batch_size_, info);
+                    run_calculation<OutputData<symmetric_t>>(model_options, batch_size_, info);
+                    break;
                 case CalculationSymmetry::asymmetric:
-                    return run_calculation<OutputData<asymmetric_t>>(model_options, batch_size_, info);
+                    run_calculation<OutputData<asymmetric_t>>(model_options, batch_size_, info);
+                    break;
                 default:
                     throw MissingCaseForEnumError{"run_benchmark<calculation_symmetry>",
                                                   model_options.calculation_symmetry};
@@ -231,11 +235,6 @@ struct PowerGridBenchmark {
 } // namespace
 } // namespace power_grid_model::benchmark
 
-namespace {
-using power_grid_model::asymmetric_t;
-using power_grid_model::symmetric_t;
-} // namespace
-
 int main(int /* argc */, char** /* argv */) {
     using enum power_grid_model::CalculationType;
     using enum power_grid_model::CalculationMethod;
diff --git a/tests/benchmark_cpp/fictional_grid_generator.hpp b/tests/benchmark_cpp/fictional_grid_generator.hpp
@@ -646,8 +646,8 @@ class FictionalGridGenerator {
         std::uniform_real_distribution<double> load_scaling_gen{0.0, 1.0};
         load_series.resize(input.size() * batch_size);
         auto const n_object = std::ssize(input);
-        for (Idx batch : IdxRange{batch_size}) {
-            for (Idx object : IdxRange{n_object}) {
+        for (Idx const batch : IdxRange{batch_size}) {
+            for (Idx const object : IdxRange{n_object}) {
                 T const& input_obj = input[object];
                 U& update_obj = load_series[batch * n_object + object];
                 update_obj.id = input_obj.id;
@@ -698,10 +698,10 @@ class FictionalGridGenerator {
 
         sensor_series.resize(input.size() * batch_size);
         auto const n_object = std::ssize(input);
-        for (Idx object : IdxRange{n_object}) {
+        for (Idx const object : IdxRange{n_object}) {
             T const& input_obj = input[object];
 
-            for (Idx batch : IdxRange{batch_size}) {
+            for (Idx const batch : IdxRange{batch_size}) {
                 U& update_obj = sensor_series[batch * n_object + object];
                 update_obj.id = input_obj.id;
                 if constexpr (is_symmetric_v<typename T::sym>) {
diff --git a/tests/cpp_unit_tests/test_dataset.cpp b/tests/cpp_unit_tests/test_dataset.cpp
@@ -1071,8 +1071,10 @@ TEST_CASE_TEMPLATE("Test dataset (common)", DatasetType, ConstDataset, MutableDa
                 auto a_a1_buffer = std::vector<double>(a_elements_per_scenario * batch_size);
                 auto b_indptr = std::vector<Idx>{0, 0, 3};
 
-                std::iota(a_id_buffer.begin(), a_id_buffer.end(), ID{0});
-                std::iota(a_a1_buffer.begin(), a_a1_buffer.end(), 0.0);
+                std::iota( // NOLINT(modernize-use-ranges) // not yet supported by some compilers
+                    a_id_buffer.begin(), a_id_buffer.end(), ID{0});
+                std::iota( // NOLINT(modernize-use-ranges) // not yet supported by some compilers
+                    a_a1_buffer.begin(), a_a1_buffer.end(), 0.0);
 
                 add_homogeneous_buffer(dataset, A::name, a_elements_per_scenario, nullptr);
                 add_attribute_buffer(dataset, A::name, "id", static_cast<void*>(a_id_buffer.data()));
diff --git a/tests/cpp_unit_tests/test_exceptions.cpp b/tests/cpp_unit_tests/test_exceptions.cpp
@@ -38,8 +38,8 @@ TEST_CASE("Exceptions") {
         CHECK(std::string{InvalidArguments{"bar"}.what()} == "bar");
         CHECK(std::string{InvalidArguments{"foo", "bar"}.what()} == "foo is not implemented for bar!\n");
 
-        InvalidArguments::TypeValuePair const foo{"foo", "baz"};
-        InvalidArguments::TypeValuePair const bar{"bar", "bla"};
+        InvalidArguments::TypeValuePair const foo{.name = "foo", .value = "baz"};
+        InvalidArguments::TypeValuePair const bar{.name = "bar", .value = "bla"};
         CHECK(std::string{InvalidArguments{"Test method", foo}.what()} ==
               "Test method is not implemented for the following combination of options!\n"
               " foo: baz\n");
@@ -298,8 +298,8 @@ TEST_CASE("Exceptions") {
         CHECK(std::string{ExperimentalFeature{"bar"}.what()} == "bar");
         CHECK(std::string{ExperimentalFeature{"foo", "bar"}.what()} == "foo is not implemented for bar!\n");
 
-        ExperimentalFeature::TypeValuePair const foo{"foo", "baz"};
-        ExperimentalFeature::TypeValuePair const bar{"bar", "bla"};
+        ExperimentalFeature::TypeValuePair const foo{.name = "foo", .value = "baz"};
+        ExperimentalFeature::TypeValuePair const bar{.name = "bar", .value = "bla"};
         CHECK(std::string{ExperimentalFeature{"Test method", foo}.what()} ==
               "Test method is not implemented for the following combination of options!\n"
               " foo: baz\n");
