add runtime_conditional and flow unary operator+

Author: lukevalenty

examples/flow_daily_routine/main.cpp

@@ -95,14 +95,10 @@ struct self_care_component_t {
     // Extend flow services
     constexpr static auto config = cib::config(
 
-        cib::extend<morning_routine_t>(self_care_component_t::WAKE_UP >>
-                                       self_care_component_t::EXERCISE >>
-                                       self_care_component_t::TAKE_BATH),
+        cib::extend<morning_routine_t>(+WAKE_UP >> +EXERCISE >> +TAKE_BATH),
 
-        cib::extend<evening_routine_t>(self_care_component_t::EXERCISE >>
-                                       self_care_component_t::TAKE_BATH >>
-                                       self_care_component_t::RELAX >>
-                                       self_care_component_t::GO_TO_BED));
+        cib::extend<evening_routine_t>(+EXERCISE >> +TAKE_BATH >> +RELAX >>
+                                       +GO_TO_BED));
 };
 
 struct food_component_t {
@@ -119,10 +115,10 @@ struct food_component_t {
     constexpr static auto config = cib::config(
 
         cib::extend<morning_routine_t>(self_care_component_t::TAKE_BATH >>
-                                       food_component_t::BREAKFAST),
+                                       +BREAKFAST),
 
         cib::extend<evening_routine_t>(self_care_component_t::RELAX >>
-                                       food_component_t::DINNER >>
+                                       +DINNER >>
                                        self_care_component_t::GO_TO_BED));
 };
 
@@ -141,16 +137,13 @@ struct dress_up_component_t {
     constexpr static auto config = cib::config(
 
         cib::extend<morning_routine_t>(
-            self_care_component_t::WAKE_UP >>
-            dress_up_component_t::GET_READY_FOR_EXERCISE >>
+            self_care_component_t::WAKE_UP >> +GET_READY_FOR_EXERCISE >>
             self_care_component_t::EXERCISE >>
-            self_care_component_t::TAKE_BATH >>
-            dress_up_component_t::GET_READY_TO_WORK >>
+            self_care_component_t::TAKE_BATH >> +GET_READY_TO_WORK >>
             food_component_t::BREAKFAST),
 
-        cib::extend<evening_routine_t>(
-            dress_up_component_t::GET_READY_FOR_EXERCISE >>
-            self_care_component_t::EXERCISE));
+        cib::extend<evening_routine_t>(+GET_READY_FOR_EXERCISE >>
+                                       self_care_component_t::EXERCISE));
 };
 
 struct commute_component_t {
@@ -167,11 +160,10 @@ struct commute_component_t {
     constexpr static auto config = cib::config(
 
         cib::extend<morning_routine_t>(food_component_t::BREAKFAST >>
-                                       commute_component_t::GO_TO_OFFICE),
+                                       +GO_TO_OFFICE),
 
         cib::extend<evening_routine_t>(
-            commute_component_t::RETURN_HOME >>
-            dress_up_component_t::GET_READY_FOR_EXERCISE));
+            +RETURN_HOME >> dress_up_component_t::GET_READY_FOR_EXERCISE));
 };
 
 struct daily_routine_component_t {
@@ -206,7 +198,7 @@ struct daily_routine_component_t {
 
         // we need to extend the MainLoop as cib::top implements
         // MainLoop service
-        cib::extend<cib::MainLoop>(DAILY_ROUTINES));
+        cib::extend<cib::MainLoop>(+DAILY_ROUTINES));
 };
 
 struct person_routine_proj {

include/cib/config.hpp

@@ -7,6 +7,7 @@
 #include <cib/detail/config_item.hpp>
 #include <cib/detail/exports.hpp>
 #include <cib/detail/extend.hpp>
+#include <cib/detail/runtime_conditional.hpp>
 
 #include <stdx/compiler.hpp>
 
@@ -22,6 +23,7 @@ namespace cib {
  * @see cib::extend
  * @see cib::exports
  * @see cib::conditional
+ * @see cib::runtime_conditional
  */
 template <typename... Configs>
 [[nodiscard]] CONSTEVAL auto config(Configs const &...configs) {
@@ -72,4 +74,10 @@ template <typename Predicate, typename... Configs>
                                          Configs const &...configs) {
     return detail::conditional<Predicate, Configs...>{configs...};
 }
+
+template <stdx::ct_string Name>
+constexpr auto runtime_condition = []<typename P>(P) {
+    static_assert(std::is_default_constructible_v<P>);
+    return detail::runtime_condition<Name, P>{};
+};
 } // namespace cib

include/cib/detail/runtime_conditional.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <cib/detail/config_details.hpp>
+#include <cib/detail/config_item.hpp>
+#include <cib/detail/extend.hpp>
+
+#include <stdx/compiler.hpp>
+#include <stdx/ct_format.hpp>
+#include <stdx/tuple.hpp>
+#include <stdx/tuple_algorithms.hpp>
+
+namespace cib::detail {
+template <typename Cond, typename... Configs>
+struct runtime_conditional : config_item {
+    detail::config<Configs...> body;
+
+    CONSTEVAL explicit runtime_conditional(Configs const &...configs)
+        : body{configs...} {}
+
+    [[nodiscard]] constexpr auto extends_tuple() const {
+        return stdx::transform(
+            []<typename E>(E e) {
+                auto args_tuple = stdx::transform(
+                    []<typename Arg>(Arg) {
+                        return make_runtime_conditional(Cond{}, Arg{});
+                    },
+                    e.args_tuple);
+
+                return stdx::apply(
+                    []<typename... Args>(Args...) {
+                        return extend<typename E::service_type, Args...>{
+                            Args{}...};
+                    },
+                    args_tuple);
+            },
+            body.extends_tuple());
+    }
+
+    [[nodiscard]] constexpr auto exports_tuple() const {
+        return body.exports_tuple();
+    }
+};
+
+template <stdx::ct_string Name, typename... Ps> // FIXME: concept for Ps
+struct runtime_condition {
+    constexpr static auto predicates = stdx::make_tuple(Ps{}...);
+
+    constexpr static auto ct_name = Name;
+
+    template <typename... Configs>
+    [[nodiscard]] CONSTEVAL auto operator()(Configs const &...configs) const {
+        return detail::runtime_conditional<runtime_condition<Name, Ps...>,
+                                           Configs...>{configs...};
+    }
+
+    explicit operator bool() const { return (Ps{}() and ...); }
+
+    template <stdx::ct_string RhsName, typename... RhsPs>
+    [[nodiscard]] constexpr auto
+    operator and(runtime_condition<RhsName, RhsPs...> rhs) const {
+        if constexpr ((sizeof...(Ps) + sizeof...(RhsPs)) == 0) {
+            return runtime_condition<"always">{};
+
+        } else if constexpr (sizeof...(Ps) == 0) {
+            return rhs;
+
+        } else if constexpr (sizeof...(RhsPs) == 0) {
+            return *this;
+
+        } else {
+            constexpr auto name =
+                stdx::ct_format<"{} and {}">(CX_VALUE(Name), CX_VALUE(RhsName));
+
+            return runtime_condition<name, Ps..., RhsPs...>{};
+        }
+    }
+};
+
+using always_condition_t = runtime_condition<"always">;
+constexpr auto always_condition = always_condition_t{};
+} // namespace cib::detail

include/flow/detail/par.hpp

@@ -11,6 +11,13 @@ template <node Lhs, node Rhs> struct par {
 
     using is_node = void;
 
+    constexpr auto operator+() const {
+        using lhs_t = decltype(+lhs);
+        using rhs_t = decltype(+rhs);
+
+        return par<lhs_t, rhs_t>{lhs_t{}, rhs_t{}};
+    }
+
   private:
     friend constexpr auto tag_invoke(get_initials_t, par const &p) {
         return stdx::tuple_cat(get_initials(p.lhs), get_initials(p.rhs));
@@ -24,6 +31,11 @@ template <node Lhs, node Rhs> struct par {
         return stdx::tuple_cat(get_nodes(p.lhs), get_nodes(p.rhs));
     }
 
+    friend constexpr auto tag_invoke(get_all_mentioned_nodes_t, par const &p) {
+        return stdx::tuple_cat(get_all_mentioned_nodes(p.lhs),
+                               get_all_mentioned_nodes(p.rhs));
+    }
+
     friend constexpr auto tag_invoke(get_edges_t, par const &p) {
         return stdx::tuple_cat(get_edges(p.lhs), get_edges(p.rhs));
     }
@@ -36,3 +48,9 @@ template <flow::dsl::node Lhs, flow::dsl::node Rhs>
 [[nodiscard]] constexpr auto operator&&(Lhs const &lhs, Rhs const &rhs) {
     return flow::dsl::par{lhs, rhs};
 }
+
+template <typename Cond, flow::dsl::node Lhs, flow::dsl::node Rhs>
+constexpr auto make_runtime_conditional(Cond, flow::dsl::par<Lhs, Rhs>) {
+    return flow::dsl::par{make_runtime_conditional(Cond{}, Lhs{}),
+                          make_runtime_conditional(Cond{}, Rhs{})};
+}

include/flow/detail/seq.hpp

@@ -1,16 +1,25 @@
 #pragma once
 
+#include <cib/detail/runtime_conditional.hpp>
 #include <flow/detail/walk.hpp>
 
 #include <stdx/tuple_algorithms.hpp>
 
 namespace flow::dsl {
-template <node Lhs, node Rhs> struct seq {
+template <node Lhs, node Rhs, typename Cond = cib::detail::always_condition_t>
+struct seq {
     Lhs lhs;
     Rhs rhs;
 
     using is_node = void;
 
+    constexpr auto operator+() const {
+        using lhs_t = decltype(+lhs);
+        using rhs_t = decltype(+rhs);
+
+        return seq<lhs_t, rhs_t, Cond>{lhs_t{}, rhs_t{}};
+    }
+
   private:
     friend constexpr auto tag_invoke(get_initials_t, seq const &s) {
         return get_initials(s.lhs);
@@ -24,6 +33,11 @@ template <node Lhs, node Rhs> struct seq {
         return stdx::tuple_cat(get_nodes(s.lhs), get_nodes(s.rhs));
     }
 
+    friend constexpr auto tag_invoke(get_all_mentioned_nodes_t, seq const &s) {
+        return stdx::tuple_cat(get_all_mentioned_nodes(s.lhs),
+                               get_all_mentioned_nodes(s.rhs));
+    }
+
     friend constexpr auto tag_invoke(get_edges_t, seq const &s) {
         auto is = get_initials(s.rhs);
         auto fs = get_finals(s.lhs);
@@ -33,16 +47,31 @@ template <node Lhs, node Rhs> struct seq {
             transform(
                 []<typename P>(P const &) {
                     return edge<stdx::tuple_element_t<0, P>,
-                                stdx::tuple_element_t<1, P>>{};
+                                stdx::tuple_element_t<1, P>, Cond>{};
                 },
                 cartesian_product_copy(fs, is)));
     }
 };
 
 template <node Lhs, node Rhs> seq(Lhs, Rhs) -> seq<Lhs, Rhs>;
+
 } // namespace flow::dsl
 
 template <flow::dsl::node Lhs, flow::dsl::node Rhs>
 [[nodiscard]] constexpr auto operator>>(Lhs const &lhs, Rhs const &rhs) {
     return flow::dsl::seq{lhs, rhs};
 }
+
+template <typename Cond, flow::dsl::node Lhs, flow::dsl::node Rhs,
+          typename EdgeCond>
+constexpr auto make_runtime_conditional(Cond,
+                                        flow::dsl::seq<Lhs, Rhs, EdgeCond>) {
+    auto lhs = make_runtime_conditional(Cond{}, Lhs{});
+    auto rhs = make_runtime_conditional(Cond{}, Rhs{});
+
+    using lhs_t = decltype(lhs);
+    using rhs_t = decltype(rhs);
+    using cond_t = decltype(EdgeCond{} and Cond{});
+
+    return flow::dsl::seq<lhs_t, rhs_t, cond_t>{lhs, rhs};
+}

include/flow/detail/walk.hpp

@@ -10,7 +10,7 @@ namespace flow::dsl {
 template <typename T>
 concept node = requires { typename stdx::remove_cvref_t<T>::is_node; };
 
-template <typename Source, typename Dest> struct edge {
+template <typename Source, typename Dest, typename Cond> struct edge {
     using source_t = Source;
     using dest_t = Dest;
 };
@@ -47,7 +47,11 @@ constexpr inline class get_finals_t {
 
 constexpr inline class get_nodes_t {
     template <node N> friend constexpr auto tag_invoke(get_nodes_t, N &&n) {
-        return stdx::make_tuple(std::forward<N>(n));
+        if constexpr (std::remove_cvref_t<N>::is_reference) {
+            return stdx::tuple{};
+        } else {
+            return stdx::make_tuple(std::forward<N>(n));
+        }
     }
 
   public:
@@ -60,6 +64,22 @@ constexpr inline class get_nodes_t {
     }
 } get_nodes{};
 
+constexpr inline class get_all_mentioned_nodes_t {
+    template <node N>
+    friend constexpr auto tag_invoke(get_all_mentioned_nodes_t, N &&n) {
+        return stdx::make_tuple(std::forward<N>(n));
+    }
+
+  public:
+    template <typename... Ts>
+    constexpr auto operator()(Ts &&...ts) const
+        noexcept(noexcept(tag_invoke(std::declval<get_all_mentioned_nodes_t>(),
+                                     std::forward<Ts>(ts)...)))
+            -> decltype(tag_invoke(*this, std::forward<Ts>(ts)...)) {
+        return tag_invoke(*this, std::forward<Ts>(ts)...);
+    }
+} get_all_mentioned_nodes{};
+
 constexpr inline class get_edges_t {
     friend constexpr auto tag_invoke(get_edges_t, node auto const &) {
         return stdx::tuple{};