# queue_node

[flow_graph.queue_node]

A node that forwards messages in a first-in first-out (FIFO) order.

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

    namespace oneapi {
    namespace tbb {
    namespace flow {

        template <typename T >
        class queue_node : public graph_node, public receiver<T>, public sender<T> {
        public:
            explicit queue_node( graph &g );
            queue_node( const queue_node &src );
            ~queue_node();

            bool try_put( const T &v );
            bool try_get( T &v );
        };

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

Requirements:

- The type `T` must meet the CopyConstructible requirements from [copyconstructible] and CopyAssignable requirements from [copyassignable] ISO C++ Standard sections.

`queue_node` forwards messages in a FIFO order to a single successor in its successor set.

`queue_node` is a `graph_node`, `receiver` and `sender`.

`queue_node` has a buffering and single-push properties.

## Member functions

explicit queue_node(graph &g)

  Constructs an empty `queue_node` that belongs to the graph `g`.

queue_node(const queue_node &src)

  Constructs an empty `queue_node` that belongs to the same graph `g` as `src`. Any intermediate state of `src`, including its links to predecessors and successors, is not copied.

bool try_put(const T &v)

  Adds `v` to the set of items managed by the node, and tries forwarding the least recently added item to a successor.

  Returns: `true`.

bool try_get(T &v)

  Returns: `true` if an item can be taken from the node and assigned to `v`. Returns `false` if there is no item currently in the `queue_node` or if the node is reserved.

## Example

Usage scenario is similar to buffer_node except that messages are passed in first-in first-out (FIFO) order.