A node that generates messages by invoking the user-provided functor and broadcasts the result to all of its successors.

// Defined in header <oneapi/tbb/flow_graph.h>

namespace oneapi {
namespace tbb {
namespace flow {

    template < typename Output >
    class input_node : public graph_node, public sender<Output> {
        template< typename Body >
        input_node( graph &g, Body body );
        input_node( const input_node &src );

        void activate();
        bool try_get( Output &v );

} // namespace flow
} // namespace tbb
} // namespace oneapi


  • The Output type must meet the DefaultConstructible requirements from [defaultconstructible], CopyConstructible requirements from [copyconstructible] and CopyAssignable requirements from [copyassignable] ISO C++ Standard sections.

  • The type Body must meet the InputNodeBody requirements.

This node can have no predecessors. It executes a user-provided body function object to generate messages that are broadcast to all successors. It is a serial node and never calls its body concurrently. This node can buffer a single item. If no successor accepts an item that it has generated, the message is buffered and provided to successors before a new item is generated.

input_node is a graph_node and sender<Output>.

input_node has a buffering and broadcast-push properties.

An input_node continues to invoke body and broadcast messages until the body toggles fc.stop() or it has no valid successors. A message may be generated and then rejected by all successors. In this case, the message is buffered and will be the next message sent once a successor is added to the node or try_get is called. Calls to try_get return a message from the buffer, or invoke body to attempt to generate a new message. A call to body is made only when the buffer is empty.

The body object passed to an input_node is copied. Updates to member variables do not affect the original object used to construct the node. If the state held within a body object must be inspected from outside of the node, the copy_body function can be used to obtain an updated copy.

Member functions

template<typename Body>
input_node(graph &g, Body body)

Constructs an input_node that invokes body. By default, the node is created in an inactive state, which means that messages are not generated until a call to activate is made.

input_node(const input_node &src)

Constructs an input_node that has the same initial state that src had when it was constructed. The input_node that is constructed has a reference to the same graph object as src, has a copy of the initial body used by src, and has the same initial active state as src. The successors of src are not copied.

The new body object is copy-constructed from a copy of the original body provided to src at its construction. Changes made to member variables in src body after the construction of src do not affect the body of the new input_node.

void activate()

Sets the input_node to the active state, which enables messages generation.

bool try_get(Output &v)

Copies the message from the buffer to v if available, or, if the node is in active state, invokes body to attempt to generate a new message that will be copied into v.

Returns: true if a message is copied to v; false, otherwise.

Deduction Guides

template <typename Body>
input_node(graph&, Body) -> input_node<std::decay_t<input_t<Body>>>;


  • input_t is an alias to Body input argument type.