🎨 Use flow log spec if step log spec is not defined

Author: elbeno

include/flow/builder.hpp

@@ -4,7 +4,6 @@
 #include <flow/common.hpp>
 #include <flow/graph_builder.hpp>
 #include <flow/impl.hpp>
-#include <log/level.hpp>
 
 #include <stdx/ct_string.hpp>
 

include/flow/graph_builder.hpp

@@ -27,7 +27,13 @@
 namespace flow {
 namespace detail {
 template <typename T> using is_duplicated = std::bool_constant<(T::size() > 1)>;
-}
+
+template <typename CTNode, typename Output>
+concept is_output_compatible = requires(CTNode n) {
+    { Output::create_node(n) } -> std::same_as<typename Output::node_t>;
+};
+} // namespace detail
+
 template <typename T> using name_for = typename T::name_t;
 
 [[nodiscard]] constexpr auto edge_size(auto const &nodes,
@@ -57,12 +63,14 @@ template <stdx::ct_string Name,
           template <stdx::ct_string, std::size_t> typename Impl>
 struct graph_builder {
     // NOLINTBEGIN(readability-function-cognitive-complexity)
-    template <typename Node, std::size_t N, std::size_t E>
+    template <typename Output, std::size_t N, std::size_t E>
     [[nodiscard]] constexpr static auto make_graph(auto const &nodes,
                                                    auto const &edges) {
-        using graph_t = stdx::cx_multimap<Node, Node, N, E>;
+        using output_node_t = typename Output::node_t;
+        using graph_t = stdx::cx_multimap<output_node_t, output_node_t, N, E>;
         graph_t g{};
-        for_each([&](auto const &node) { g.put(node); }, nodes);
+        for_each([&]<typename Node>(Node n) { g.put(Output::create_node(n)); },
+                 nodes);
 
         auto const named_nodes = stdx::apply_indices<name_for>(nodes);
         for_each(
@@ -96,7 +104,7 @@ struct graph_builder {
                     },
                     node_ps);
 
-                g.put(lhs, rhs);
+                g.put(Output::create_node(lhs), Output::create_node(rhs));
             },
             edges);
         return g;
@@ -213,18 +221,16 @@ struct graph_builder {
         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;
-
         static_assert(
             all_of(
                 []<typename N>(N const &) {
-                    return std::is_convertible_v<N, rt_node_t>;
+                    return detail::is_output_compatible<N, output_t>;
                 },
                 node_set),
             "Output node type is not compatible with given input nodes");
 
-        auto g = make_graph<rt_node_t, node_capacity, edge_capacity>(node_set,
-                                                                     edges);
+        auto g =
+            make_graph<output_t, node_capacity, edge_capacity>(node_set, edges);
         return topo_sort<output_t>(g);
     }
 

include/flow/impl.hpp

@@ -4,6 +4,7 @@
 #include <flow/step.hpp>
 #include <log/log.hpp>
 
+#include <stdx/ct_string.hpp>
 #include <stdx/cx_vector.hpp>
 #include <stdx/span.hpp>
 
@@ -13,6 +14,41 @@
 #include <type_traits>
 
 namespace flow {
+namespace detail {
+template <typename CTNode> constexpr auto run_func() -> void {
+    if (CTNode::condition) {
+        typename CTNode::func_t{}();
+    }
+}
+
+template <typename Flow, typename CTNode> constexpr auto log_func() -> void {
+    if (CTNode::condition) {
+        using log_spec_t = decltype(get_log_spec<CTNode, Flow>());
+        CIB_LOG(typename log_spec_t::flavor, log_spec_t::level, "flow.{}({})",
+                typename CTNode::type_t{}, typename CTNode::name_t{});
+    }
+}
+} // namespace detail
+
+struct rt_node {
+    constexpr rt_node() = default;
+
+    template <typename Flow, typename CTNode> constexpr rt_node(Flow, CTNode) {
+        // GCC wants these to be explicitly marked constexpr
+        constexpr auto rf = detail::run_func<CTNode>;
+        constexpr auto lf = detail::log_func<Flow, CTNode>;
+        run = rf;
+        log_name = lf;
+    }
+
+    FunctionPtr run{};
+    FunctionPtr log_name{};
+
+  private:
+    friend constexpr auto operator==(rt_node const &,
+                                     rt_node const &) -> bool = default;
+};
+
 /**
  * flow::impl is a constant representation of a series of Milestones and actions
  * to be executed in a specific order.
@@ -45,11 +81,16 @@ template <stdx::ct_string Name, std::size_t NumSteps> class impl {
   public:
     stdx::cx_vector<FunctionPtr, capacity> functionPtrs{};
 
-    using node_t = rt_node;
     constexpr static bool active = capacity > 0;
-
     constexpr static auto name = Name;
 
+    using node_t = rt_node;
+
+    template <typename CTNode>
+    constexpr static auto create_node(CTNode n) -> node_t {
+        return node_t{log_spec_id_t<Name>{}, n};
+    }
+
     /**
      * Create a new flow::impl of Milestones.
      *
@@ -60,17 +101,16 @@ template <stdx::ct_string Name, std::size_t NumSteps> class impl {
      *
      * @see flow::builder
      */
-    constexpr explicit(true)
-        impl(stdx::span<node_t const, NumSteps> newMilestones) {
+    constexpr explicit(true) impl(stdx::span<node_t const, NumSteps> steps) {
         if constexpr (loggingEnabled) {
-            for (auto const &milestone : newMilestones) {
-                functionPtrs.push_back(milestone.log_name);
-                functionPtrs.push_back(milestone.run);
+            for (auto const &step : steps) {
+                functionPtrs.push_back(step.log_name);
+                functionPtrs.push_back(step.run);
             }
         } else {
-            std::transform(std::cbegin(newMilestones), std::cend(newMilestones),
+            std::transform(std::cbegin(steps), std::cend(steps),
                            std::back_inserter(functionPtrs),
-                           [](auto const &milestone) { return milestone.run; });
+                           [](auto const &step) { return step.run; });
         }
     }
 };

include/flow/log.hpp

@@ -2,6 +2,8 @@
 
 #include <log/log.hpp>
 
+#include <stdx/ct_string.hpp>
+
 #include <type_traits>
 
 namespace flow {
@@ -12,21 +14,23 @@ struct default_log_spec {
 template <stdx::ct_string, typename...>
 constexpr auto log_spec = default_log_spec{};
 
-template <typename T, typename... DummyArgs>
+template <stdx::ct_string Name> struct log_spec_id_t {
+    constexpr static auto ct_name = Name;
+};
+
+template <typename T, typename Fallback = log_spec_id_t<"default">,
+          typename... DummyArgs>
     requires(sizeof...(DummyArgs) == 0)
 constexpr static auto get_log_spec() {
-    if constexpr (std::is_same_v<decltype(log_spec<T::ct_name, DummyArgs...>),
-                                 default_log_spec const>) {
-        return log_spec<"default", DummyArgs...>;
+    using log_spec_t = decltype(log_spec<T::ct_name, DummyArgs...>);
+    if constexpr (std::is_same_v<log_spec_t, default_log_spec const>) {
+        if constexpr (Fallback::ct_name == stdx::ct_string{"default"}) {
+            return log_spec<Fallback::ct_name, DummyArgs...>;
+        } else {
+            return get_log_spec<Fallback>();
+        }
     } else {
-        return log_spec<T::ct_name, DummyArgs...>;
+        return log_spec_t{};
     }
 }
-
-template <typename T, typename... DummyArgs, typename... Args>
-auto log_with_spec(Args &&...args) {
-    using log_spec_t = decltype(get_log_spec<T, DummyArgs...>());
-    logging::log<typename log_spec_t::flavor, log_spec_t::level,
-                 cib_log_module_id_t>(std::forward<Args>(args)...);
-}
 } // namespace flow

include/flow/step.hpp

@@ -14,55 +14,20 @@
 #include <type_traits>
 
 namespace flow {
-struct rt_node {
-    FunctionPtr run;
-    FunctionPtr log_name;
-
-  private:
-    friend constexpr auto operator==(rt_node const &,
-                                     rt_node const &) -> bool = default;
-};
-
-namespace detail {
-template <typename Cond, typename F> constexpr auto run_func() -> void {
-    if (Cond{}) {
-        F{}();
-    }
-}
-
-template <typename ct_node, typename Cond, stdx::ct_string Type,
-          stdx::ct_string Name>
-constexpr auto log_func() -> void {
-    if (Cond{}) {
-        using log_spec_t = decltype(get_log_spec<ct_node>());
-        CIB_LOG(typename log_spec_t::flavor, log_spec_t::level, "flow.{}({})",
-                stdx::ct_string_to_type<Type, sc::string_constant>(),
-                stdx::ct_string_to_type<Name, sc::string_constant>());
-    }
-}
-} // namespace detail
-
 template <stdx::ct_string Type, stdx::ct_string Name,
           subgraph_identity Identity, typename Cond, typename F>
 struct ct_node {
     using is_subgraph = void;
     using type_t =
         decltype(stdx::ct_string_to_type<Type, sc::string_constant>());
-
     using name_t =
         decltype(stdx::ct_string_to_type<Name, sc::string_constant>());
+    using func_t = F;
 
     constexpr static auto ct_name = Name;
-
     constexpr static auto identity = Identity;
-
     constexpr static auto condition = Cond{};
 
-    constexpr operator rt_node() const {
-        return rt_node{detail::run_func<Cond, F>,
-                       detail::log_func<ct_node, Cond, Type, Name>};
-    }
-
     constexpr auto operator*() const {
         if constexpr (Identity == subgraph_identity::REFERENCE) {
             return ct_node<Type, Name, subgraph_identity::VALUE, Cond, F>{};

include/seq/impl.hpp

@@ -24,6 +24,11 @@ template <stdx::ct_string, std::size_t NumSteps> struct impl {
 
     using node_t = rt_step;
 
+    template <typename CTNode>
+    constexpr static auto create_node(CTNode n) -> node_t {
+        return n;
+    }
+
     constexpr explicit(true) impl(stdx::span<node_t const, NumSteps> steps) {
         for (auto const &step : steps) {
             _forward_steps.push_back(step.forward_ptr);

test/flow/custom_log_levels.cpp

@@ -30,6 +30,7 @@ constexpr auto run_flow = []() -> void {
 
 struct TestFlowA : public flow::service<"A"> {};
 struct TestFlowB : public flow::service<"B"> {};
+struct TestFlowC : public flow::service<"C"> {};
 
 constexpr auto msA = flow::milestone<"msA">();
 constexpr auto msB = flow::milestone<"msB">();
@@ -81,3 +82,15 @@ TEST_CASE("override log level by name", "[flow_custom_log_levels]") {
     CHECK(log_calls[1] == logging::level::USER2);
     CHECK(log_calls[2] == logging::level::USER1);
 }
+
+template <> constexpr auto flow::log_spec<"C"> = user1_log_spec{};
+
+TEST_CASE("default log spec for step will use overridden log spec for flow",
+          "[flow_custom_log_levels]") {
+    run_flow<TestFlowC, cib::exports<TestFlowC>,
+             cib::extend<TestFlowC>(*msA)>();
+
+    REQUIRE(log_calls.size() == 3);
+    std::for_each(std::begin(log_calls), std::end(log_calls),
+                  [](auto level) { CHECK(level == logging::level::USER1); });
+}