A template class that is a receiver<TupleType> and has a tuple of sender< tuple_element< i, TupleType >::type > output ports; where i is the index in the tuple. A split_node sends each element of the incoming tuple to the output port that matches the element's index in the incoming tuple. This node has unlimited concurrency.
template < typename TupleType > class split_node;
#include "tbb/flow_graph.h"
This node receives a tuple at its single input port and generates a message from each element of the tuple, passing each to the corresponding output port.
A split_node has unlimited concurrency, no buffering, and behaves as a broadcast_node with multiple output ports.
The example below shows a split_node that separates a stream of tuples of integers, placing each element of the tuple in the appropriate output queue.
The output ports of the split_node can be connected to other graph nodes using the make_edge method or by using register_successor:
#include "tbb/flow_graph.h"
using namespace tbb::flow;
int main() {
graph g;
queue_node<int> first_queue(g);
queue_node<int> second_queue(g);
split_node< flow::tuple<int,int> > my_split_node(g);
output_port<0>(my_split_node).register_successor(first_queue);
make_edge(output_port<1>(my_split_node), second_queue);
for(int i = 0; i < 1000; ++i) {
node1.try_put(int_tuple_type(2*i,2*i+1));
}
g.wait_for_all();
}
namespace tbb {
template < typename TupleType >
class split_node : public graph_node, public receiver<TupleType>
{
public:
split_node( graph &g );
split_node( const split_node &other);
~split_node();
// receiver< TupleType >
typedef TupleType input_type;
typedef sender<input_type> predecessor_type;
bool try_put( const input_type &v );
bool register_predecessor( predecessor_type &p );
bool remove_predecessor( predecessor_type &p );
typedef implementation-dependent output_ports_type;
output_ports_type& output_ports();
};
}
| Member | Description |
|---|---|
| split_node( graph &g ) |
Constructs a split_node registered with graph g. |
| split_node( const split_node &other) |
Constructs a split_node that has the same initial state that other had when it was constructed. The split_node that is constructed will have a reference to the same graph object as other. The predecessors and successors of other will not be copied. |
| ~split_node() |
Destructor |
| bool try_put( const input_type &v ) |
Broadcasts each element of the incoming tuple to the nodes connected to the split_node's output ports. The element at index i of vi will be broadcast through the ith output port. Returns: true |
| bool register_predecessor( predecessor_type &p ) |
Adds p to the set of predecessors. Returns: true |
| bool remove_predecessor( predecessor_type &p ) |
Removes p from the set of predecessors. Returns: true |
| output_ports_type& output_ports(); |
Returns: a tuple of output ports. |