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};
     }
 };