Merge pull request #926 from PowerGridModel/revert-922-feature/clang-tidy-19

Revert "Support for clang tidy 19"

Author: mgovers

.clang-tidy

@@ -5,7 +5,6 @@
 Checks: '
 -*,
 boost-*,
--boost-use-ranges,
 bugprone-*,
 -bugprone-easily-swappable-parameters,
 -bugprone-exception-escape,
@@ -56,8 +55,6 @@ 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,9 +535,8 @@ 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({.component = &dataset_info_.dataset->get_component(component),
-                                                .elements_per_scenario = elements_per_scenario,
-                                                .total_elements = total_elements});
+        dataset_info_.component_info.push_back(
+            {&dataset_info_.dataset->get_component(component), elements_per_scenario, total_elements});
         buffers_.push_back(Buffer{});
     }
 

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

@@ -186,10 +186,6 @@ 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;
@@ -242,8 +238,6 @@ struct MapArrayVisitor : DefaultErrorVisitor<MapArrayVisitor<map_array>> {
         assert(size == 0);
         return true;
     }
-
-    MapArrayVisitor() = default;
 };
 
 struct StringVisitor : DefaultErrorVisitor<StringVisitor> {
@@ -254,8 +248,6 @@ struct StringVisitor : DefaultErrorVisitor<StringVisitor> {
         str = {v, size};
         return true;
     }
-
-    StringVisitor() = default;
 };
 
 struct BoolVisitor : DefaultErrorVisitor<BoolVisitor> {
@@ -266,8 +258,6 @@ struct BoolVisitor : DefaultErrorVisitor<BoolVisitor> {
         value = v;
         return true;
     }
-
-    BoolVisitor() = default;
 };
 
 template <class T> struct ValueVisitor;
@@ -292,8 +282,6 @@ template <std::integral T> struct ValueVisitor<T> : DefaultErrorVisitor<ValueVis
         value = static_cast<T>(v);
         return true;
     }
-
-    ValueVisitor(T& v) : DefaultErrorVisitor<ValueVisitor<T>>{}, value{v} {}
 };
 
 template <> struct ValueVisitor<double> : DefaultErrorVisitor<ValueVisitor<double>> {
@@ -318,8 +306,6 @@ template <> struct ValueVisitor<double> : DefaultErrorVisitor<ValueVisitor<doubl
         value = v;
         return true;
     }
-
-    ValueVisitor(double& v) : DefaultErrorVisitor<ValueVisitor<double>>{}, value{v} {}
 };
 
 template <> struct ValueVisitor<RealValue<asymmetric_t>> : DefaultErrorVisitor<ValueVisitor<RealValue<asymmetric_t>>> {
@@ -371,8 +357,6 @@ template <> struct ValueVisitor<RealValue<asymmetric_t>> : DefaultErrorVisitor<V
         value[idx] = v;
         return true;
     }
-
-    ValueVisitor(RealValue<asymmetric_t>& v) : DefaultErrorVisitor<ValueVisitor<RealValue<asymmetric_t>>>{}, value{v} {}
 };
 
 } // namespace detail
@@ -675,8 +659,7 @@ class Deserializer {
             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 = component_key_, .size = component_size, .offset = scenario_offset, .has_map = has_map});
+            count_per_scenario.push_back({component_key_, component_size, scenario_offset, has_map});
         }
         component_key_ = {};
         return count_per_scenario;
@@ -725,8 +708,8 @@ class Deserializer {
                 elements_per_scenario * batch_size;                                     // multiply
         handler.add_component_info(component_key_, elements_per_scenario, total_elements);
         // check if all scenarios only contain array data
-        bool const only_values_in_data =
-            std::ranges::none_of(component_byte_meta, [](auto const& x) { return x.has_map; });
+        bool const only_values_in_data = std::none_of(component_byte_meta.cbegin(), component_byte_meta.cend(),
+                                                      [](auto const& x) { return x.has_map; });
         msg_data_offsets_.push_back(std::move(component_byte_meta));
         // enable attribute indications if possible
         if (only_values_in_data) {
@@ -960,7 +943,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);
         });
     }
@@ -971,7 +954,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,19 +73,13 @@ struct MapArray {
     bool begin{true};
 };
 
-template <typename T> struct NullVisitor : msgpack::null_visitor {
-  private:
-    NullVisitor() = default;
-    friend T; // CRTP compliance
-};
-
-struct JsonConverter : NullVisitor<JsonConverter> {
+struct JsonConverter : msgpack::null_visitor {
     static constexpr char sep_char = ' ';
 
     Idx indent{};
     Idx max_indent_level{};
-    std::stringstream ss{};
-    std::stack<MapArray> map_array{};
+    std::stringstream ss{};           // NOLINT(readability-redundant-member-init)
+    std::stack<MapArray> map_array{}; // NOLINT(readability-redundant-member-init)
 
     void print_indent() {
         if (indent < 0) {
@@ -200,9 +194,6 @@ struct JsonConverter : NullVisitor<JsonConverter> {
         ss << '}';
         return true;
     }
-
-    JsonConverter(Idx indent_, Idx max_indent_level_)
-        : NullVisitor<JsonConverter>{}, indent{indent_}, max_indent_level{max_indent_level_} {}
 };
 
 } // namespace json_converter
@@ -389,7 +380,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/common.hpp

@@ -31,7 +31,7 @@ struct Idx2D {
 };
 
 struct Idx2DHash {
-    std::size_t operator()(Idx2D const& idx) const {
+    std::size_t operator()(const Idx2D& idx) const {
         size_t const h1 = std::hash<Idx>{}(idx.group);
         size_t const h2 = std::hash<Idx>{}(idx.pos);
         return h1 ^ (h2 << 1);

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

@@ -8,7 +8,6 @@
 #include "enum.hpp"
 
 #include <exception>
-#include <format>
 #include <sstream>
 #include <string>
 
@@ -24,7 +23,7 @@ inline auto to_string(std::integral auto x) { return std::to_string(x); }
 
 class PowerGridError : public std::exception {
   public:
-    void append_msg(std::string_view msg) { msg_ = std::format("{}{}", msg_, msg); }
+    void append_msg(std::string_view msg) { msg_ += msg; }
     char const* what() const noexcept final { return msg_.c_str(); }
 
   private:
@@ -45,16 +44,17 @@ class InvalidArguments : public PowerGridError {
 
     template <class... Options>
         requires(std::same_as<std::remove_cvref_t<Options>, TypeValuePair> && ...)
-    InvalidArguments(std::string const& method, Options const&... options)
+    InvalidArguments(std::string const& method, Options&&... options)
         : InvalidArguments{method, "the following combination of options"} {
-        (append_msg(" " + options.name + ": " + options.value + "\n"), ...);
+        (append_msg(" " + std::forward<Options>(options).name + ": " + std::forward<Options>(options).value + "\n"),
+         ...);
     }
 };
 
 class MissingCaseForEnumError : public InvalidArguments {
   public:
     template <typename T>
-    MissingCaseForEnumError(std::string const& method, T const& value)
+    MissingCaseForEnumError(std::string const& method, const T& value)
         : InvalidArguments{method, std::string{typeid(T).name()} + " #" + detail::to_string(static_cast<IntS>(value))} {
     }
 };
@@ -292,7 +292,7 @@ class UnreachableHit : public PowerGridError {
 class TapSearchStrategyIncompatibleError : public InvalidArguments {
   public:
     template <typename T1, typename T2>
-    TapSearchStrategyIncompatibleError(std::string const& method, T1 const& value1, T2 const& value2)
+    TapSearchStrategyIncompatibleError(std::string const& method, const T1& value1, const T2& value2)
         : InvalidArguments{
               method, std::string{typeid(T1).name()} + " #" + detail::to_string(static_cast<IntS>(value1)) + " and " +
                           std::string{typeid(T2).name()} + " #" + detail::to_string(static_cast<IntS>(value2))} {}

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::ranges::is_sorted(indptr_));
+        assert(std::is_sorted(std::begin(indptr_), std::end(indptr_)));
     }
     SparseGroupedIdxVector(from_sparse_t /* tag */, IdxVector sparse_group_elements)
         : SparseGroupedIdxVector{std::move(sparse_group_elements)} {}
@@ -154,44 +154,46 @@ class DenseGroupedIdxVector {
         explicit constexpr GroupIterator(IdxVector const& dense_vector, Idx group)
             : dense_vector_{&dense_vector},
               group_{group},
-              group_range_{std::ranges::equal_range(*dense_vector_, group)} {}
+              group_range_{std::equal_range(std::cbegin(*dense_vector_), std::cend(*dense_vector_), group)} {}
 
       private:
         using group_iterator = IdxVector::const_iterator;
 
         IdxVector const* dense_vector_{};
         Idx group_{};
-        std::ranges::subrange<group_iterator> group_range_;
+        std::pair<group_iterator, group_iterator> group_range_;
 
         friend class boost::iterator_core_access;
 
         auto dereference() const -> iterator {
             assert(dense_vector_ != nullptr);
             return boost::counting_range(
-                narrow_cast<Idx>(std::distance(std::cbegin(*dense_vector_), group_range_.begin())),
-                narrow_cast<Idx>(std::distance(std::cbegin(*dense_vector_), group_range_.end())));
+                narrow_cast<Idx>(std::distance(std::cbegin(*dense_vector_), group_range_.first)),
+                narrow_cast<Idx>(std::distance(std::cbegin(*dense_vector_), group_range_.second)));
         }
         constexpr auto equal(GroupIterator const& other) const { return group_ == other.group_; }
         constexpr auto distance_to(GroupIterator const& other) const { return other.group_ - group_; }
 
         constexpr void increment() {
             ++group_;
-            group_range_ = {group_range_.end(), std::find_if(group_range_.end(), std::cend(*dense_vector_),
-                                                             [group = group_](Idx value) { return value > group; })};
+            group_range_ = std::make_pair(group_range_.second,
+                                          std::find_if(group_range_.second, std::cend(*dense_vector_),
+                                                       [group = group_](Idx value) { return value > group; }));
         }
         constexpr void decrement() {
             --group_;
-            group_range_ = {std::find_if(std::make_reverse_iterator(group_range_.begin()), std::crend(*dense_vector_),
-                                         [group = group_](Idx value) { return value < group; })
-                                .base(),
-                            group_range_.begin()};
+            group_range_ =
+                std::make_pair(std::find_if(std::make_reverse_iterator(group_range_.first), std::crend(*dense_vector_),
+                                            [group = group_](Idx value) { return value < group; })
+                                   .base(),
+                               group_range_.first);
         }
         constexpr void advance(Idx n) {
-            auto const start = n > 0 ? group_range_.end() : std::cbegin(*dense_vector_);
-            auto const stop = n < 0 ? group_range_.begin() : std::cend(*dense_vector_);
+            auto const start = n > 0 ? group_range_.second : std::cbegin(*dense_vector_);
+            auto const stop = n < 0 ? group_range_.first : std::cend(*dense_vector_);
 
             group_ += n;
-            group_range_ = std::ranges::equal_range(std::ranges::subrange{start, stop}, group_);
+            group_range_ = std::equal_range(start, stop, group_);
         }
     };
 
@@ -213,7 +215,7 @@ class DenseGroupedIdxVector {
         : num_groups_{num_groups}, dense_vector_{std::move(dense_vector)} {
         assert(size() >= 0);
         assert(element_size() >= 0);
-        assert(std::ranges::is_sorted(dense_vector_));
+        assert(std::is_sorted(std::begin(dense_vector_), std::end(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/common/three_phase_tensor.hpp

@@ -238,7 +238,7 @@ template <column_vector DerivedA> inline auto mean_val(Eigen::ArrayBase<DerivedA
 inline DoubleComplex mean_val(DoubleComplex const& z) { return z; }
 inline double mean_val(double z) { return z; }
 
-template <symmetry_tag sym, class T> inline auto process_mean_val(T const& m) {
+template <symmetry_tag sym, class T> inline auto process_mean_val(const T& m) {
     if constexpr (is_symmetric_v<sym>) {
         return mean_val(m);
     } else {
@@ -348,7 +348,9 @@ inline auto all_zero(RealValue<asymmetric_t> const& value) { return (value == Re
 //
 // The function assumes that the current value is normalized and new value should be normalized with scalar
 template <symmetry_tag sym, class Proxy>
-inline void update_real_value(RealValue<sym> const& new_value, Proxy&& current_value, double scalar) {
+inline void
+update_real_value(RealValue<sym> const& new_value, Proxy&& current_value,
+                  double scalar) { // NOLINT(cppcoreguidelines-missing-std-forward) // perfect forward into void
     if constexpr (is_symmetric_v<sym>) {
         if (!is_nan(new_value)) {
             std::forward<Proxy>(current_value) = scalar * new_value;

power_grid_model_c/power_grid_model/include/power_grid_model/common/timer.hpp

@@ -29,9 +29,9 @@ class Timer {
     Timer(CalculationInfo& info, int code, std::string name)
         : info_(&info), code_(code), name_(std::move(name)), start_(Clock::now()) {}
 
-    Timer(Timer const&) = delete;
+    Timer(const Timer&) = delete;
     Timer(Timer&&) = default;
-    Timer& operator=(Timer const&) = delete;
+    Timer& operator=(const Timer&) = delete;
 
     Timer& operator=(Timer&& timer) noexcept {
         // Stop the current timer

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

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