Merge remote-tracking branch 'origin/feature/use-std-views' into feature/clang-tidy-19

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

Author: mgovers

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

@@ -40,74 +40,77 @@ class InvalidArguments : public PowerGridError {
 
     template <std::same_as<TypeValuePair>... Options>
     InvalidArguments(std::string const& method, std::string const& arguments) {
-        append_msg(method + " is not implemented for " + arguments + "!\n");
+        append_msg(std::format("{} is not implemented for {}!\n", method, arguments));
     }
 
     template <class... Options>
         requires(std::same_as<std::remove_cvref_t<Options>, TypeValuePair> && ...)
     InvalidArguments(std::string const& method, Options const&... options)
         : InvalidArguments{method, "the following combination of options"} {
-        (append_msg(" " + options.name + ": " + options.value + "\n"), ...);
+        (append_msg(std::format(" {}: {}\n", options.name, options.value)), ...);
     }
 };
 
 class MissingCaseForEnumError : public InvalidArguments {
   public:
     template <typename T>
     MissingCaseForEnumError(std::string const& method, T const& value)
-        : InvalidArguments{method, std::string{typeid(T).name()} + " #" + detail::to_string(static_cast<IntS>(value))} {
-    }
+        : InvalidArguments{method,
+                           std::format("{} #{}", typeid(T).name(), detail::to_string(static_cast<IntS>(value)))} {}
 };
 
 class ConflictVoltage : public PowerGridError {
   public:
     ConflictVoltage(ID id, ID id1, ID id2, double u1, double u2) {
-        append_msg("Conflicting voltage for line " + detail::to_string(id) + "\n voltage at from node " +
-                   detail::to_string(id1) + " is " + detail::to_string(u1) + "\n voltage at to node " +
-                   detail::to_string(id2) + " is " + detail::to_string(u2) + '\n');
+        append_msg(std::format(
+            "Conflicting voltage for line {}\n voltage at from node {} is {}\n voltage at to node {} is {}\n",
+            detail::to_string(id), detail::to_string(id1), detail::to_string(u1), detail::to_string(id2),
+            detail::to_string(u2)));
     }
 };
 
 class InvalidBranch : public PowerGridError {
   public:
     InvalidBranch(ID branch_id, ID node_id) {
-        append_msg("Branch " + detail::to_string(branch_id) + " has the same from- and to-node " +
-                   detail::to_string(node_id) + ",\n This is not allowed!\n");
+        append_msg(std::format("Branch {} has the same from- and to-node {},\n This is not allowed!\n",
+                               detail::to_string(branch_id), detail::to_string(node_id)));
     }
 };
 
 class InvalidBranch3 : public PowerGridError {
   public:
     InvalidBranch3(ID branch3_id, ID node_1_id, ID node_2_id, ID node_3_id) {
-        append_msg("Branch3 " + detail::to_string(branch3_id) +
-                   " is connected to the same node at least twice. Node 1/2/3: " + detail::to_string(node_1_id) + "/" +
-                   detail::to_string(node_2_id) + "/" + detail::to_string(node_3_id) + ",\n This is not allowed!\n");
+        append_msg(std::format(
+            "Branch3 {} is connected to the same node at least twice. Node 1/2/3: {}/{}/{},\n This is not allowed!\n",
+            detail::to_string(branch3_id), detail::to_string(node_1_id), detail::to_string(node_2_id),
+            detail::to_string(node_3_id)));
     }
 };
 
 class InvalidTransformerClock : public PowerGridError {
   public:
     InvalidTransformerClock(ID id, IntS clock) {
-        append_msg("Invalid clock for transformer " + detail::to_string(id) + ", clock " + detail::to_string(clock) +
-                   '\n');
+        append_msg(std::format("Invalid clock for transformer {}, clock {}\n", detail::to_string(id),
+                               detail::to_string(clock)));
     }
 };
 
 class SparseMatrixError : public PowerGridError {
   public:
     SparseMatrixError(Idx err, std::string const& msg = "") {
-        append_msg("Sparse matrix error with error code #" + detail::to_string(err) + " (possibly singular)\n");
+        append_msg(
+            std::format("Sparse matrix error with error code #{} (possibly singular)\n", detail::to_string(err)));
         if (!msg.empty()) {
-            append_msg(msg + "\n");
+            append_msg(std::format("{}\n", msg));
         }
         append_msg("If you get this error from state estimation, ");
         append_msg("it usually means the system is not fully observable, i.e. not enough measurements.");
     }
     SparseMatrixError() {
-        append_msg("Sparse matrix error, possibly singular matrix!\n" +
-                   std::string("If you get this error from state estimation, ") +
-                   "it might mean the system is not fully observable, i.e. not enough measurements.\n" +
-                   "It might also mean that you are running into a corner case where PGM cannot resolve yet." +
+        append_msg("Sparse matrix error, possibly singular matrix!\n"
+                   "If you get this error from state estimation, "
+                   "it might mean the system is not fully observable, i.e. not enough measurements.\n"
+                   "It might also mean that you are running into a corner case where PGM cannot resolve yet."
                    "See https://github.com/PowerGridModel/power-grid-model/issues/864.");
     }
 };
@@ -117,7 +120,7 @@ class NotObservableError : public PowerGridError {
     NotObservableError(std::string const& msg = "") {
         append_msg("Not enough measurements available for state estimation.\n");
         if (!msg.empty()) {
-            append_msg(msg + "\n");
+            append_msg(std::format("{}\n", msg));
         }
     }
 };
@@ -126,58 +129,59 @@ class IterationDiverge : public PowerGridError {
   public:
     IterationDiverge() = default;
     IterationDiverge(Idx num_iter, double max_dev, double err_tol) {
-        append_msg("Iteration failed to converge after " + detail::to_string(num_iter) +
-                   " iterations! Max deviation: " + detail::to_string(max_dev) +
-                   ", error tolerance: " + detail::to_string(err_tol) + ".\n");
+        append_msg(
+            std::format("Iteration failed to converge after {} iterations! Max deviation: {}, error tolerance: {}.\n",
+                        detail::to_string(num_iter), detail::to_string(max_dev), detail::to_string(err_tol)));
     }
 };
 
 class MaxIterationReached : public IterationDiverge {
   public:
     MaxIterationReached(std::string const& msg = "") {
-        append_msg("Maximum number of iterations reached" + msg + "\n");
+        append_msg(std::format("Maximum number of iterations reached{}\n", msg));
     }
 };
 
 class ConflictID : public PowerGridError {
   public:
-    explicit ConflictID(ID id) { append_msg("Conflicting id detected: " + detail::to_string(id) + '\n'); }
+    explicit ConflictID(ID id) { append_msg(std::format("Conflicting id detected: {}\n", detail::to_string(id))); }
 };
 
 class IDNotFound : public PowerGridError {
   public:
-    explicit IDNotFound(ID id) { append_msg("The id cannot be found: " + detail::to_string(id) + '\n'); }
+    explicit IDNotFound(ID id) { append_msg(std::format("The id cannot be found: {}\n", detail::to_string(id))); }
 };
 class Idx2DNotFound : public PowerGridError {
   public:
     explicit Idx2DNotFound(Idx2D id) {
-        append_msg("The idx 2d cannot be found: {" + detail::to_string(id.group) + ", " + detail::to_string(id.pos) +
-                   "}.\n");
+        append_msg(std::format("The idx 2d cannot be found: {{{}, {}}}.\n", detail::to_string(id.group),
+                               detail::to_string(id.pos)));
     }
 };
 
 class InvalidMeasuredObject : public PowerGridError {
   public:
     InvalidMeasuredObject(std::string const& object, std::string const& sensor) {
-        append_msg(sensor + " measurement is not supported for object of type " + object);
+        append_msg(std::format("{} measurement is not supported for object of type {}", sensor, object));
     }
 };
 
 class InvalidMeasuredTerminalType : public PowerGridError {
   public:
     InvalidMeasuredTerminalType(MeasuredTerminalType const terminal_type, std::string const& sensor) {
-        append_msg(sensor + " measurement is not supported for object of type " +
-                   detail::to_string(static_cast<IntS>(terminal_type)));
+        append_msg(std::format("{} measurement is not supported for object of type {}", sensor,
+                               detail::to_string(static_cast<IntS>(terminal_type))));
     }
 };
 
 class InvalidRegulatedObject : public PowerGridError {
   public:
     InvalidRegulatedObject(std::string const& object, std::string const& regulator) {
-        append_msg(regulator + " regulator is not supported for object of type " + object);
+        append_msg(std::format("{} regulator is not supported for object of type {}", regulator, object));
     }
     InvalidRegulatedObject(ID id, std::string const& regulator) {
-        append_msg(regulator + " regulator is not supported for object with ID " + detail::to_string(id));
+        append_msg(
+            std::format("{} regulator is not supported for object with ID {}", regulator, detail::to_string(id)));
     }
 };
 
@@ -191,8 +195,9 @@ class DuplicativelyRegulatedObject : public PowerGridError {
 class AutomaticTapCalculationError : public PowerGridError {
   public:
     AutomaticTapCalculationError(ID id) {
-        append_msg("Automatic tap changing regulator with tap_side at LV side is not supported. Found at id " +
-                   detail::to_string(id)); // NOSONAR
+        append_msg(
+            std::format("Automatic tap changing regulator with tap_side at LV side is not supported. Found at id {}",
+                        detail::to_string(id)));
     }
 };
 
@@ -205,7 +210,9 @@ class AutomaticTapInputError : public PowerGridError {
 
 class IDWrongType : public PowerGridError {
   public:
-    explicit IDWrongType(ID id) { append_msg("Wrong type for object with id " + detail::to_string(id) + '\n'); }
+    explicit IDWrongType(ID id) {
+        append_msg(std::format("Wrong type for object with id {}\n", detail::to_string(id)));
+    }
 };
 
 class CalculationError : public PowerGridError {
@@ -235,22 +242,22 @@ class InvalidCalculationMethod : public CalculationError {
 class InvalidShortCircuitType : public PowerGridError {
   public:
     explicit InvalidShortCircuitType(FaultType short_circuit_type) {
-        append_msg("The short circuit type (" + detail::to_string(static_cast<IntS>(short_circuit_type)) +
-                   ") is invalid!\n");
+        append_msg(std::format("The short circuit type ({}) is invalid!\n",
+                               detail::to_string(static_cast<IntS>(short_circuit_type))));
     }
     InvalidShortCircuitType(bool sym, FaultType short_circuit_type) {
-        append_msg("The short circuit type (" + detail::to_string(static_cast<IntS>(short_circuit_type)) +
-                   ") does not match the calculation type (symmetric=" + detail::to_string(static_cast<int>(sym)) +
-                   ")\n");
+        append_msg(std::format("The short circuit type ({}) does not match the calculation type (symmetric={})\n",
+                               detail::to_string(static_cast<IntS>(short_circuit_type)),
+                               detail::to_string(static_cast<int>(sym))));
     }
 };
 
 class InvalidShortCircuitPhases : public PowerGridError {
   public:
     InvalidShortCircuitPhases(FaultType short_circuit_type, FaultPhase short_circuit_phases) {
-        append_msg("The short circuit phases (" + detail::to_string(static_cast<IntS>(short_circuit_phases)) +
-                   ") do not match the short circuit type (" +
-                   detail::to_string(static_cast<IntS>(short_circuit_type)) + ")\n");
+        append_msg(std::format("The short circuit phases ({}) do not match the short circuit type ({})\n",
+                               detail::to_string(static_cast<IntS>(short_circuit_phases)),
+                               detail::to_string(static_cast<IntS>(short_circuit_type))));
     }
 };
 
@@ -268,7 +275,7 @@ class SerializationError : public PowerGridError {
 
 class DatasetError : public PowerGridError {
   public:
-    explicit DatasetError(std::string const& msg) { append_msg("Dataset error: " + msg); }
+    explicit DatasetError(std::string const& msg) { append_msg(std::format("Dataset error: {}", msg)); }
 };
 
 class ExperimentalFeature : public InvalidArguments {
@@ -283,19 +290,19 @@ class NotImplementedError : public PowerGridError {
 class UnreachableHit : public PowerGridError {
   public:
     UnreachableHit(std::string const& method, std::string const& reason_for_assumption) {
-        append_msg("Unreachable code hit when executing " + method +
-                   ".\n The following assumption for unreachability was not met: " + reason_for_assumption +
-                   ".\n This may be a bug in the library\n");
+        append_msg(std::format("Unreachable code hit when executing {}.\n The following assumption for unreachability "
+                               "was not met: {}.\n This may be a bug in the library\n",
+                               method, reason_for_assumption));
     }
 };
 
 class TapSearchStrategyIncompatibleError : public InvalidArguments {
   public:
     template <typename T1, typename T2>
     TapSearchStrategyIncompatibleError(std::string const& method, T1 const& value1, T2 const& 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))} {}
+        : InvalidArguments{method, std::format("{} #{} and {} #{}", typeid(T1).name(),
+                                               detail::to_string(static_cast<IntS>(value1)), typeid(T2).name(),
+                                               detail::to_string(static_cast<IntS>(value2)))} {}
 };
 
 } // namespace power_grid_model