hpx/pack_traversal/pack_traversal_async.hpp

Defined in header hpx/pack_traversal/pack_traversal_async.hpp.

See Public API for a list of names and headers that are part of the public HPX API.

namespace hpx

namespace util

Functions

template<typename Visitor, typename ...T>
auto traverse_pack_async(Visitor &&visitor, T&&... pack) -> decltype(detail::apply_pack_transform_async(std::forward<Visitor>(visitor), std::forward<T>(pack)...))

Traverses the pack with the given visitor in an asynchronous way.

This function works in the same way as traverse_pack, however, we are able to suspend and continue the traversal at later time. Thus, we require a visitor callable object which provides three operator() overloads as depicted by the code sample below:

struct my_async_visitor {
    // The synchronous overload is called for each object. It may
    // return false to suspend the current control. In that case the
    // overload below is called.
    template <typename T>
    bool operator()(async_traverse_visit_tag, T&& element)
    {
        return true;
    }

    // The asynchronous overload is called when the synchronous
    // overload returned false. In addition to the current visited
    // element, the overload is called with a continuation callable
    // object which resumes the traversal when called later.
    template <typename T, typename N>
    void operator()(async_traverse_detach_tag, T&& element, N&& next)
    {
    }

    // The overload is called when the traversal was finished. The
    // whole pack which was traversed asynchronously is passed.
    template <typename T>
    void operator()(async_traverse_complete_tag, T&& pack)
    {
    }
};

See traverse_pack for a detailed description about the traversal behavior and capabilities.

Parameters

• visitor – A visitor object which provides the three operator() overloads that were described above. Additionally, the visitor must be compatible for referencing it from a hpx::intrusive_ptr. The visitor should have a virtual destructor!

• pack – The arbitrary parameter pack which is traversed asynchronously. Nested objects inside containers and tuple like types are traversed recursively.

Returns

A hpx::intrusive_ptr that references an instance of the given visitor object.

template<typename Allocator, typename Visitor, typename ...T>
auto traverse_pack_async_allocator(Allocator const &alloc, Visitor &&visitor, T&&... pack) -> decltype(detail::apply_pack_transform_async_allocator(alloc, std::forward<Visitor>(visitor), std::forward<T>(pack)...))

Traverses the pack with the given visitor in an asynchronous way.

This function works in the same way as traverse_pack, however, we are able to suspend and continue the traversal at later time. Thus, we require a visitor callable object which provides three operator() overloads as depicted by the code sample below:

struct my_async_visitor {
    // The synchronous overload is called for each object. It may
    // return false to suspend the current control. In that case the
    // overload below is called.
    template <typename T>
    bool operator()(async_traverse_visit_tag, T&& element)
    {
        return true;
    }

    // The asynchronous overload is called when the synchronous
    // overload returned false. In addition to the current visited
    // element, this overload receives a continuation callable object
    // which resumes the traversal when called later. The continuation
    // may be stored and called later or dropped completely to abort
    // the traversal early.
    template <typename T, typename N>
    void operator()(async_traverse_detach_tag, T&& element, N&& next)
    {
    }

    // This overload is called when the traversal is finished. The
    // complete pack that was traversed asynchronously is passed.
    template <typename T>
    void operator()(async_traverse_complete_tag, T&& pack)
    {
    }
};

See traverse_pack for a detailed description about the traversal behavior and capabilities.

Parameters

• visitor – A visitor object which provides the three operator() overloads that were described above. Additionally, the visitor must be compatible for referencing it from a hpx::intrusive_ptr. The visitor should have a virtual destructor!

• pack – The arbitrary parameter pack which is traversed asynchronously. Nested objects inside containers and tuple like types are traversed recursively.

• alloc – Allocator instance to use to create the traversal frame.

Returns

A hpx::intrusive_ptr that references an instance of the given visitor object.