# combinable

[tls.combinable]

A class template for holding thread-local values during a parallel computation that will be merged into a final value.

A `combinable` provides each thread with its own instance of type `T`.

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

    namespace oneapi {
    namespace tbb {
        template <typename T>
        class combinable {
        public:
            combinable();

            combinable(const combinable& other);
            combinable(combinable&& other);

            template <typename FInit>
            explicit combinable(FInit finit);

            ~combinable();

            combinable& operator=( const combinable& other);
            combinable& operator=( combinable&& other);

            void clear();

            T& local();
            T& local(bool & exists);

            template<typename BinaryFunc> T combine(BinaryFunc f);
            template<typename UnaryFunc> void combine_each(UnaryFunc f);
        };
    } // namespace tbb
    } // namespace oneapi

## Member functions

combinable()

  Constructs `combinable` such that thread-local instances of `T` will be default-constructed.

template<typename FInit>
explicit combinable(FInit finit)

  Constructs `combinable` such that thread-local elements will be created by copying the result of finit().

  Caution

  The expression finit() must be safe to evaluate concurrently by multiple threads. It is evaluated each time a new thread-local element is created.

combinable(const combinable &other)

  Constructs a copy of other, so that it has copies of each element in other with the same thread mapping.

combinable(combinable &&other)

  Constructs `combinable` by moving the content of other intact. other is left in an unspecified state but can be safely destroyed.

~combinable()

  Destroys all elements in `*this`.

combinable &operator=(const combinable &other)

  Sets `*this` to be a copy of other. Returns a reference to `*this`.

combinable &operator=(combinable &&other)

  Moves the content of other to `*this` intact. other is left in an unspecified state but can be safely destroyed. Returns a reference to `*this`.

void clear()

  Removes all elements from `*this`.

T &local()

  If an element does not exist for the current thread, creates it.

  Returns: Reference to thread-local element.

T &local(bool &exists)

  Similar to `local()`, except that exists is set to true if an element was already present for the current thread; false, otherwise.

  Returns: Reference to thread-local element.

template<typename BinaryFunc>
T combine(BinaryFunc f)

  Requires: A `BinaryFunc` must meet the Function Objects requirements described in the [function.objects] section of the ISO C++ standard. Specifically, the type should be an associative binary functor with the signature `T BinaryFunc(T,T)` or `T BinaryFunc(const T&,const T&)`. A `T` type must be the same as a corresponding template parameter for the `combinable` object.

  Effects: Computes a reduction over all elements using binary functor f. All evaluations of f are done sequentially in the calling thread. If there are no elements, creates the result using the same rules as for creating a new element.

  Returns: Result of the reduction.

template<typename UnaryFunc>
void combine_each(UnaryFunc f)

  Requires: An `UnaryFunc` must meet the Function Objects requirements described in the [function.objects] section of the ISO C++ standard. Specifically, the type should be an unary functor with the one of the signatures: `void UnaryFunc(T)`, `void UnaryFunc(T&)`, or `void UnaryFunc(const T&)` A `T` type must be the same as a corresponding template parameter for the `enumerable_thread_specific` object.

  Effects: Evaluates f(x) for each thread-local element x in `*this`. All evaluations are done sequentially in the calling thread.

Note

Methods of `class combinable` are not thread-safe, except for `local`.