Merge pull request #1401 from PowerGridModel/pgm/remove-forward

Improve and reduce usage of universal reference and forward

Author: TonyXiang8787

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp

@@ -553,14 +553,14 @@ template <dataset_type_tag dataset_type_> class Dataset {
         return result;
     }
 
-    template <class type_getter, class ComponentType, typename Func,
+    template <class type_getter, class ComponentType, functor_c Func,
               class StructType = DataStruct<typename type_getter::template type<ComponentType>>>
         requires std::invocable<Func, SpanRange<StructType>> && std::invocable<Func, RangeObject<StructType>>
-    auto for_each_component(Func&& func, Idx scenario = invalid_index) const {
+    auto for_each_component(Func func, Idx scenario = invalid_index) const {
         if (is_columnar(ComponentType::name)) {
-            return std::forward<Func>(func)(get_columnar_buffer_span<type_getter, ComponentType, StructType>(scenario));
+            return func(get_columnar_buffer_span<type_getter, ComponentType, StructType>(scenario));
         }
-        return std::forward<Func>(func)(get_buffer_span<type_getter, ComponentType, StructType>(scenario));
+        return func(get_buffer_span<type_getter, ComponentType, StructType>(scenario));
     }
 
     void set_next_cartesian_product_dimension(Dataset const* next) {

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp

@@ -51,18 +51,18 @@ template <class T> constexpr CType ctype_v = ctype_t<T>::value;
 // function selector based on ctype
 // the operator() of the functor should have a single template parameter
 // the selector will instantiate the operator() with relevant type
-template <class Functor, class... Args> decltype(auto) ctype_func_selector(CType ctype, Functor&& f, Args&&... args) {
+template <functor_c Functor, class... Args> decltype(auto) ctype_func_selector(CType ctype, Functor f, Args&&... args) {
     using enum CType;
 
     switch (ctype) {
     case c_double:
-        return std::forward<Functor>(f).template operator()<double>(std::forward<Args>(args)...);
+        return f.template operator()<double>(std::forward<Args>(args)...);
     case c_double3:
-        return std::forward<Functor>(f).template operator()<RealValue<asymmetric_t>>(std::forward<Args>(args)...);
+        return f.template operator()<RealValue<asymmetric_t>>(std::forward<Args>(args)...);
     case c_int8:
-        return std::forward<Functor>(f).template operator()<int8_t>(std::forward<Args>(args)...);
+        return f.template operator()<int8_t>(std::forward<Args>(args)...);
     case c_int32:
-        return std::forward<Functor>(f).template operator()<int32_t>(std::forward<Args>(args)...);
+        return f.template operator()<int32_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"CType selector", ctype};
     }

power_grid_model_c/power_grid_model/include/power_grid_model/calculation.hpp

@@ -26,55 +26,53 @@ struct short_circuit_t : calculation_type_t {};
 template <typename T>
 concept calculation_type_tag = std::derived_from<T, calculation_type_t>;
 
-template <class Functor, class... Args>
-decltype(auto) calculation_symmetry_func_selector(CalculationSymmetry calculation_symmetry, Functor&& f,
+template <class... Args>
+decltype(auto) calculation_symmetry_func_selector(CalculationSymmetry calculation_symmetry, functor_c auto f,
                                                   Args&&... args) {
     using enum CalculationSymmetry;
 
     switch (calculation_symmetry) {
     case symmetric:
-        return std::forward<Functor>(f).template operator()<symmetric_t>(std::forward<Args>(args)...);
+        return f.template operator()<symmetric_t>(std::forward<Args>(args)...);
     case asymmetric:
-        return std::forward<Functor>(f).template operator()<asymmetric_t>(std::forward<Args>(args)...);
+        return f.template operator()<asymmetric_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"Calculation symmetry selector", calculation_symmetry};
     }
 }
 
-template <class Functor, class... Args>
-decltype(auto) calculation_type_func_selector(CalculationType calculation_type, Functor&& f, Args&&... args) {
+template <class... Args>
+decltype(auto) calculation_type_func_selector(CalculationType calculation_type, functor_c auto f, Args&&... args) {
     using enum CalculationType;
 
     switch (calculation_type) {
     case CalculationType::power_flow:
-        return std::forward<Functor>(f).template operator()<power_flow_t>(std::forward<Args>(args)...);
+        return f.template operator()<power_flow_t>(std::forward<Args>(args)...);
     case CalculationType::state_estimation:
-        return std::forward<Functor>(f).template operator()<state_estimation_t>(std::forward<Args>(args)...);
+        return f.template operator()<state_estimation_t>(std::forward<Args>(args)...);
     case CalculationType::short_circuit:
-        return std::forward<Functor>(f).template operator()<short_circuit_t>(std::forward<Args>(args)...);
+        return f.template operator()<short_circuit_t>(std::forward<Args>(args)...);
     default:
         throw MissingCaseForEnumError{"CalculationType", calculation_type};
     }
 }
 
-template <class Functor, class... Args>
+template <class... Args>
 decltype(auto) calculation_type_symmetry_func_selector(CalculationType calculation_type,
-                                                       CalculationSymmetry calculation_symmetry, Functor&& f,
+                                                       CalculationSymmetry calculation_symmetry, functor_c auto f,
                                                        Args&&... args) {
     calculation_type_func_selector(
         calculation_type,
-        []<calculation_type_tag calculation_type, typename Functor_, typename... Args_>(
-            CalculationSymmetry calculation_symmetry_, Functor_&& f_, Args_&&... args_) {
+        []<calculation_type_tag calculation_type, typename... Args_>(CalculationSymmetry calculation_symmetry_,
+                                                                     functor_c auto f_, Args_&&... args_) {
             calculation_symmetry_func_selector(
                 calculation_symmetry_,
-                []<symmetry_tag sym, typename SubFunctor, typename... SubArgs>(SubFunctor&& sub_f,
-                                                                               SubArgs&&... sub_args) {
-                    std::forward<SubFunctor>(sub_f).template operator()<calculation_type, sym>(
-                        std::forward<SubArgs>(sub_args)...);
+                []<symmetry_tag sym, typename... SubArgs>(functor_c auto sub_f, SubArgs&&... sub_args) {
+                    sub_f.template operator()<calculation_type, sym>(std::forward<SubArgs>(sub_args)...);
                 },
-                std::forward<Functor_>(f_), std::forward<Args_>(args_)...);
+                f_, std::forward<Args_>(args_)...);
         },
-        calculation_symmetry, std::forward<Functor>(f), std::forward<Args>(args)...);
+        calculation_symmetry, f, std::forward<Args>(args)...);
 }
 
 template <typename T, typename sym> struct Calculator;

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

@@ -36,10 +36,8 @@ class CalculationInfo : public Logger {
     void log(LogEvent tag, double value) override { log_impl(tag, value); }
     void log(LogEvent tag, Idx value) override { log_impl(tag, static_cast<double>(value)); }
     void log(std::string_view /*message*/) const { /* ignore all such events for now */ }
-    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn&& fn) const {
-        capturing::into_the_void(std::forward<Fn>(fn));
-    }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) const { capturing::into_the_void(std::forward<Fn>(fn)); }
+    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn /*fn*/) const { /*do nothing*/ }
+    template <LazyLoggingFn Fn> void log(Fn /*fn*/) const { /*do nothing*/ }
 
   private:
     Data data_;

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

@@ -13,7 +13,9 @@
 #include <functional>
 #include <limits>
 #include <numbers>
+#include <ranges>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace power_grid_model {
@@ -101,22 +103,38 @@ template <class T, class... Ts>
 concept derives_from_any_in_list_c = (std::derived_from<T, Ts> || ...);
 
 namespace capturing {
-// perfect forward into void
-template <class... T>
-constexpr void into_the_void(T&&... /*ignored*/) { // NOLINT(cppcoreguidelines-missing-std-forward)
+// capture into void
+template <class... T> constexpr void into_the_void(T const&... /*ignored*/) {
     // do nothing; the constexpr allows all compilers to optimize this away
 }
 } // namespace capturing
 
 // functor to include all
 struct IncludeAll {
-    template <class... T> consteval bool operator()(T&&... args) const {
-        capturing::into_the_void(std::forward<T>(args)...);
-        return true;
-    }
+    template <class... T> consteval bool operator()(T const&... /* args */) const { return true; }
 };
 constexpr IncludeAll include_all{};
 
+// define a non-owning view
+namespace detail {
+template <class> struct is_owning_view : std::false_type {};
+template <class R> struct is_owning_view<std::ranges::owning_view<R>> : std::true_type {};
+} // namespace detail
+template <class R>
+concept non_owning_view_c = std::ranges::view<R> && !detail::is_owning_view<std::remove_cvref_t<R>>::value;
+
+// by ref adaptor to pass to functions which accepts std::ranges::view
+template <class R>
+concept owning_container_c = std::ranges::viewable_range<R> && !std::ranges::view<R> && !std::ranges::borrowed_range<R>;
+constexpr non_owning_view_c auto by_ref(owning_container_c auto& r) noexcept { return std::ranges::ref_view(r); }
+constexpr non_owning_view_c auto by_ref(owning_container_c auto const& r) noexcept { return std::ranges::ref_view(r); }
+constexpr non_owning_view_c auto by_const_ref(owning_container_c auto& r) noexcept { return by_ref(std::as_const(r)); }
+
+// pgm functor concept
+// it should be cheap to copy, so it should be trivially copyable and small in size
+template <class T>
+concept functor_c = std::is_trivially_copyable_v<T> && (sizeof(T) <= 256);
+
 // function to handle periodic mapping
 template <typename T> constexpr T map_to_cyclic_range(T value, T period) {
     static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type (integral or floating-point)");

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

@@ -20,10 +20,8 @@ class NoLogger : public Logger {
     void log(LogEvent /*tag*/, double /*value*/) override { /* no logging */ }
     void log(LogEvent /*tag*/, Idx /*value*/) override { /* no logging */ }
     void log(std::string_view /*message*/) const { /* no logging */ }
-    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn&& fn) const {
-        capturing::into_the_void(std::forward<Fn>(fn));
-    }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) const { capturing::into_the_void(std::forward<Fn>(fn)); }
+    template <LazyLoggingFn Fn> void log(LogEvent /*tag*/, Fn /* fn */) const { /*do nothing*/ }
+    template <LazyLoggingFn Fn> void log(Fn /* fn */) const { /*do nothing*/ }
     template <std::derived_from<Logger> T> T& merge_into(T& destination) const { return destination; }
 };
 

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

@@ -36,26 +36,29 @@ The input, i.e., [0, 1, 3] should be strictly increasing
 namespace power_grid_model {
 
 namespace detail {
-template <std::ranges::viewable_range ElementGroups>
-constexpr auto sparse_encode(ElementGroups&& element_groups, Idx num_groups) {
+constexpr auto sparse_encode(non_owning_view_c auto element_groups, Idx num_groups) {
     IdxVector result(num_groups + 1);
-    auto element_groups_view = std::views::all(std::forward<ElementGroups>(element_groups));
-    auto next_group = std::begin(element_groups_view);
+    auto next_group = std::begin(element_groups);
+    auto const begin = std::begin(element_groups);
+    auto const end = std::end(element_groups);
     for (auto const group : IdxRange{num_groups}) {
-        next_group = std::upper_bound(next_group, std::end(element_groups_view), group);
-        result[group + 1] = std::distance(std::begin(element_groups_view), next_group);
+        next_group = std::upper_bound(next_group, end, group);
+        result[group + 1] = std::distance(begin, next_group);
     }
     return result;
 }
+constexpr auto sparse_encode(IdxVector const& element_groups, Idx num_groups) {
+    return sparse_encode(by_ref(element_groups), num_groups);
+}
 
-template <std::ranges::viewable_range IndPtr> constexpr auto sparse_decode(IndPtr&& indptr) {
-    auto indptr_view = std::views::all(std::forward<IndPtr>(indptr));
-    auto result = IdxVector(indptr_view.back());
-    for (Idx const group : IdxRange{static_cast<Idx>(indptr_view.size()) - 1}) {
-        std::fill(std::begin(result) + indptr_view[group], std::begin(result) + indptr_view[group + 1], group);
+constexpr auto sparse_decode(non_owning_view_c auto indptr) {
+    auto result = IdxVector(indptr.back());
+    for (Idx const group : IdxRange{static_cast<Idx>(indptr.size()) - 1}) {
+        std::fill(std::begin(result) + indptr[group], std::begin(result) + indptr[group + 1], group);
     }
     return result;
 }
+constexpr auto sparse_decode(IdxVector const& indptr) { return sparse_decode(by_ref(indptr)); }
 
 template <typename T, typename ElementType>
 concept iterator_of = std::input_or_output_iterator<T> && requires(T const t) {

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

@@ -35,9 +35,7 @@ class IteratorFacade {
   public:
     using iterator_category = std::random_access_iterator_tag;
 
-    template <typename Self> constexpr decltype(auto) operator->(this Self&& self) {
-        return &(*std::forward<Self>(self));
-    }
+    template <typename Self> constexpr decltype(auto) operator->(this Self const& self) { return &(*self); }
 
     template <typename Self, typename Other>
         requires std::same_as<std::remove_cvref_t<Self>, std::remove_cvref_t<Other>>
@@ -83,23 +81,22 @@ class IteratorFacade {
     }
 
     template <typename Self, std::integral Int>
-    friend constexpr std::remove_cvref_t<Self> operator+(Self&& self, Int offset)
-        requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
+    friend constexpr Self operator+(Self const& self, Int offset)
+        requires std::derived_from<Self, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
     {
-        using Result = std::remove_cvref_t<Self>;
-        Result result{std::forward<Self>(self)};
+        Self result{self};
         result += offset;
         return result;
     }
     template <typename Self, std::integral Int>
-        requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
-    friend constexpr std::remove_cvref_t<Self> operator+(Int offset, Self&& self) {
-        return std::forward<Self>(self) + offset;
+        requires std::derived_from<Self, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
+    friend constexpr Self operator+(Int offset, Self const& self) {
+        return self + offset;
     }
     template <typename Self, std::integral Int>
-        requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
-    friend constexpr std::remove_cvref_t<Self> operator-(Self&& self, Int idx) {
-        return (std::forward<Self>(self)) + (-idx);
+        requires std::derived_from<Self, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
+    friend constexpr Self operator-(Self const& self, Int idx) {
+        return self + (-idx);
     }
 
     template <typename Self>

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

@@ -46,7 +46,7 @@ enum class LogEvent : int16_t {
 
 template <typename Fn>
 concept LazyLoggingFn = std::invocable<Fn> && std::convertible_to<std::invoke_result_t<Fn>, std::string> &&
-                        (!std::convertible_to<Fn, std::string_view>);
+                        (!std::convertible_to<Fn, std::string_view>) && functor_c<Fn>;
 
 class Logger {
   public:
@@ -56,8 +56,8 @@ class Logger {
     virtual void log(LogEvent tag, Idx value) = 0;
 
     void log(std::string_view message) { log(LogEvent::unknown, message); }
-    template <LazyLoggingFn Fn> void log(LogEvent tag, Fn&& fn) { log(tag, std::invoke(std::forward<Fn>(fn))); }
-    template <LazyLoggingFn Fn> void log(Fn&& fn) { log(LogEvent::unknown, std::invoke(std::forward<Fn>(fn))); }
+    template <LazyLoggingFn Fn> void log(LogEvent tag, Fn fn) { log(tag, std::invoke(fn)); }
+    template <LazyLoggingFn Fn> void log(Fn fn) { log(LogEvent::unknown, std::invoke(fn)); }
 
     Logger(Logger&&) noexcept = default;
     Logger& operator=(Logger&&) noexcept = default;

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

@@ -314,7 +314,7 @@ inline auto scale(DecomposedComplexRandVar<sym> const& var, ScaleType const& sca
 }
 
 // combine multiple random variables of one quantity using Kalman filter
-template <std::ranges::view RandVarsView>
+template <non_owning_view_c RandVarsView>
     requires std::same_as<std::ranges::range_value_t<RandVarsView>,
                           UniformRealRandVar<typename std::ranges::range_value_t<RandVarsView>::sym>> ||
              std::same_as<std::ranges::range_value_t<RandVarsView>,
@@ -345,7 +345,7 @@ constexpr auto combine(RandVarsView rand_vars) {
                        .variance = VarianceType{1.0} / accumulated_inverse_variance};
 }
 
-template <std::ranges::view RandVarsView>
+template <non_owning_view_c RandVarsView>
     requires std::same_as<std::ranges::range_value_t<RandVarsView>,
                           DecomposedComplexRandVar<typename std::ranges::range_value_t<RandVarsView>::sym>>
 constexpr auto combine(RandVarsView rand_vars) {
@@ -373,7 +373,7 @@ template <symmetry_tag sym> inline RealValue<sym> cabs_or_real(ComplexValue<sym>
 }
 } // namespace detail
 
-template <std::ranges::view RandVarsView>
+template <non_owning_view_c RandVarsView>
     requires std::same_as<std::ranges::range_value_t<RandVarsView>,
                           UniformComplexRandVar<typename std::ranges::range_value_t<RandVarsView>::sym>>
 constexpr auto combine_magnitude(RandVarsView rand_vars) {