move concepts to container_fwd

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

Author: nitbharambe

power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp

@@ -9,6 +9,7 @@
 #include "common/common.hpp"
 #include "common/exception.hpp"
 #include "common/iterator_facade.hpp"
+#include "container_fwd.hpp"
 
 #include <boost/range.hpp>
 

power_grid_model_c/power_grid_model/include/power_grid_model/container_fwd.hpp

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <[email protected]>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "common/common.hpp"
+
+#include <concepts>
+
+namespace power_grid_model {
+
+template <typename ContainerType, typename ComponentType>
+concept component_container_c = requires(ContainerType const& c, ID id) {
+    { c.template citer<ComponentType>().begin() } -> std::forward_iterator;
+    { c.template citer<ComponentType>().end() } -> std::forward_iterator;
+    { *(c.template citer<ComponentType>().begin()) } -> std::same_as<ComponentType const&>;
+    { *(c.template citer<ComponentType>().end()) } -> std::same_as<ComponentType const&>;
+    { 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 <typename ContainerType, typename... ComponentType>
+concept multi_extended_component_container_c = (extended_component_container_c<ContainerType, ComponentType> && ...);
+
+} // namespace power_grid_model

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

@@ -28,25 +28,6 @@ template <class CompContainer> struct MainModelState {
 template <class StateType>
 concept main_model_state_c = std::same_as<StateType, MainModelState<typename StateType::ComponentContainer>>;
 
-template <typename ContainerType, typename ComponentType>
-concept component_container_c = requires(ContainerType const& c, ID id) {
-    { c.template citer<ComponentType>().begin() } -> std::forward_iterator;
-    { c.template citer<ComponentType>().end() } -> std::forward_iterator;
-    { *(c.template citer<ComponentType>().begin()) } -> std::same_as<ComponentType const&>;
-    { *(c.template citer<ComponentType>().end()) } -> std::same_as<ComponentType const&>;
-    { 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 <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/optimizer/optimizer.hpp

@@ -29,7 +29,7 @@ constexpr auto get_optimizer(OptimizerType optimizer_type, OptimizerStrategy str
     case automatic_tap_adjustment:
         if constexpr (detail::steady_state_calculator_c<StateCalculator, State> &&
                       std::invocable<std::remove_cvref_t<StateUpdater>, ConstDataset const&> &&
-                      main_core::component_container_c<typename State::ComponentContainer, TransformerTapRegulator>) {
+                      component_container_c<typename State::ComponentContainer, TransformerTapRegulator>) {
             return BaseOptimizer::template make_shared<TapPositionOptimizer<StateCalculator, StateUpdater, State>>(
                 std::move(calculator), std::move(updater), strategy, meta_data, search);
         }

power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp

@@ -471,7 +471,7 @@ template <transformer_c... TransformerTypes> struct TapRegulatorRef {
 };
 
 template <typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, TransformerTapRegulator>
+    requires component_container_c<typename State::ComponentContainer, TransformerTapRegulator>
 TransformerTapRegulator const& find_regulator(State const& state, ID regulated_object) {
     auto const regulators = get_component_citer<TransformerTapRegulator>(state);
 
@@ -503,7 +503,7 @@ template <typename... Ts> struct transformer_types_s<std::tuple<std::tuple<Ts...
 template <typename... Ts> using transformer_types_t = typename transformer_types_s<std::tuple<Ts...>>::type;
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(main_core::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline TapRegulatorRef<TransformerTypes...> regulator_mapping(State const& state, Idx2D const& transformer_index) {
     using ResultType = TapRegulatorRef<TransformerTypes...>;
     using IsType = bool (*)(Idx2D const&);
@@ -536,7 +536,7 @@ inline TapRegulatorRef<TransformerTypes...> regulator_mapping(State const& state
 }
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(main_core::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline auto regulator_mapping(State const& state, std::vector<Idx2D> const& order) {
     std::vector<TapRegulatorRef<TransformerTypes...>> result;
     result.reserve(order.size());
@@ -549,7 +549,7 @@ inline auto regulator_mapping(State const& state, std::vector<Idx2D> const& orde
 }
 
 template <transformer_c... TransformerTypes, typename State>
-    requires(main_core::component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
+    requires(component_container_c<typename State::ComponentContainer, TransformerTypes> && ...)
 inline auto regulator_mapping(State const& state, RankedTransformerGroups const& order) {
     std::vector<std::vector<TapRegulatorRef<TransformerTypes...>>> result;
     result.reserve(order.size());
@@ -598,15 +598,15 @@ inline auto i_pu(std::vector<SolverOutputType> const& solver_output, Idx2DBranch
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto i_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regulator, State const& state,
                                  std::vector<SolverOutputType> const& solver_output) {
     auto const& branch_math_id = get_math_id<ComponentType>(state, regulator.transformer.topology_index());
     return i_pu<ComponentType>(solver_output, branch_math_id, regulator.regulator.get().control_side());
 }
 
 template <transformer_c ComponentType, typename State, steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType> &&
+    requires component_container_c<typename State::ComponentContainer, ComponentType> &&
              requires(State const& state, Idx const i) {
                  { get_branch_nodes<ComponentType>(state, i)[i] } -> std::convertible_to<Idx>;
              }
@@ -619,15 +619,15 @@ inline auto u_pu(State const& state, std::vector<SolverOutputType> const& solver
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu_controlled_node(TapRegulatorRef<RegulatedTypes...> const& regulator, State const& state,
                                  std::vector<SolverOutputType> const& solver_output) {
     return u_pu<ComponentType>(state, solver_output, regulator.transformer.topology_index(),
                                regulator.regulator.get().control_side());
 }
 
 template <component_c ComponentType, typename... RegulatedTypes, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline bool is_regulated_transformer_connected(TapRegulatorRef<RegulatedTypes...> const& regulator,
                                                State const& state) {
     auto const controlled_node_idx = get_topo_node<ComponentType>(state, regulator.transformer.topology_index(),
@@ -702,7 +702,7 @@ class RankIteration {
 template <typename... T> class TapPositionOptimizerImpl;
 template <transformer_c... TransformerTypes, typename StateCalculator, typename StateUpdater_, typename State_,
           typename TransformerRanker_>
-    requires(main_core::component_container_c<typename State_::ComponentContainer, TransformerTypes> && ...) &&
+    requires(component_container_c<typename State_::ComponentContainer, TransformerTypes> && ...) &&
             detail::steady_state_calculator_c<StateCalculator, State_> &&
             std::invocable<std::remove_cvref_t<StateUpdater_>, ConstDataset const&> &&
             requires(TransformerRanker_ const& ranker, State_ const& state) {

tests/cpp_unit_tests/test_optimizer.hpp

@@ -54,13 +54,13 @@ static_assert(transformer_c<StubTransformerA>);
 static_assert(transformer_c<StubTransformerB>);
 
 template <std::derived_from<StubTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_topology_index(State const& /* state */, auto const& /* id_or_index */) {
     return Idx{};
 }
 
 template <std::derived_from<StubTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_math_id(State const& /* state */, Idx /* topology_sequence_idx */) {
     return StubTransformerMathIdType{};
 }
@@ -73,7 +73,7 @@ inline auto i_pu(std::vector<SolverOutputType> const& /* solver_output */,
 
 template <std::derived_from<StubTransformer> ComponentType, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu(State const& /* state */, std::vector<SolverOutputType> const& /* solver_output */,
                  Idx /* topology_index */, ControlSide /* control_side */) {
     return ComplexValue<typename SolverOutputType::sym>{};

tests/cpp_unit_tests/test_tap_position_optimizer.cpp

@@ -624,7 +624,7 @@ class MockSolverOutput : public SolverOutput<symmetric_t> {
     template <typename... T> struct AddTapPositions;
     template <typename T> struct AddTapPositions<T> {
         void operator()(main_core::MainModelState<ContainerType> const& state, std::map<ID, IntS>& target) {
-            if constexpr (transformer_c<T> && main_core::component_container_c<ContainerType, T>) {
+            if constexpr (transformer_c<T> && component_container_c<ContainerType, T>) {
                 for (auto const& component : state.components.template citer<T>()) {
                     target[component.id()] = component.tap_pos();
                 }
@@ -732,14 +732,14 @@ struct MockTransformer {
 static_assert(transformer_c<MockTransformer>);
 
 template <std::derived_from<MockTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_topology_index(State const& state, auto const& id_or_index) {
     auto const& transformer = main_core::get_component<ComponentType>(state, id_or_index);
     return transformer.state.math_id.pos;
 }
 
 template <std::derived_from<MockTransformer> ComponentType, typename State>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 constexpr auto get_math_id(State const& state, Idx topology_index) {
     return main_core::get_component_by_sequence<MockTransformer>(state, topology_index).state.math_id;
 }
@@ -763,7 +763,7 @@ inline DoubleComplex i_pu(std::vector<MockSolverOutput<ContainerType>> const& so
 
 template <std::derived_from<MockTransformer> ComponentType, typename State,
           steady_state_solver_output_type SolverOutputType>
-    requires main_core::component_container_c<typename State::ComponentContainer, ComponentType>
+    requires component_container_c<typename State::ComponentContainer, ComponentType>
 inline auto u_pu(State const& state, std::vector<SolverOutputType> const& /* solver_output */, Idx topology_index,
                  ControlSide side) {
     return main_core::get_component_by_sequence<MockTransformer>(state, topology_index).state.u_pu(side);