apply clang-tidy-19 suggestions

Signed-off-by: Martijn Govers <Martijn.Govers@Alliander.com>

revert readability-math-missing-parentheses and boost-use-ranges

Signed-off-by: Martijn Govers <Martijn.Govers@Alliander.com>

revert readability-redundant-member-init

Signed-off-by: Martijn Govers <Martijn.Govers@Alliander.com>

Author: mgovers

.clang-tidy

@@ -5,6 +5,7 @@
 Checks: '
 -*,
 boost-*,
+-boost-use-ranges,
 bugprone-*,
 -bugprone-easily-swappable-parameters,
 -bugprone-exception-escape,
@@ -55,6 +56,8 @@ readability-*,
 -readability-function-cognitive-complexity,
 -readability-identifier-length,
 -readability-magic-numbers,
+-readability-math-missing-parentheses,
+-readability-redundant-member-init,
 -bugprone-unchecked-optional-access,
 '
 

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp

@@ -535,8 +535,9 @@ template <dataset_type_tag dataset_type_> class Dataset {
             throw DatasetError{"Cannot have duplicated components!\n"};
         }
         check_uniform_integrity(elements_per_scenario, total_elements);
-        dataset_info_.component_info.push_back(
-            {&dataset_info_.dataset->get_component(component), elements_per_scenario, total_elements});
+        dataset_info_.component_info.push_back({.component = &dataset_info_.dataset->get_component(component),
+                                                .elements_per_scenario = elements_per_scenario,
+                                                .total_elements = total_elements});
         buffers_.push_back(Buffer{});
     }
 

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/deserializer.hpp

@@ -186,6 +186,10 @@ template <class T> struct DefaultErrorVisitor : DefaultNullVisitor {
     bool throw_error() { throw SerializationError{(static_cast<T&>(*this)).get_err_msg()}; }
 
     std::string get_err_msg() { return std::string{T::static_err_msg}; }
+
+  private:
+    DefaultErrorVisitor() = default;
+    friend T; // CRTP compliance
 };
 
 struct visit_map_t;
@@ -238,6 +242,8 @@ struct MapArrayVisitor : DefaultErrorVisitor<MapArrayVisitor<map_array>> {
         assert(size == 0);
         return true;
     }
+
+    MapArrayVisitor<map_array>() = default;
 };
 
 struct StringVisitor : DefaultErrorVisitor<StringVisitor> {
@@ -248,6 +254,8 @@ struct StringVisitor : DefaultErrorVisitor<StringVisitor> {
         str = {v, size};
         return true;
     }
+
+    StringVisitor() = default;
 };
 
 struct BoolVisitor : DefaultErrorVisitor<BoolVisitor> {
@@ -258,6 +266,8 @@ struct BoolVisitor : DefaultErrorVisitor<BoolVisitor> {
         value = v;
         return true;
     }
+
+    BoolVisitor() = default;
 };
 
 template <class T> struct ValueVisitor;
@@ -282,6 +292,8 @@ template <std::integral T> struct ValueVisitor<T> : DefaultErrorVisitor<ValueVis
         value = static_cast<T>(v);
         return true;
     }
+
+    ValueVisitor<T>(T& v) : DefaultErrorVisitor<ValueVisitor<T>>{}, value{v} {}
 };
 
 template <> struct ValueVisitor<double> : DefaultErrorVisitor<ValueVisitor<double>> {
@@ -306,6 +318,8 @@ template <> struct ValueVisitor<double> : DefaultErrorVisitor<ValueVisitor<doubl
         value = v;
         return true;
     }
+
+    ValueVisitor<double>(double& v) : DefaultErrorVisitor<ValueVisitor<double>>{}, value{v} {}
 };
 
 template <> struct ValueVisitor<RealValue<asymmetric_t>> : DefaultErrorVisitor<ValueVisitor<RealValue<asymmetric_t>>> {
@@ -357,6 +371,9 @@ template <> struct ValueVisitor<RealValue<asymmetric_t>> : DefaultErrorVisitor<V
         value[idx] = v;
         return true;
     }
+
+    ValueVisitor<RealValue<asymmetric_t>>(RealValue<asymmetric_t>& v)
+        : DefaultErrorVisitor<ValueVisitor<RealValue<asymmetric_t>>>{}, value{v} {}
 };
 
 } // namespace detail
@@ -656,10 +673,9 @@ class Deserializer {
         while (n_components-- != 0) {
             component_key_ = parse_string();
             Idx const component_size = parse_map_array<visit_array_t, stay_offset>().size;
-            size_t const scenario_offset = offset_;
-            // skip all the real content but check if it has map
-            bool const has_map = parse_skip_check_map();
-            count_per_scenario.push_back({component_key_, component_size, scenario_offset, has_map});
+            count_per_scenario.push_back({.component = component_key_, .size = component_size, .offset = offset_});
+            // skip all the real content
+            parse_skip();
         }
         component_key_ = {};
         return count_per_scenario;
@@ -943,7 +959,7 @@ class Deserializer {
 
         ctype_func_selector(attribute.ctype, [&buffer_view, &component, &attribute, this]<class T> {
             ValueVisitor<T> visitor{
-                {}, attribute.get_attribute<T>(component.advance_ptr(buffer_view.buffer->data, buffer_view.idx))};
+                attribute.get_attribute<T>(component.advance_ptr(buffer_view.buffer->data, buffer_view.idx))};
             msgpack::parse(data_, size_, offset_, visitor);
         });
     }
@@ -954,7 +970,7 @@ class Deserializer {
         assert(buffer.meta_attribute != nullptr);
 
         ctype_func_selector(buffer.meta_attribute->ctype, [&buffer, &idx, this]<class T> {
-            ValueVisitor<T> visitor{{}, *(reinterpret_cast<T*>(buffer.data) + idx)};
+            ValueVisitor<T> visitor{*(reinterpret_cast<T*>(buffer.data) + idx)};
             msgpack::parse(data_, size_, offset_, visitor);
         });
     }

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/serializer.hpp

@@ -73,13 +73,19 @@ struct MapArray {
     bool begin{true};
 };
 
-struct JsonConverter : msgpack::null_visitor {
+template <typename T> struct NullVisitor : msgpack::null_visitor {
+  private:
+    NullVisitor() = default;
+    friend T; // CRTP compliance
+};
+
+struct JsonConverter : NullVisitor<JsonConverter> {
     static constexpr char sep_char = ' ';
 
     Idx indent{};
     Idx max_indent_level{};
-    std::stringstream ss{};           // NOLINT(readability-redundant-member-init)
-    std::stack<MapArray> map_array{}; // NOLINT(readability-redundant-member-init)
+    std::stringstream ss{};
+    std::stack<MapArray> map_array{};
 
     void print_indent() {
         if (indent < 0) {
@@ -194,6 +200,9 @@ struct JsonConverter : msgpack::null_visitor {
         ss << '}';
         return true;
     }
+
+    JsonConverter(Idx indent_, Idx max_indent_level_)
+        : NullVisitor<JsonConverter>{}, indent{indent_}, max_indent_level{max_indent_level_} {}
 };
 
 } // namespace json_converter
@@ -380,7 +389,7 @@ class Serializer {
     std::string const& get_json(bool use_compact_list, Idx indent) {
         if (json_buffer_.empty() || (use_compact_list_ != use_compact_list) || (json_indent_ != indent)) {
             Idx const max_indent_level = dataset_handler_.is_batch() ? 4 : 3;
-            json_converter::JsonConverter visitor{{}, indent, max_indent_level};
+            json_converter::JsonConverter visitor{indent, max_indent_level};
             auto const msgpack_data = get_msgpack(use_compact_list);
             msgpack::parse(msgpack_data.data(), msgpack_data.size(), visitor);
             json_buffer_ = visitor.ss.str();

power_grid_model_c/power_grid_model/include/power_grid_model/common/exception.hpp

@@ -44,10 +44,9 @@ class InvalidArguments : public PowerGridError {
 
     template <class... Options>
         requires(std::same_as<std::remove_cvref_t<Options>, TypeValuePair> && ...)
-    InvalidArguments(std::string const& method, Options&&... options)
+    InvalidArguments(std::string const& method, Options const&... options)
         : InvalidArguments{method, "the following combination of options"} {
-        (append_msg(" " + std::forward<Options>(options).name + ": " + std::forward<Options>(options).value + "\n"),
-         ...);
+        (append_msg(" " + options.name + ": " + options.value + "\n"), ...);
     }
 };
 

power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp

@@ -132,7 +132,7 @@ class SparseGroupedIdxVector {
         : indptr_{sparse_group_elements.empty() ? IdxVector{0} : std::move(sparse_group_elements)} {
         assert(size() >= 0);
         assert(element_size() >= 0);
-        assert(std::is_sorted(std::begin(indptr_), std::end(indptr_)));
+        assert(std::ranges::is_sorted(indptr_));
     }
     SparseGroupedIdxVector(from_sparse_t /* tag */, IdxVector sparse_group_elements)
         : SparseGroupedIdxVector{std::move(sparse_group_elements)} {}
@@ -154,7 +154,7 @@ class DenseGroupedIdxVector {
         explicit constexpr GroupIterator(IdxVector const& dense_vector, Idx group)
             : dense_vector_{&dense_vector},
               group_{group},
-              group_range_{std::equal_range(std::cbegin(*dense_vector_), std::cend(*dense_vector_), group)} {}
+              group_range_{std::ranges::equal_range(*dense_vector_, group)} {}
 
       private:
         using group_iterator = IdxVector::const_iterator;
@@ -215,7 +215,7 @@ class DenseGroupedIdxVector {
         : num_groups_{num_groups}, dense_vector_{std::move(dense_vector)} {
         assert(size() >= 0);
         assert(element_size() >= 0);
-        assert(std::is_sorted(std::begin(dense_vector_), std::end(dense_vector_)));
+        assert(std::ranges::is_sorted(dense_vector_));
         assert(num_groups_ >= (dense_vector_.empty() ? 0 : dense_vector_.back()));
     }
     DenseGroupedIdxVector(from_sparse_t /* tag */, IdxVector const& sparse_group_elements)

power_grid_model_c/power_grid_model/include/power_grid_model/component/base.hpp

@@ -28,7 +28,7 @@ class Base {
     virtual ~Base() = default;
     constexpr ID id() const noexcept { return id_; }
     constexpr BaseOutput base_output(bool is_energized) const {
-        return BaseOutput{id_, static_cast<IntS>(is_energized)};
+        return BaseOutput{.id = id_, .energized = static_cast<IntS>(is_energized)};
     }
     virtual bool energized(bool is_connected_to_source) const = 0;
 

power_grid_model_c/power_grid_model/include/power_grid_model/component/branch.hpp

@@ -187,7 +187,7 @@ class Branch : public Base {
         assert(update_data.id == this->id() || is_nan(update_data.id));
         bool const changed = set_status(update_data.from_status, update_data.to_status);
         // change branch connection will change both topo and param
-        return {changed, changed};
+        return {.topo = changed, .param = changed};
     }
 
     auto inverse(std::convertible_to<BranchUpdate> auto update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/branch3.hpp

@@ -209,7 +209,7 @@ class Branch3 : public Base {
         assert(update_data.id == this->id() || is_nan(update_data.id));
         bool const changed = set_status(update_data.status_1, update_data.status_2, update_data.status_3);
         // change in branch3 connection will change both topo and param
-        return {changed, changed};
+        return {.topo = changed, .param = changed};
     }
 
     auto inverse(std::convertible_to<Branch3Update> auto update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/component.hpp

@@ -18,7 +18,7 @@ struct UpdateChange {
     bool param{};
 
     friend constexpr UpdateChange operator||(UpdateChange const& x, UpdateChange const& y) {
-        return UpdateChange{x.topo || y.topo, x.param || y.param};
+        return UpdateChange{.topo = x.topo || y.topo, .param = x.param || y.param};
     }
 };
 

power_grid_model_c/power_grid_model/include/power_grid_model/component/current_sensor.hpp

@@ -105,7 +105,7 @@ template <symmetry_tag current_sensor_symmetry_> class CurrentSensor : public Ge
         update_real_value<current_sensor_symmetry>(update_data.i_measured, i_measured_, base_current_inv_);
         update_real_value<current_sensor_symmetry>(update_data.i_angle_measured, i_angle_measured_, 1.0);
 
-        return {false, false};
+        return {.topo = false, .param = false};
     }
 
     CurrentSensorUpdate<current_sensor_symmetry>

power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp

@@ -114,7 +114,7 @@ class Fault final : public Base {
             x_f_ = update.x_f;
         }
         check_sanity();
-        return {false, false}; // topology and parameters do not change
+        return {.topo = false, .param = false}; // topology and parameters do not change
     }
 
     FaultUpdate inverse(FaultUpdate update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/load_gen.hpp

@@ -106,7 +106,7 @@ class LoadGen final : public std::conditional_t<is_generator_v<appliance_type_>,
         this->set_status(update_data.status);
         set_power(update_data.p_specified, update_data.q_specified);
         // change load connection and/or value will not change topology or parameters
-        return {false, false};
+        return {.topo = false, .param = false};
     }
 
     LoadGenUpdate<loadgen_symmetry> inverse(LoadGenUpdate<loadgen_symmetry> update_data) const {
@@ -161,7 +161,7 @@ class LoadGen final : public std::conditional_t<is_generator_v<appliance_type_>,
 
     // scale load
     template <symmetry_tag calculation_symmetry>
-    ComplexValue<calculation_symmetry> scale_power(ComplexValue<calculation_symmetry> u) const {
+    ComplexValue<calculation_symmetry> scale_power(ComplexValue<calculation_symmetry> const& u) const {
         using enum LoadGenType;
 
         auto const params = [this] { return this->template calc_param<calculation_symmetry>(); };
@@ -173,7 +173,9 @@ class LoadGen final : public std::conditional_t<is_generator_v<appliance_type_>,
         case const_i:
             return params() * cabs(u);
         default:
-            throw MissingCaseForEnumError(std::string(this->name) + " power scaling factor", this->type());
+            auto const& load_gen_name =
+                this->name; // NOLINT(readability-static-accessed-through-instance) // for derived class type
+            throw MissingCaseForEnumError(std::string{load_gen_name} + " power scaling factor", this->type());
         }
     }
 };

power_grid_model_c/power_grid_model/include/power_grid_model/component/node.hpp

@@ -26,7 +26,9 @@ class Node final : public Base {
     explicit Node(NodeInput const& node_input) : Base{node_input}, u_rated_{node_input.u_rated} {}
 
     // update node, nothing happens here
-    static constexpr UpdateChange update(BaseUpdate const& /* update_data */) { return {false, false}; }
+    static constexpr UpdateChange update(BaseUpdate const& /* update_data */) {
+        return {.topo = false, .param = false};
+    }
     static constexpr BaseUpdate inverse(BaseUpdate update_data) { return update_data; }
 
     // energized

power_grid_model_c/power_grid_model/include/power_grid_model/component/power_sensor.hpp

@@ -95,7 +95,7 @@ template <symmetry_tag power_sensor_symmetry_> class PowerSensor : public Generi
         update_real_value<power_sensor_symmetry>(update_data.p_sigma, p_sigma_, inv_base_power);
         update_real_value<power_sensor_symmetry>(update_data.q_sigma, q_sigma_, inv_base_power);
 
-        return {false, false};
+        return {.topo = false, .param = false};
     }
 
     PowerSensorUpdate<power_sensor_symmetry> inverse(PowerSensorUpdate<power_sensor_symmetry> update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/shunt.hpp

@@ -51,7 +51,7 @@ class Shunt : public Appliance {
         changed = update_params(update_data) || changed;
 
         // change shunt connection will not change topology, but will change parameters
-        return {false, changed};
+        return {.topo = false, .param = changed};
     }
 
     ShuntUpdate inverse(ShuntUpdate update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp

@@ -93,7 +93,7 @@ class Source : public Appliance {
         bool const param_changed = set_u_ref(update_data.u_ref, update_data.u_ref_angle);
         // change source connection will change both topo and param
         // change u ref will change param
-        return {topo_changed, param_changed || topo_changed};
+        return {.topo = topo_changed, .param = param_changed || topo_changed};
     }
 
     SourceUpdate inverse(SourceUpdate update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/three_winding_transformer.hpp

@@ -105,7 +105,7 @@ class ThreeWindingTransformer : public Branch3 {
     double base_i_2() const final { return base_i_2_; }
     double base_i_3() const final { return base_i_3_; }
     double loading(double s_1, double s_2, double s_3) const final {
-        return std::max(std::max(s_1 / sn_1_, s_2 / sn_2_), s_3 / sn_3_);
+        return std::max({s_1 / sn_1_, s_2 / sn_2_, s_3 / sn_3_});
     }
     // 3-way branch, phase shift = phase_node_x - phase_internal_node
     // the clock_12 and clock_13 is reverted
@@ -133,7 +133,7 @@ class ThreeWindingTransformer : public Branch3 {
         assert(update_data.id == this->id() || is_nan(update_data.id));
         bool const topo_changed = set_status(update_data.status_1, update_data.status_2, update_data.status_3);
         bool const param_changed = set_tap(update_data.tap_pos) || topo_changed;
-        return {topo_changed, param_changed};
+        return {.topo = topo_changed, .param = param_changed};
     }
 
     ThreeWindingTransformerUpdate inverse(ThreeWindingTransformerUpdate update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/transformer.hpp

@@ -97,7 +97,7 @@ class Transformer : public Branch {
         assert(update_data.id == this->id() || is_nan(update_data.id));
         bool const topo_changed = set_status(update_data.from_status, update_data.to_status);
         bool const param_changed = set_tap(update_data.tap_pos) || topo_changed;
-        return {topo_changed, param_changed};
+        return {.topo = topo_changed, .param = param_changed};
     }
 
     TransformerUpdate inverse(TransformerUpdate update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/transformer_tap_regulator.hpp

@@ -41,7 +41,7 @@ class TransformerTapRegulator : public Regulator {
         update_real_value<symmetric_t>(update_data.u_band, u_band_, 1.0);
         update_real_value<symmetric_t>(update_data.line_drop_compensation_r, line_drop_compensation_r_, 1.0);
         update_real_value<symmetric_t>(update_data.line_drop_compensation_x, line_drop_compensation_x_, 1.0);
-        return {false, false};
+        return {.topo = false, .param = false};
     }
 
     TransformerTapRegulatorUpdate inverse(TransformerTapRegulatorUpdate update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/component/voltage_sensor.hpp

@@ -89,7 +89,7 @@ template <symmetry_tag sym> class VoltageSensor : public GenericVoltageSensor {
             u_sigma_ = update_data.u_sigma * inv_u_norm();
         }
 
-        return {false, false};
+        return {.topo = false, .param = false};
     }
 
     VoltageSensorUpdate<sym> inverse(VoltageSensorUpdate<sym> update_data) const {

power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp

@@ -92,7 +92,7 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
         // create object
         vec.emplace_back(std::forward<Args>(args)...);
         // insert idx to map
-        map_[id] = Idx2D{group, pos};
+        map_[id] = Idx2D{.group = group, .pos = pos};
     }
 
     // get item based on Idx2D

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/input.hpp

@@ -23,8 +23,8 @@ constexpr std::array<Branch3Side, 3> const branch3_sides = {Branch3Side::side_1,
 template <std::derived_from<Base> Component, class ComponentContainer,
           forward_iterator_like<typename Component::InputType> ForwardIterator>
     requires model_component_state_c<MainModelState, ComponentContainer, Component>
-inline void add_component(MainModelState<ComponentContainer>& state, ForwardIterator begin, ForwardIterator end,
-                          double system_frequency) {
+inline void add_component(MainModelState<ComponentContainer>& state, ForwardIterator const& begin,
+                          ForwardIterator const& end, double system_frequency) {
     using ComponentView = std::conditional_t<std::same_as<decltype(*begin), typename Component::InputType const&>,
                                              typename Component::InputType const&, typename Component::InputType>;