# multifunction_node

[flow_graph.multifunction_node]

A node that used for nodes that receive messages at a single input port and may generate one or more messages that are broadcast to successors.

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

    namespace oneapi {
    namespace tbb {
    namespace flow {

        template < typename Input, typename Output, typename Policy = /*implementation-defined*/ >
        class multifunction_node : public graph_node, public receiver<Input> {
        public:
            template<typename Body>
            multifunction_node( graph &g, size_t concurrency, Body body, Policy /*unspecified*/ = Policy(),
                                node_priority_t priority = no_priority );
            template<typename Body>
            multifunction_node( graph &g, size_t concurrency, Body body,
                                node_priority_t priority = no_priority );

            multifunction_node( const multifunction_node& other );
            ~multifunction_node();

            bool try_put( const Input &v );

            using output_ports_type = /*implementation-defined*/;
            output_ports_type& output_ports();
        };

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

Requirements:

- The `Input` type must meet the DefaultConstructible requirements from [defaultconstructible] and the CopyConstructible requirements from [copyconstructible] ISO C++ Standard sections.

- The type `Policy` can be specified as lightweight, queueing and rejecting policies or defaulted.

- The type `Body` must meet the MultifunctionNodeBody requirements. Since C++17, `Body` may also be a pointer to a const member function in `Input` that takes `output_ports_type&` argument.

`multifunction_node` has a user-settable concurrency limit. It can be set to one of predefined values. The user can also provide a value of type `std::size_t` to limit concurrency to a value between 1 and tbb::flow::unlimited.

When the concurrency limit allows, it executes the user-provided body on incoming messages. The body can create one or more output messages and broadcast them to successors.

`multifunction_node` is a `graph_node`, `receiver<InputType>` and has a tuple of `sender<Output>` outputs.

`multifunction_node` has a discarding and broadcast-push properties.

The body object passed to a `multifunction_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 types

`output_ports_type` is an alias to a `std::tuple` of output ports.

## Member functions

    template<typename Body>
    multifunction_node( graph &g, size_t concurrency, Body body,
                        node_priority_t priority = no_priority );

Constructs a `multifunction_node` that invokes a copy of `body`. Most `concurrency` calls to `body` can be made concurrently.

Use this function to specify node priority.

    template<typename Body>
    multifunction_node( graph &g, size_t concurrency, Body body, Policy /*unspecified*/ = Policy(),
                        node_priority_t priority = no_priority );

Constructs a `multifunction_node` that invokes a copy of `body`. Most `concurrency` calls to `body` can be made concurrently.

Use this function to specify a policy and node priority.

    multifunction_node( const multifunction_node &src )

Constructs a `multifunction_node` that has the same initial state that `other` had when it was constructed. The `multifunction_node` that is constructed has a reference to the same `graph` object as `other`, has a copy of the initial `body` used by `other`, and has the same concurrency threshold as `other`. The predecessors and successors of `other` are not copied.

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

    bool try_put( const input_type &v )

If the concurrency limit allows, executes the user-provided body on the incoming message `v`. Otherwise, depending on the policy of the node, either queues the incoming message `v` or rejects it.

Returns: `true` if the input was accepted; `false`, otherwise.

    output_ports_type& output_ports();

Returns: a `std::tuple` of output ports.