# `resource_limiter` Class

## Description

The class `resource_limiter<ResourceHandle>` represents a Provider that manages one or more resource handles of type `ResourceHandle`.

It provides exclusive access to managed resources to the consumers – `resource_limited_node` instances.

For some resource types, the `ResourceHandle` represents the resource itself. For other resource types, the `ResourceHandle` may represent a lightweight entity used to access the resource.

    tbb::flow::resource_limiter<int> int_limiter{1, 2, 3};

    using db_resource_handle = std::unique_ptr<Database, CloseDatabase>;
    tbb::flow::resource_limiter<db_resource_handle> db_limiter{open_database()};

In the example above, `int_limiter` manages three resources of type `int`, and `db_limiter` manages a single handle to a resource of type `Database`.

All the resource handles managed by the `resource_limiter` are considered equivalent, and the order in which the access to resources is granted to consumers is unspecified.

## API

### Header

    #define TBB_PREVIEW_FLOW_GRAPH_FEATURES 1
    // or
    #define TBB_PREVIEW_FLOW_GRAPH_RESOURCE_LIMITING 1

    #include <oneapi/tbb/flow_graph.h>

### Synopsis

    namespace oneapi {
        namespace tbb {
            namespace flow {

                template <typename ResourceHandle>
                class resource_limiter {
                public:
                    using resource_handle_type = ResourceHandle;

                    template <typename Handle, typename... Handles>
                    resource_limiter(Handle&& handle, Handles&&... handles);

                    ~resource_limiter();
                }; // class resource_limiter

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

### Requirements

`ResourceHandle` type must meet the `MoveConstructible` requirements from [moveconstructible] and the `MoveAssignable` requirements from [moveassignable] sections of the ISO C++ Standard.

### Member Types

    using resource_handle_type = ResourceHandle;

An alias to the resource handle type.

### Member Functions

    template <typename Handle, typename... Handles>
    resource_limiter(Handle&& handle, Handles&&... handles);

Requirements: `ResourceHandle` type must be constructible from `std::forward<Handle>(handle)`, and from `std::forward<H>(h)` for each `H` in `Handles` and for each `h` in `handles`.

Constructs a `resource_limiter` that manages at least one resource.

Each resource is constructed from the corresponding argument in `handle` or `handles`.

    ~resource_limiter();

Destroys the `resource_limiter`.

If there are consumers that still reference the limiter, the behavior is undefined.