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


template<typename Visitor, typename ...T>
auto traverse_pack_async(Visitor &&visitor, T&&... pack) -> decltype(detail::apply_pack_transform_async(HPX_FORWARD(Visitor, visitor), HPX_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:

    // 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 this 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
    it's called later. // The continuation next 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) { }

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

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

  • 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 must have a virtual destructor!

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


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