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,11 @@ template <typename Predicate, typename... Configs>
                                          Configs const &...configs) {
     return detail::conditional<Predicate, Configs...>{configs...};
 }
+
+template <typename Predicate, typename... Configs>
+    requires std::is_default_constructible_v<Predicate>
+[[nodiscard]] CONSTEVAL auto runtime_conditional(Predicate const &,
+                                                 Configs const &...configs) {
+    return detail::runtime_conditional<Predicate, Configs...>{configs...};
+}
 } // namespace cib

include/cib/detail/runtime_conditional.hpp

@@ -0,0 +1,43 @@
+#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/tuple.hpp>
+#include <stdx/tuple_algorithms.hpp>
+
+namespace cib::detail {
+template <typename Pred, typename... Configs>
+    requires std::is_default_constructible_v<Pred>
+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(Pred{}, 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();
+    }
+};
+} // namespace cib::detail

include/flow/detail/par.hpp

@@ -24,6 +24,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 +41,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 P, flow::dsl::node Lhs, flow::dsl::node Rhs>
+constexpr auto make_runtime_conditional(P, flow::dsl::par<Lhs, Rhs>) {
+    return flow::dsl::par{make_runtime_conditional(P{}, Lhs{}),
+                          make_runtime_conditional(P{}, Rhs{})};
+}

include/flow/detail/seq.hpp

@@ -24,6 +24,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);
@@ -40,9 +45,16 @@ template <node Lhs, node Rhs> struct seq {
 };
 
 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 P, flow::dsl::node Lhs, flow::dsl::node Rhs>
+constexpr auto make_runtime_conditional(P, flow::dsl::seq<Lhs, Rhs>) {
+    return flow::dsl::seq{make_runtime_conditional(P{}, Lhs{}),
+                          make_runtime_conditional(P{}, Rhs{})};
+}

include/flow/detail/walk.hpp

@@ -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{};

include/flow/graph_builder.hpp

@@ -11,6 +11,8 @@
 #include <stdx/tuple_algorithms.hpp>
 #include <stdx/type_traits.hpp>
 
+#include <boost/mp11/set.hpp>
+
 #include <algorithm>
 #include <array>
 #include <cstddef>
@@ -20,14 +22,21 @@
 #include <utility>
 
 namespace flow {
+namespace detail {
+template <typename T> using is_duplicated = std::bool_constant<(T::size() > 1)>;
+}
+template <typename T> using name_for = typename T::name_t;
+
 [[nodiscard]] constexpr auto edge_size(auto const &nodes,
                                        auto const &edges) -> std::size_t {
     auto const edge_capacities = transform(
         [&]<typename N>(N const &) {
             return edges.fold_left(
                 std::size_t{}, []<typename E>(auto acc, E const &) {
-                    if constexpr (std::is_same_v<typename E::source_t, N> or
-                                  std::is_same_v<typename E::dest_t, N>) {
+                    if constexpr (std::is_same_v<name_for<typename E::source_t>,
+                                                 name_for<N>> or
+                                  std::is_same_v<name_for<typename E::dest_t>,
+                                                 name_for<N>>) {
                         return ++acc;
                     } else {
                         return acc;
@@ -43,8 +52,6 @@ namespace flow {
 
 template <template <stdx::ct_string, std::size_t> typename Impl>
 struct graph_builder {
-    template <typename T> using name_for = typename T::name_t;
-
     template <typename Node, std::size_t N, std::size_t E>
     [[nodiscard]] constexpr static auto make_graph(auto const &nodes,
                                                    auto const &edges) {
@@ -119,13 +126,58 @@ struct graph_builder {
             std::span{std::cbegin(ordered_list), std::size(ordered_list)}};
     }
 
+    constexpr static void check_for_missing_nodes(auto nodes,
+                                                  auto mentioned_nodes) {
+        constexpr auto get_name = []<typename N>(N) ->
+            typename N::name_t { return {}; };
+        auto node_names = stdx::transform(get_name, nodes);
+        auto mentioned_node_names = stdx::transform(get_name, mentioned_nodes);
+
+        using node_names_t = decltype(stdx::to_sorted_set(node_names));
+        using mentioned_node_names_t =
+            decltype(stdx::to_sorted_set(mentioned_node_names));
+
+        if constexpr (not std::is_same_v<node_names_t,
+                                         mentioned_node_names_t>) {
+            using missing_nodes_t =
+                boost::mp11::mp_set_difference<mentioned_node_names_t,
+                                               node_names_t>;
+
+            static_assert(
+                stdx::always_false_v<missing_nodes_t>,
+                "A node is referenced in the graph but not explicitly added "
+                "with the unary plus operator. The beginning of this error "
+                "shows you which nodes are missing.");
+        }
+
+        if constexpr (stdx::tuple_size_v<node_names_t> !=
+                      stdx::tuple_size_v<decltype(node_names)>) {
+            auto duplicates = stdx::transform(
+                [](auto e) { return stdx::get<0>(e); },
+                stdx::filter<detail::is_duplicated>(stdx::gather(node_names)));
+
+            static_assert(stdx::always_false_v<decltype(duplicates)>,
+                          "A node is explicitly added more than once using the "
+                          "unary plus "
+                          "operator. The beginning of this error shows you "
+                          "which nodes are "
+                          "duplicated.");
+        }
+    }
+
     template <typename Graph>
     [[nodiscard]] constexpr static auto build(Graph const &input) {
         auto nodes = flow::dsl::get_nodes(input);
+        auto mentioned_nodes = flow::dsl::get_all_mentioned_nodes(input);
+
+        check_for_missing_nodes(nodes, mentioned_nodes);
+
+        auto node_set = stdx::to_unsorted_set(nodes);
+
         auto edges = flow::dsl::get_edges(input);
 
-        constexpr auto node_capacity = stdx::tuple_size_v<decltype(nodes)>;
-        constexpr auto edge_capacity = edge_size(nodes, edges);
+        constexpr auto node_capacity = stdx::tuple_size_v<decltype(node_set)>;
+        constexpr auto edge_capacity = edge_size(node_set, edges);
 
         using output_t = Impl<Graph::name, node_capacity>;
         using rt_node_t = typename output_t::node_t;
@@ -135,11 +187,11 @@ struct graph_builder {
                 []<typename N>(N const &) {
                     return std::is_convertible_v<N, rt_node_t>;
                 },
-                nodes),
+                node_set),
             "Output node type is not compatible with given input nodes");
 
-        auto g =
-            make_graph<rt_node_t, node_capacity, edge_capacity>(nodes, edges);
+        auto g = make_graph<rt_node_t, node_capacity, edge_capacity>(node_set,
+                                                                     edges);
         return topo_sort<output_t>(g);
     }
 
@@ -177,10 +229,17 @@ template <stdx::ct_string Name = "", typename Renderer = graph_builder<impl>,
           flow::dsl::node... Fragments>
 class graph {
     friend constexpr auto tag_invoke(flow::dsl::get_nodes_t, graph const &g) {
-        auto t = g.fragments.apply([](auto const &...frags) {
+        return g.fragments.apply([](auto const &...frags) {
             return stdx::tuple_cat(flow::dsl::get_nodes(frags)...);
         });
-        return stdx::to_unsorted_set(t);
+    }
+
+    friend constexpr auto tag_invoke(flow::dsl::get_all_mentioned_nodes_t,
+                                     graph const &g) {
+        return g.fragments.apply([](auto const &...frags) {
+            return stdx::tuple_cat(
+                flow::dsl::get_all_mentioned_nodes(frags)...);
+        });
     }
 
     friend constexpr auto tag_invoke(flow::dsl::get_edges_t, graph const &g) {