Merge branch 'main' into feature/state-queries-to-container-queries

Author: mgovers

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

@@ -116,7 +116,7 @@ template <typename T> constexpr T map_to_cyclic_range(T value, T period) {
     if constexpr (std::is_integral_v<T>) {
         return static_cast<T>((value % period + period) % period);
     } else {
-        if (std::is_constant_evaluated()) {
+        if consteval {
             T quotient = value / period;
             Idx const floored_quotient =
                 (quotient >= T{0}) ? static_cast<Idx>(quotient) : static_cast<Idx>(quotient) - 1;

power_grid_model_c/power_grid_model/include/power_grid_model/common/multi_threaded_logging.hpp

@@ -20,10 +20,23 @@ class MultiThreadedLoggerImpl : public MultiThreadedLogger {
     class ThreadLogger : public LoggerType {
       public:
         ThreadLogger(MultiThreadedLoggerImpl& parent) : parent_{&parent} {}
-        ThreadLogger(ThreadLogger const&) = default;
-        ThreadLogger& operator=(ThreadLogger const&) = default;
-        ThreadLogger(ThreadLogger&&) noexcept = default;
-        ThreadLogger& operator=(ThreadLogger&&) noexcept = default;
+        ThreadLogger(ThreadLogger const& other) : LoggerType{other}, parent_{other.parent_} {};
+        ThreadLogger& operator=(ThreadLogger const& other) {
+            if (this != &other) {
+                LoggerType::operator=(other);
+                parent_ = other.parent_;
+            }
+            return *this;
+        };
+        ThreadLogger(ThreadLogger&& other) noexcept
+            : LoggerType{std::move(static_cast<LoggerType>(other))}, parent_{other.parent_} {};
+        ThreadLogger& operator=(ThreadLogger&& other) noexcept {
+            if (this != &other) {
+                parent_ = std::exchange(other.parent_, nullptr);
+                LoggerType::operator=(std::move(other));
+            }
+            return *this;
+        };
         ~ThreadLogger() noexcept override {
             try {
                 sync();

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

@@ -26,7 +26,8 @@ class Timer {
     Timer(Logger& log, LogEvent code) : log_{&log}, code_{code}, start_{Clock::now()} {}
 
     Timer(Timer const&) = delete;
-    Timer(Timer&&) = default;
+    Timer(Timer&& other) noexcept
+        : log_{std::exchange(other.log_, nullptr)}, code_{other.code_}, start_{other.start_} {}
     Timer& operator=(Timer const&) = delete;
 
     Timer& operator=(Timer&& timer) noexcept {

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/main_model_type.hpp

@@ -33,12 +33,43 @@ constexpr auto filter_tuple_types(std::tuple<std::type_identity<Types>...> /*unu
                                              std::tuple<std::type_identity<Types>>, std::tuple<>>{}...);
 }
 
+template <typename List, typename T, typename... NeedsTypes>
+concept dependent_type_check = !IsInList<T, List>::value || (IsInList<NeedsTypes, List>::value && ...);
+
+template <typename CompList>
+concept validate_component_types_c =
+    dependent_type_check<CompList, Source, Node> &&                  //
+    dependent_type_check<CompList, Line, Node> &&                    //
+    dependent_type_check<CompList, Link, Node> &&                    //
+    dependent_type_check<CompList, Transformer, Node> &&             //
+    dependent_type_check<CompList, GenericBranch, Node> &&           //
+    dependent_type_check<CompList, AsymLine, Node> &&                //
+    dependent_type_check<CompList, ThreeWindingTransformer, Node> && //
+    dependent_type_check<CompList, Shunt, Node> &&                   //
+    dependent_type_check<CompList, SymGenerator, Node> &&            //
+    dependent_type_check<CompList, AsymGenerator, Node> &&           //
+    dependent_type_check<CompList, SymLoad, Node> &&                 //
+    dependent_type_check<CompList, AsymLoad, Node> &&                //
+    dependent_type_check<CompList, SymVoltageSensor, Node> &&        //
+    dependent_type_check<CompList, AsymVoltageSensor, Node> &&       //
+    dependent_type_check<CompList, SymPowerSensor, Node, Line, AsymLine, GenericBranch, Transformer,
+                         ThreeWindingTransformer, SymGenerator, AsymGenerator, SymLoad, AsymLoad> && //
+    dependent_type_check<CompList, AsymPowerSensor, Node, Line, AsymLine, Link, GenericBranch, Transformer,
+                         ThreeWindingTransformer, SymGenerator, AsymGenerator, SymLoad, AsymLoad> && //
+    dependent_type_check<CompList, SymCurrentSensor, Line, AsymLine, Link, GenericBranch, Transformer,
+                         ThreeWindingTransformer> && //
+    dependent_type_check<CompList, AsymCurrentSensor, Line, AsymLine, Link, GenericBranch, Transformer,
+                         ThreeWindingTransformer> &&                                                       //
+    dependent_type_check<CompList, TransformerTapRegulator, Node, Transformer, ThreeWindingTransformer> && //
+    dependent_type_check<CompList, Fault, Node>;
+
 } // namespace detail
 
 template <class T, class U> class MainModelType;
 
 // TODO: discussion on checking dependent types can also be done here.
 template <class... ExtraRetrievableType, class... ComponentType>
+    requires detail::validate_component_types_c<ComponentList<ComponentType...>>
 class MainModelType<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentList<ComponentType...>> {
 
   public:

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp

@@ -208,7 +208,7 @@ constexpr void register_connections_components(ComponentContainer const& compone
 } // namespace detail
 
 template <typename ModelType>
-    requires common::component_container_c<typename ModelType::ComponentContainer, Branch, Branch3, Source, Shunt,
+    requires common::component_container_c<typename ModelType::ComponentContainer, Node, Branch, Branch3, Source, Shunt,
                                            GenericLoadGen, GenericVoltageSensor, GenericPowerSensor,
                                            GenericCurrentSensor, Regulator>
 ComponentTopology construct_topology(typename ModelType::ComponentContainer const& components) {

tests/cpp_unit_tests/test_main_model_type.cpp

@@ -5,6 +5,7 @@
 #include <power_grid_model/container.hpp>
 #include <power_grid_model/main_core/core_utils.hpp>
 #include <power_grid_model/main_core/main_model_type.hpp>
+#include <power_grid_model/math_solver/math_solver_dispatch.hpp>
 
 #include <doctest/doctest.h>
 
@@ -17,6 +18,16 @@ struct AComponent {
 };
 } // namespace
 
+static_assert(detail::validate_component_types_c<AllComponents>);
+
+static_assert(detail::validate_component_types_c<ComponentList<Node, Source>>);
+static_assert(detail::validate_component_types_c<ComponentList<Node, Line>>);
+static_assert(detail::validate_component_types_c<ComponentList<Node, Line, AComponent>>);
+static_assert(detail::validate_component_types_c<ComponentList<Source, Node>>);
+
+static_assert(!detail::validate_component_types_c<ComponentList<Line>>);
+static_assert(!detail::validate_component_types_c<ComponentList<Source, Line>>);
+
 TEST_CASE("MainModelType") {
 
     SUBCASE("Node Source") {
@@ -44,8 +55,6 @@ TEST_CASE("MainModelType") {
         utils::run_functor_with_tuple_return_void<typename ModelType::TopologyTypesTuple>(
             [&calls]<typename CompType>() { calls.push_back(std::string_view(CompType::name)); });
         CHECK(calls == std::vector<std::string_view>{"node", "source"});
-
-        // static_assert(is_constructible_v<MainModelImpl<ModelType>>);
     }
     SUBCASE("Node Line Source") {
         using ModelType =
@@ -136,18 +145,6 @@ TEST_CASE("MainModelType") {
         CHECK(calls == std::vector<std::string_view>{"node", "source"});
     }
 
-    SUBCASE("Bad case: Line Source") {
-        // TODO rewrite for checking fail instead of pass
-        using ModelType = MainModelType<ExtraRetrievableTypes<Base, Branch, Appliance>, ComponentList<Line, Source>>;
-
-        static_assert(std::is_same_v<typename ModelType::ComponentContainer,
-                                     Container<ExtraRetrievableTypes<Base, Branch, Appliance>, Line, Source>>);
-        static_assert(std::is_same_v<typename ModelType::ComponentTypesTuple, std::tuple<Line, Source>>);
-        static_assert(std::is_same_v<typename ModelType::TopologyTypesTuple, std::tuple<Branch, Source>>);
-        static_assert(std::is_same_v<typename ModelType::TopologyConnectionTypesTuple, std::tuple<Branch, Source>>);
-        static_assert(ModelType::n_types == 2);
-    }
-
     // TODO add static_assert(std::constructible_from<ModelType, double, meta_data::MetaData const&,
     // MathSolverDispatcher const&>);
 }