# indexer_node

[flow_graph.indexer_node]

`indexer_node` broadcasts messages received at input ports to all of its successors. The messages are broadcast individually as they are received at each port. The output is a tagged message that contains a tag and a value; the tag identifies the input port on which the message was received.

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

    namespace oneapi {
    namespace tbb {
    namespace flow {

        template<typename T0, typename... TN>
        class indexer_node : public graph_node, public sender</*implementation_defined*/> {
        public:
            indexer_node(graph &g);
            indexer_node(const indexer_node &src);

            using input_ports_type = /*implementation_defined*/;
            input_ports_type &input_ports();

            using output_type = tagged_msg<size_t, T0, TN...>;
            bool try_get( output_type &v );
        };

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

Requirements:

- The `T0` type and all types in `TN` template parameter pack must meet the CopyConstructible requirements from [copyconstructible] ISO C++ Standard section.

An `indexer_node` is a `graph_node` and `sender<tagged_msg<size_t, T0, TN...>>`. It contains a tuple of input ports, each of which is a `receiver` specified by corresponding input template parameter pack element. It supports multiple input receivers with distinct types and broadcasts each received message to all of its successors. Unlike a `join_node`, each message is broadcast individually to all successors of the `indexer_node` as it arrives at an input port. Before broadcasting, a message is tagged with the index of the port on which the message arrived.

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

The function template input_port simplifies the syntax for getting a reference to a specific input port.

## Member types

- `input_ports_type` is an alias to a `std::tuple` of input ports.

- `output_type` is an alias to the message of type `tagged_msg`, which is sent to successors.

## Member functions

indexer_node(graph &g)

  Constructs an `indexer_node` that belongs to the graph `g`.

indexer_node(const indexer_node &src)

  Constructs an `indexer_node`. The list of predecessors, messages in the input ports, and successors are not copied.

input_ports_type &input_ports()

  Returns: A `std::tuple` of receivers. Each element inherits from `receiver<T>` where `T` is the type of message expected at that input. Each tuple element can be used like any other `receiver<T>`.

bool try_get(output_type &v)

  An `indexer_node` contains no buffering and therefore does not support gets.

  Returns: `false`.

See also:

- input_port function template

- tagged_msg template class