decouple topology related state queries

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

Author: nitbharambe

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

@@ -37,6 +37,13 @@ concept component_container_c = requires(ContainerType const& c, ID id) {
     { c.template get_item<ComponentType>(id) } -> std::convertible_to<ComponentType const&>;
 };
 
+template <typename ContainerType, typename ComponentType>
+concept extended_component_container_c =
+    component_container_c<ContainerType, ComponentType> && requires(ContainerType const& c, Idx2D const& idx2d) {
+        { c.template size<ComponentType>() } -> std::same_as<Idx>;
+        { c.template get_seq<ComponentType>(idx2d) } -> std::same_as<Idx>;
+    };
+
 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/state_queries.hpp

@@ -9,6 +9,23 @@
 #include "../all_components.hpp"
 
 namespace power_grid_model::main_core {
+
+// using only components and not state
+
+template <typename ComponentType, class ComponentContainer>
+    requires extended_component_container_c<ComponentContainer, ComponentType>
+constexpr auto get_component_size(ComponentContainer const& components) {
+    return components.template size<ComponentType>();
+}
+
+template <typename ComponentType, class ComponentContainer>
+    requires extended_component_container_c<ComponentContainer, ComponentType>
+inline Idx get_component_sequence_idx(ComponentContainer const& components, auto const& id_or_index) {
+    return components.template get_seq<ComponentType>(id_or_index);
+}
+
+// existing implementation
+
 template <typename ComponentType, class ComponentContainer>
     requires model_component_state_c<MainModelState, ComponentContainer, ComponentType>
 inline Idx get_component_type_index(MainModelState<ComponentContainer> const& state) {

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

@@ -32,16 +32,16 @@ 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);
+    comp_topo.n_node = get_component_size<Node>(state.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, branch.from_node()),
-                         get_component_sequence_idx<Node>(state, branch.to_node())};
+        return BranchIdx{get_component_sequence_idx<Node>(state.components, branch.from_node()),
+                         get_component_sequence_idx<Node>(state.components, branch.to_node())};
     });
 }
 
@@ -50,9 +50,9 @@ template <std::same_as<Branch3> Component, class ComponentContainer>
 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, branch3.node_1()),
-                          get_component_sequence_idx<Node>(state, branch3.node_2()),
-                          get_component_sequence_idx<Node>(state, branch3.node_3())};
+        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())};
     });
 }
 
@@ -61,7 +61,7 @@ template <std::same_as<Source> Component, class ComponentContainer>
 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, source.node());
+        return get_component_sequence_idx<Node>(state.components, source.node());
     });
 }
 
@@ -70,7 +70,7 @@ template <std::same_as<Shunt> Component, class ComponentContainer>
 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, shunt.node());
+        return get_component_sequence_idx<Node>(state.components, shunt.node());
     });
 }
 
@@ -79,8 +79,9 @@ template <std::same_as<GenericLoadGen> Component, class ComponentContainer>
 constexpr void register_topology_components(MainModelState<ComponentContainer> const& state,
                                             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, load_gen.node()); });
+        state, comp_topo.load_gen_node_idx, [&state](GenericLoadGen const& load_gen) {
+            return get_component_sequence_idx<Node>(state.components, load_gen.node());
+        });
 
     detail::register_topo_components<Component>(state, comp_topo.load_gen_type,
                                                 [](GenericLoadGen const& load_gen) { return load_gen.type(); });
@@ -92,7 +93,7 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
                                             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, voltage_sensor.measured_object());
+            return get_component_sequence_idx<Node>(state.components, voltage_sensor.measured_object());
         });
 }
 
@@ -110,23 +111,23 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state, measured_object);
+                return get_component_sequence_idx<Branch>(state.components, measured_object);
             case source:
-                return get_component_sequence_idx<Source>(state, measured_object);
+                return get_component_sequence_idx<Source>(state.components, measured_object);
             case shunt:
-                return get_component_sequence_idx<Shunt>(state, measured_object);
+                return get_component_sequence_idx<Shunt>(state.components, measured_object);
             case load:
                 [[fallthrough]];
             case generator:
-                return get_component_sequence_idx<GenericLoadGen>(state, measured_object);
+                return get_component_sequence_idx<GenericLoadGen>(state.components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state, measured_object);
+                return get_component_sequence_idx<Branch3>(state.components, measured_object);
             case node:
-                return get_component_sequence_idx<Node>(state, measured_object);
+                return get_component_sequence_idx<Node>(state.components, measured_object);
             default:
                 throw MissingCaseForEnumError("Power sensor idx to seq transformation",
                                               power_sensor.get_terminal_type());
@@ -152,13 +153,13 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
             case branch_from:
                 [[fallthrough]];
             case branch_to:
-                return get_component_sequence_idx<Branch>(state, measured_object);
+                return get_component_sequence_idx<Branch>(state.components, measured_object);
             case branch3_1:
                 [[fallthrough]];
             case branch3_2:
                 [[fallthrough]];
             case branch3_3:
-                return get_component_sequence_idx<Branch3>(state, measured_object);
+                return get_component_sequence_idx<Branch3>(state.components, measured_object);
             default:
                 throw MissingCaseForEnumError("Current sensor idx to seq transformation",
                                               current_sensor.get_terminal_type());
@@ -178,9 +179,9 @@ constexpr void register_topology_components(MainModelState<ComponentContainer> c
         state, comp_topo.regulated_object_idx, [&state](Regulator const& regulator) {
             switch (regulator.regulated_object_type()) {
             case ComponentType::branch:
-                return get_component_sequence_idx<Branch>(state, regulator.regulated_object());
+                return get_component_sequence_idx<Branch>(state.components, regulator.regulated_object());
             case ComponentType::branch3:
-                return get_component_sequence_idx<Branch3>(state, regulator.regulated_object());
+                return get_component_sequence_idx<Branch3>(state.components, regulator.regulated_object());
             default:
                 throw MissingCaseForEnumError("Regulator idx to seq transformation", regulator.regulated_object_type());
             }