async.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/engine/async.hpp
/// @brief TaskWithResult creation helpers
 
#include <userver/engine/deadline.hpp>
#include <userver/engine/impl/task_context_factory.hpp>
#include <userver/engine/task/shared_task_with_result.hpp>
#include <userver/engine/task/task_processor_fwd.hpp>
#include <userver/engine/task/task_with_result.hpp>
#include <userver/utils/impl/wrapped_call.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace engine {
 
namespace impl {
 
template <template <typename> typename TaskType, typename Function, typename... Args>
[[nodiscard]] auto MakeTaskWithResult(
    TaskProcessor& task_processor,
    Task::Importance importance,
    Deadline deadline,
    Function&& f,
    Args&&... args
) {
    using ResultType = typename utils::impl::WrappedCallImplType<Function, Args...>::ResultType;
    constexpr auto kWaitMode = TaskType<ResultType>::kWaitMode;
 
    return TaskType<ResultType>{MakeTask(
        {task_processor, importance, kWaitMode, deadline}, std::forward<Function>(f), std::forward<Args>(args)...
    )};
}
 
}  // namespace impl
 
/// Runs an asynchronous function call using specified task processor
template <typename Function, typename... Args>
[[nodiscard]] auto AsyncNoSpan(TaskProcessor& task_processor, Function&& f, Args&&... args) {
    return impl::MakeTaskWithResult<TaskWithResult>(
        task_processor, Task::Importance::kNormal, {}, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// Runs an asynchronous function call using specified task processor
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsyncNoSpan(TaskProcessor& task_processor, Function&& f, Args&&... args) {
    return impl::MakeTaskWithResult<SharedTaskWithResult>(
        task_processor, Task::Importance::kNormal, {}, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// Runs an asynchronous function call with deadline using specified task
/// processor
template <typename Function, typename... Args>
[[nodiscard]] auto AsyncNoSpan(TaskProcessor& task_processor, Deadline deadline, Function&& f, Args&&... args) {
    return impl::MakeTaskWithResult<TaskWithResult>(
        task_processor, Task::Importance::kNormal, deadline, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// Runs an asynchronous function call with deadline using specified task
/// processor
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsyncNoSpan(TaskProcessor& task_processor, Deadline deadline, Function&& f, Args&&... args) {
    return impl::MakeTaskWithResult<SharedTaskWithResult>(
        task_processor, Task::Importance::kNormal, deadline, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// Runs an asynchronous function call using task processor of the caller
template <typename Function, typename... Args>
[[nodiscard]] auto AsyncNoSpan(Function&& f, Args&&... args) {
    return AsyncNoSpan(current_task::GetTaskProcessor(), std::forward<Function>(f), std::forward<Args>(args)...);
}
 
/// Runs an asynchronous function call using task processor of the caller
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsyncNoSpan(Function&& f, Args&&... args) {
    return SharedAsyncNoSpan(current_task::GetTaskProcessor(), std::forward<Function>(f), std::forward<Args>(args)...);
}
 
/// Runs an asynchronous function call with deadline using task processor of the
/// caller
template <typename Function, typename... Args>
[[nodiscard]] auto AsyncNoSpan(Deadline deadline, Function&& f, Args&&... args) {
    return AsyncNoSpan(
        current_task::GetTaskProcessor(), deadline, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// Runs an asynchronous function call with deadline using task processor of the
/// caller
template <typename Function, typename... Args>
[[nodiscard]] auto SharedAsyncNoSpan(Deadline deadline, Function&& f, Args&&... args) {
    return SharedAsyncNoSpan(
        current_task::GetTaskProcessor(), deadline, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// @brief Runs an asynchronous function call that will start regardless of
/// cancellations using specified task processor
/// @see Task::Importance::Critical
template <typename Function, typename... Args>
[[nodiscard]] auto CriticalAsyncNoSpan(TaskProcessor& task_processor, Function&& f, Args&&... args) {
    return impl::MakeTaskWithResult<TaskWithResult>(
        task_processor, Task::Importance::kCritical, {}, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// @brief Runs an asynchronous function call that will start regardless of
/// cancellations using specified task processor
/// @see Task::Importance::Critical
template <typename Function, typename... Args>
[[nodiscard]] auto SharedCriticalAsyncNoSpan(TaskProcessor& task_processor, Function&& f, Args&&... args) {
    return impl::MakeTaskWithResult<SharedTaskWithResult>(
        task_processor, Task::Importance::kCritical, {}, std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// @brief Runs an asynchronous function call that will start regardless of
/// cancellations using task processor of the caller
/// @see Task::Importance::Critical
template <typename Function, typename... Args>
[[nodiscard]] auto CriticalAsyncNoSpan(Function&& f, Args&&... args) {
    return CriticalAsyncNoSpan(
        current_task::GetTaskProcessor(), std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// @brief Runs an asynchronous function call that will start regardless of
/// cancellations using task processor of the caller
/// @see Task::Importance::Critical
template <typename Function, typename... Args>
[[nodiscard]] auto SharedCriticalAsyncNoSpan(Function&& f, Args&&... args) {
    return SharedCriticalAsyncNoSpan(
        current_task::GetTaskProcessor(), std::forward<Function>(f), std::forward<Args>(args)...
    );
}
 
/// @brief Runs an asynchronous function call that will start regardless of
/// cancellations, using task processor of the caller, with deadline
/// @see Task::Importance::Critical
template <typename Function, typename... Args>
[[nodiscard]] auto CriticalAsyncNoSpan(Deadline deadline, Function&& f, Args&&... args) {
    return impl::MakeTaskWithResult<TaskWithResult>(
        current_task::GetTaskProcessor(),
        Task::Importance::kCritical,
        deadline,
        std::forward<Function>(f),
        std::forward<Args>(args)...
    );
}
 
}  // namespace engine
 
USERVER_NAMESPACE_END