shift to component container

Signed-off-by: Nitish Bharambe <[email protected]>

Author: nitbharambe

power_grid_model_c/power_grid_model/include/power_grid_model/main_core/state.hpp

@@ -44,6 +44,9 @@ concept extended_component_container_c =
         { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
     };
 
+template <typename ContainerType, typename... ComponentType>
+concept multi_extended_component_container_c = (extended_component_container_c<ContainerType, ComponentType> && ...);
+
 template <template <typename T> class StateType, typename ContainerType, typename ComponentType>
 concept model_component_state_c =
     component_container_c<typename StateType<ContainerType>::ComponentContainer, ComponentType> &&

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

@@ -14,13 +14,13 @@ namespace power_grid_model::main_core {
 namespace detail {
 
 template <typename Component, class ComponentContainer, typename ResType, typename ResFunc>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component> &&
+    requires component_container_c<ComponentContainer, Component> &&
              std::invocable<std::remove_cvref_t<ResFunc>, Component const&> &&
              std::convertible_to<std::invoke_result_t<ResFunc, Component const&>, ResType>
-constexpr void register_topo_components(MainModelState<ComponentContainer> const& state, std::vector<ResType>& target,
+constexpr void register_topo_components(ComponentContainer const& components, std::vector<ResType>& target,
                                         ResFunc&& func) {
-    auto const begin = get_component_citer<Component>(state).begin();
-    auto const end = get_component_citer<Component>(state).end();
+    auto const begin = components.template citer<Component>().begin();
+    auto const end = components.template citer<Component>().end();
 
     target.resize(std::distance(begin, end));
     std::transform(begin, end, target.begin(), std::forward<ResFunc>(func));
@@ -29,80 +29,75 @@ constexpr void register_topo_components(MainModelState<ComponentContainer> const
 } // namespace detail
 
 template <std::same_as<Node> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    comp_topo.n_node = get_component_size<Node>(state.components);
+    requires component_container_c<ComponentContainer, Component>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    comp_topo.n_node = get_component_size<Node>(components);
 }
 
 template <std::same_as<Branch> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.branch_node_idx, [&state](Branch const& branch) {
-        return BranchIdx{get_component_sequence_idx<Node>(state.components, branch.from_node()),
-                         get_component_sequence_idx<Node>(state.components, branch.to_node())};
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.branch_node_idx, [&components](Branch const& branch) {
+            return BranchIdx{get_component_sequence_idx<Node>(components, branch.from_node()),
+                             get_component_sequence_idx<Node>(components, branch.to_node())};
+        });
 }
 
 template <std::same_as<Branch3> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.branch3_node_idx, [&state](Branch3 const& branch3) {
-        return Branch3Idx{get_component_sequence_idx<Node>(state.components, branch3.node_1()),
-                          get_component_sequence_idx<Node>(state.components, branch3.node_2()),
-                          get_component_sequence_idx<Node>(state.components, branch3.node_3())};
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.branch3_node_idx, [&components](Branch3 const& branch3) {
+            return Branch3Idx{get_component_sequence_idx<Node>(components, branch3.node_1()),
+                              get_component_sequence_idx<Node>(components, branch3.node_2()),
+                              get_component_sequence_idx<Node>(components, branch3.node_3())};
+        });
 }
 
 template <std::same_as<Source> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.source_node_idx, [&state](Source const& source) {
-        return get_component_sequence_idx<Node>(state.components, source.node());
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.source_node_idx,
+        [&components](Source const& source) { return get_component_sequence_idx<Node>(components, source.node()); });
 }
 
 template <std::same_as<Shunt> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
-    detail::register_topo_components<Component>(state, comp_topo.shunt_node_idx, [&state](Shunt const& shunt) {
-        return get_component_sequence_idx<Node>(state.components, shunt.node());
-    });
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
+    detail::register_topo_components<Component>(
+        components, comp_topo.shunt_node_idx,
+        [&components](Shunt const& shunt) { return get_component_sequence_idx<Node>(components, shunt.node()); });
 }
 
 template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.load_gen_node_idx, [&state](GenericLoadGen const& load_gen) {
-            return get_component_sequence_idx<Node>(state.components, load_gen.node());
+        components, comp_topo.load_gen_node_idx, [&components](GenericLoadGen const& load_gen) {
+            return get_component_sequence_idx<Node>(components, load_gen.node());
         });
 
-    detail::register_topo_components<Component>(state, comp_topo.load_gen_type,
+    detail::register_topo_components<Component>(components, comp_topo.load_gen_type,
                                                 [](GenericLoadGen const& load_gen) { return load_gen.type(); });
 }
 
 template <std::same_as<GenericVoltageSensor> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.voltage_sensor_node_idx, [&state](GenericVoltageSensor const& voltage_sensor) {
-            return get_component_sequence_idx<Node>(state.components, voltage_sensor.measured_object());
+        components, comp_topo.voltage_sensor_node_idx, [&components](GenericVoltageSensor const& voltage_sensor) {
+            return get_component_sequence_idx<Node>(components, voltage_sensor.measured_object());
         });
 }
 
 template <std::same_as<GenericPowerSensor> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Source, Shunt, GenericLoadGen,
+                                                  Branch3, Node>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.power_sensor_object_idx, [&state](GenericPowerSensor const& power_sensor) {
+        components, comp_topo.power_sensor_object_idx, [&components](GenericPowerSensor const& power_sensor) {
             using enum MeasuredTerminalType;
 
             auto const measured_object = power_sensor.measured_object();
@@ -111,40 +106,39 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state.components, measured_object);
+                return get_component_sequence_idx<Branch>(components, measured_object);
             case source:
-                return get_component_sequence_idx<Source>(state.components, measured_object);
+                return get_component_sequence_idx<Source>(components, measured_object);
             case shunt:
-                return get_component_sequence_idx<Shunt>(state.components, measured_object);
+                return get_component_sequence_idx<Shunt>(components, measured_object);
             case load:
                 [[fallthrough]];
             case generator:
-                return get_component_sequence_idx<GenericLoadGen>(state.components, measured_object);
+                return get_component_sequence_idx<GenericLoadGen>(components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state.components, measured_object);
+                return get_component_sequence_idx<Branch3>(components, measured_object);
             case node:
-                return get_component_sequence_idx<Node>(state.components, measured_object);
+                return get_component_sequence_idx<Node>(components, measured_object);
             default:
                 throw MissingCaseForEnumError("Power sensor idx to seq transformation",
                                               power_sensor.get_terminal_type());
             }
         });
 
     detail::register_topo_components<Component>(
-        state, comp_topo.power_sensor_terminal_type,
+        components, comp_topo.power_sensor_terminal_type,
         [](GenericPowerSensor const& power_sensor) { return power_sensor.get_terminal_type(); });
 }
 
 template <std::same_as<GenericCurrentSensor> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.current_sensor_object_idx, [&state](GenericCurrentSensor const& current_sensor) {
+        components, comp_topo.current_sensor_object_idx, [&components](GenericCurrentSensor const& current_sensor) {
             using enum MeasuredTerminalType;
 
             auto const measured_object = current_sensor.measured_object();
@@ -153,57 +147,56 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state.components, measured_object);
+                return get_component_sequence_idx<Branch>(components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state.components, measured_object);
+                return get_component_sequence_idx<Branch3>(components, measured_object);
             default:
                 throw MissingCaseForEnumError("Current sensor idx to seq transformation",
                                               current_sensor.get_terminal_type());
             }
         });
 
     detail::register_topo_components<Component>(
-        state, comp_topo.current_sensor_terminal_type,
+        components, comp_topo.current_sensor_terminal_type,
         [](GenericCurrentSensor const& current_sensor) { return current_sensor.get_terminal_type(); });
 }
 
 template <std::derived_from<Regulator> Component, class ComponentContainer>
-    requires model_component_state_c<MainModelState, ComponentContainer, Component>
-constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
-                                            ComponentTopology& comp_topo) {
+    requires multi_extended_component_container_c<ComponentContainer, Component, Branch, Branch3>
+constexpr void register_topology_components(ComponentContainer const& components, ComponentTopology& comp_topo) {
     detail::register_topo_components<Component>(
-        state, comp_topo.regulated_object_idx, [&state](Regulator const& regulator) {
+        components, comp_topo.regulated_object_idx, [&components](Regulator const& regulator) {
             switch (regulator.regulated_object_type()) {
             case ComponentType::branch:
-                return get_component_sequence_idx<Branch>(state.components, regulator.regulated_object());
+                return get_component_sequence_idx<Branch>(components, regulator.regulated_object());
             case ComponentType::branch3:
-                return get_component_sequence_idx<Branch3>(state.components, regulator.regulated_object());
+                return get_component_sequence_idx<Branch3>(components, regulator.regulated_object());
             default:
                 throw MissingCaseForEnumError("Regulator idx to seq transformation", regulator.regulated_object_type());
             }
         });
 
-    detail::register_topo_components<Component>(state, comp_topo.regulated_object_type, [](Regulator const& regulator) {
-        return regulator.regulated_object_type();
-    });
+    detail::register_topo_components<Component>(
+        components, comp_topo.regulated_object_type,
+        [](Regulator const& regulator) { return regulator.regulated_object_type(); });
 }
 
 ComponentTopology construct_topology(main_model_state_c auto const& state) {
     ComponentTopology comp_topo;
-    register_topology_components<Node>(state, comp_topo);
-    register_topology_components<Branch>(state, comp_topo);
-    register_topology_components<Branch3>(state, comp_topo);
-    register_topology_components<Source>(state, comp_topo);
-    register_topology_components<Shunt>(state, comp_topo);
-    register_topology_components<GenericLoadGen>(state, comp_topo);
-    register_topology_components<GenericVoltageSensor>(state, comp_topo);
-    register_topology_components<GenericPowerSensor>(state, comp_topo);
-    register_topology_components<GenericCurrentSensor>(state, comp_topo);
-    register_topology_components<Regulator>(state, comp_topo);
+    register_topology_components<Node>(state.components, comp_topo);
+    register_topology_components<Branch>(state.components, comp_topo);
+    register_topology_components<Branch3>(state.components, comp_topo);
+    register_topology_components<Source>(state.components, comp_topo);
+    register_topology_components<Shunt>(state.components, comp_topo);
+    register_topology_components<GenericLoadGen>(state.components, comp_topo);
+    register_topology_components<GenericVoltageSensor>(state.components, comp_topo);
+    register_topology_components<GenericPowerSensor>(state.components, comp_topo);
+    register_topology_components<GenericCurrentSensor>(state.components, comp_topo);
+    register_topology_components<Regulator>(state.components, comp_topo);
     return comp_topo;
 }