Apply review comments

Author: kboyarinov

include/oneapi/tbb/detail/_flow_graph_indexer_impl.h

@@ -224,22 +224,22 @@
     };  //indexer_node_base
 
     // type generators
-    template<typename T0, typename... TN>
+    template<typename... TN>
     struct indexer_types {
-        using output_type = tagged_msg<std::size_t, T0, TN...>;
-        using input_ports_type = std::tuple<indexer_input_port<T0>, indexer_input_port<TN>...>;
-        using indexer_base_type = indexer_node_base<input_ports_type, output_type, std::tuple<T0, TN...>>;
+        using output_type = tagged_msg<std::size_t, TN...>;
+        using input_ports_type = std::tuple<indexer_input_port<TN>...>;
+        using indexer_base_type = indexer_node_base<input_ports_type, output_type, std::tuple<TN...>>;
     };
 
-    template<typename... T>
-    class unfolded_indexer_node : public indexer_types<T0, TN...>::indexer_base_type {
+    template<typename... TN>
+    class unfolded_indexer_node : public indexer_types<TN...>::indexer_base_type {
     public:
-        using input_ports_type = typename indexer_types<T0, TN...>::input_ports_type;
-        using output_type = typename indexer_types<T0, TN...>::output_type;
-        using tuple_types = std::tuple<T0, TN...>;
+        using input_ports_type = typename indexer_types<TN...>::input_ports_type;
+        using output_type = typename indexer_types<TN...>::output_type;
+        using tuple_types = std::tuple<TN...>;
 
     private:
-        using base_type = typename indexer_types<T0, TN...>::indexer_base_type;
+        using base_type = typename indexer_types<TN...>::indexer_base_type;
     public:
         unfolded_indexer_node(graph& g) : base_type(g) {}
         unfolded_indexer_node(const unfolded_indexer_node &other) : base_type(other) {}

include/oneapi/tbb/flow_graph.h

@@ -961,7 +961,7 @@ class function_node
 
 //! implements a function node that supports Input -> (set of outputs)
 // Output is a tuple of output types.
-template<typename Input, typename Output, typename Policy = queueing>
+template<typename Input, typename OutputTuple, typename Policy = queueing>
     __TBB_requires(std::default_initializable<Input> &&
                    std::copy_constructible<Input>)
 class multifunction_node :
@@ -980,11 +980,11 @@ class multifunction_node :
     typedef cache_aligned_allocator<Input> internals_allocator;
 
 protected:
-    static const int N = std::tuple_size<Output>::value;
+    static const int N = std::tuple_size<OutputTuple>::value;
 public:
     using input_type = Input;
     using output_type = null_type;
-    typedef typename wrap_tuple_elements<multifunction_output, Output>::type output_ports_type;
+    using output_ports_type = typename wrap_tuple_elements<multifunction_output, OutputTuple>::type;
     using input_impl_type =
         multifunction_input<input_type, output_ports_type, Policy, internals_allocator>;
     using input_queue_type = function_input_queue<input_type, internals_allocator>;

test/common/graph_utils.h

@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2005-2025 Intel Corporation
+    Copyright (c) 2025 UXL Foundation Contributors
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -970,4 +971,45 @@ void test(unsigned N) {
 
 } // namespace lightweight_testing
 
+template <std::size_t N>
+struct edge_maker {
+    template <typename Sender, typename NodeType>
+    static void make(Sender& sender, NodeType& node) {
+        oneapi::tbb::flow::make_edge(sender, oneapi::tbb::flow::input_port<N - 1>(node));
+        edge_maker<N - 1>::make(sender, node);
+    }
+
+    template <typename Sender, typename NodeType>
+    static void make(std::vector<Sender>& senders, NodeType& node) {
+        oneapi::tbb::flow::make_edge(senders[N - 1], oneapi::tbb::flow::input_port<N - 1>(node));
+        edge_maker<N - 1>::make(senders, node);
+    }
+};
+
+template <>
+struct edge_maker<0> {
+    template <typename Sender, typename NodeType>
+    static void make(Sender&, NodeType&) {}
+};
+
+template <std::size_t N>
+struct assert_all_items_equal_impl {
+    template <typename TupleLike, typename Message>
+    static void compare(const TupleLike& tuple_like, const Message& message) {
+        CHECK_MESSAGE(std::get<N - 1>(tuple_like) == message, "Unexpected element");
+        assert_all_items_equal_impl<N - 1>::compare(tuple_like, message);
+    }
+};
+
+template <>
+struct assert_all_items_equal_impl<0> {
+    template <typename TupleLike, typename Message>
+    static void compare(const TupleLike&, const Message&) {}
+};
+
+template <typename TupleLike, typename Message>
+void assert_all_items_equal_to(const TupleLike& tuple_like, const Message& message) {
+    assert_all_items_equal_impl<std::tuple_size<TupleLike>::value>::compare(tuple_like, message);
+}
+
 #endif  // __TBB_harness_graph_H

test/conformance/conformance_flowgraph.h

@@ -1,6 +1,5 @@
 /*
     Copyright (c) 2020-2025 Intel Corporation
-    Copyright (c) 2025 UXL Foundation Contributors
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -812,25 +811,4 @@ void test_with_reserving_join_node_class() {
         if at least one successor accepts the tuple must consume messages");
 }
 }
-
-template <std::size_t N>
-struct edge_maker {
-    template <typename Sender, typename NodeType>
-    static void make(Sender& sender, NodeType& node) {
-        oneapi::tbb::flow::make_edge(sender, oneapi::tbb::flow::input_port<N - 1>(node));
-        edge_maker<N - 1>::make(sender, node);
-    }
-
-    template <typename Sender, typename NodeType>
-    static void make(std::vector<Sender>& senders, NodeType& node) {
-        oneapi::tbb::flow::make_edge(senders[N - 1], oneapi::tbb::flow::input_port<N - 1>(node));
-        edge_maker<N - 1>::make(senders, node);
-    }
-};
-
-template <>
-struct edge_maker<0> {
-    template <typename Sender, typename NodeType>
-    static void make(Sender&, NodeType&) {}
-};
 #endif // __TBB_test_conformance_conformance_flowgraph_H

test/conformance/conformance_join_node.cpp

@@ -351,26 +351,6 @@ join_node_type_generator_t<N, JoinPolicy> make_join_node(oneapi::tbb::flow::grap
     return make_join_node_helper<N, JoinPolicy, N, BodyToGenerate...>::make(g, body...);
 }
 
-template <std::size_t N>
-struct tuple_assert_impl {
-    template <typename Tuple, typename Message>
-    static void make(const Tuple& tuple, const Message& message) {
-        CHECK_MESSAGE(std::get<N - 1>(tuple) == message, "Unexpected tuple element");
-        tuple_assert_impl<N - 1>::make(tuple, message);
-    }
-};
-
-template <>
-struct tuple_assert_impl<0> {
-    template <typename Tuple, typename Message>
-    static void make(const Tuple&, const Message&) {}
-};
-
-template <std::size_t N, typename Tuple, typename Message>
-void tuple_assert(const Tuple& tuple, const Message& message) {
-    tuple_assert_impl<N>::make(tuple, message);
-}
-
 template <typename JoinPolicy, std::size_t N, typename... Body>
 void test_join_node_with_n_inputs_impl(Body... body) {
     static_assert(sizeof...(Body) <= 1, "Unexpected arguments");
@@ -391,7 +371,7 @@ void test_join_node_with_n_inputs_impl(Body... body) {
 
     std::size_t body_counter = 0;
     function_node<output_tuple> function(g, serial, [&](const output_tuple& tuple) {
-        tuple_assert<N>(tuple, message);
+        assert_all_items_equal_to(tuple, message);
         ++body_counter;
     });