#include <userver/engine/task/task_with_result.hpp>

Detailed Description

template<typename T>
class engine::TaskWithResult< T >

Asynchronous task with result

Example usage:

    std::vector<engine::TaskWithResult<int>> tasks;
    tasks.reserve(container.size());
    for (auto value : container) {
        // Creating tasks that will be executed in parallel
        tasks.push_back(utils::Async("some_task", [value = std::move(value)] {
            engine::InterruptibleSleepFor(std::chrono::milliseconds(100));
            return value;
        }));
    }
    // we wait for the completion of tasks and get the results
    std::vector<int> results;
    results.reserve(tasks.size());
    for (auto& task : tasks) {
        // If the task completed with an exception,
        // then Get () will throw an exception
        results.push_back(task.Get());
    }

See also: Synchronization Primitives

Examples: samples/flatbuf_service/flatbuf_service.cpp.

Definition at line 28 of file task_with_result.hpp.

Inheritance diagram for engine::TaskWithResult< T >:

Public Types
enum class	Importance { kNormal , kCritical }
	Task importance. More...

enum class	State { kInvalid , kNew , kQueued , kRunning , kSuspended , kCancelled , kCompleted }
	Task state. More...

enum class	WaitMode { kSingleWaiter , kMultipleWaiters }
	Task wait mode. More...

Public Member Functions
	TaskWithResult ()=default
	Default constructor.

	TaskWithResult (const TaskWithResult &)=delete

TaskWithResult &	operator= (const TaskWithResult &)=delete

	TaskWithResult (TaskWithResult &&other) noexcept=default
	Moves the other task into this, leaving the other in an invalid state.

TaskWithResult &	operator= (TaskWithResult &&other) noexcept=default
	If this Task is still valid and is not finished, cancels it and waits until it finishes before moving the other. Otherwise just moves the other task into this, leaving the other in invalid state.

T	Get () noexcept(false)
	Returns (or rethrows) the result of task invocation. After return from this method the task is not valid.

void	Detach () &&
	Detaches task, allowing it to continue execution out of scope; memory safety is much better with concurrent::BackgroundTaskStorage.

bool	IsValid () const
	Checks whether this object owns an actual task (not `State::kInvalid`)

State	GetState () const
	Gets the task State.

bool	IsFinished () const
	Returns whether the task finished execution.

void	Wait () const noexcept(false)
	Suspends execution until the task finishes or caller is cancelled. Can be called from coroutine context only. For non-coroutine context use BlockingWait().

template<typename Rep , typename Period >
void	WaitFor (const std::chrono::duration< Rep, Period > &) const noexcept(false)
	Suspends execution until the task finishes or after the specified timeout or until caller is cancelled.

template<typename Clock , typename Duration >
void	WaitUntil (const std::chrono::time_point< Clock, Duration > &) const noexcept(false)
	Suspends execution until the task finishes or until the specified time point is reached or until caller is cancelled.

void	WaitUntil (Deadline) const
	Suspends execution until the task finishes or until the specified deadline is reached or until caller is cancelled.

bool	WaitNothrow () const noexcept
	Suspends execution until the task finishes or caller is cancelled. Can be called from coroutine context only. For non-coroutine context use BlockingWait().

FutureStatus	WaitNothrowUntil (Deadline) const noexcept
	Suspends execution until the task finishes or until the specified deadline is reached or until caller is cancelled.

void	RequestCancel ()
	Queues task cancellation request.

void	SyncCancel () noexcept
	Cancels the task and suspends execution until it is finished. Can be called from coroutine context only. For non-coroutine context use RequestCancel() + BlockingWait().

TaskCancellationReason	CancellationReason () const
	Gets task cancellation reason.

void	BlockingWait () const

Static Public Member Functions
static std::string_view	GetStateName (State state)

Member Enumeration Documentation

◆ Importance

enum class engine::TaskBase::Importance

stronginherited

Task importance.

Enumerator
kNormal	Normal task.
kCritical	Critical task. The task will be started regardless of cancellations, e.g. due to user request, deadline or TaskProcessor overload. After the task starts, it may be cancelled. In particular, if it received any cancellation requests before starting, then it will start as cancelled.

Definition at line 36 of file task_base.hpp.

◆ State

enum class engine::TaskBase::State

stronginherited

Task state.

Enumerator
kInvalid	Unusable.
kNew	just created, not registered with task processor
kQueued	awaits execution
kRunning	executing user code
kSuspended	suspended, e.g. waiting for blocking call to complete
kCancelled	exited user code because of external request
kCompleted	exited user code with return or throw

Definition at line 48 of file task_base.hpp.

◆ WaitMode

enum class engine::TaskBase::WaitMode

stronginherited

Task wait mode.

Enumerator
kSingleWaiter	Can be awaited by at most one task at a time.
kMultipleWaiters	Can be awaited by multiple tasks simultaneously.

Definition at line 59 of file task_base.hpp.

Constructor & Destructor Documentation

◆ TaskWithResult()

template<typename T >

engine::TaskWithResult< T >::TaskWithResult ( )

default

Default constructor.

Creates an invalid task.

Member Function Documentation

◆ BlockingWait()

void engine::TaskBase::BlockingWait ( ) const

inherited

Waits for the task in non-coroutine context (e.g. non-TaskProcessor's std::thread).

◆ Detach()

void engine::Task::Detach ( ) &&

inherited

Detaches task, allowing it to continue execution out of scope; memory safety is much better with concurrent::BackgroundTaskStorage.

Note: After detach, Task becomes invalid

Warning: Variables, which are captured by reference for this task in Async*, should outlive the task execution. This is hard to achieve in general, detached tasks may outlive all the components! Use concurrent::BackgroundTaskStorage as a safe and efficient alternative to calling Detach().

◆ Get()

template<typename T >

T engine::TaskWithResult< T >::Get ( )

inline

Returns (or rethrows) the result of task invocation. After return from this method the task is not valid.

Exceptions

WaitInterruptedException	when `current_task::IsCancelRequested()` and no TaskCancellationBlockers are present.
TaskCancelledException	if no result is available because the task was cancelled

Definition at line 53 of file task_with_result.hpp.

◆ IsValid()

bool engine::TaskBase::IsValid ( ) const

inherited

Checks whether this object owns an actual task (not State::kInvalid)

An invalid task cannot be used. The task becomes invalid after each of the following calls:

the default constructor
Detach()
Get() (see engine::TaskWithResult)

◆ Wait()

void engine::TaskBase::Wait ( ) const

inherited

Suspends execution until the task finishes or caller is cancelled. Can be called from coroutine context only. For non-coroutine context use BlockingWait().

Exceptions

WaitInterruptedException when current_task::IsCancelRequested() and no TaskCancellationBlockers are present.

◆ WaitFor()

template<typename Rep , typename Period >

void engine::TaskBase::WaitFor ( const std::chrono::duration< Rep, Period > & duration ) const

inherited

Suspends execution until the task finishes or after the specified timeout or until caller is cancelled.

Exceptions

WaitInterruptedException when current_task::IsCancelRequested() and no TaskCancellationBlockers are present.

Definition at line 180 of file task_base.hpp.

◆ WaitNothrow()

bool engine::TaskBase::WaitNothrow ( ) const

noexceptinherited

Suspends execution until the task finishes or caller is cancelled. Can be called from coroutine context only. For non-coroutine context use BlockingWait().

Returns: false when current_task::IsCancelRequested() and no TaskCancellationBlockers are present.

◆ WaitNothrowUntil()

FutureStatus engine::TaskBase::WaitNothrowUntil ( Deadline ) const

noexceptinherited

Suspends execution until the task finishes or until the specified deadline is reached or until caller is cancelled.

Returns: FutureStatus::kCancelled when current_task::IsCancelRequested() and no TaskCancellationBlockers are present.

◆ WaitUntil() [1/2]

template<typename Clock , typename Duration >

void engine::TaskBase::WaitUntil ( const std::chrono::time_point< Clock, Duration > & until ) const

inherited

Suspends execution until the task finishes or until the specified time point is reached or until caller is cancelled.

Exceptions

WaitInterruptedException when current_task::IsCancelRequested() and no TaskCancellationBlockers are present.

Definition at line 185 of file task_base.hpp.

◆ WaitUntil() [2/2]

void engine::TaskBase::WaitUntil ( Deadline ) const

inherited

Suspends execution until the task finishes or until the specified deadline is reached or until caller is cancelled.

Exceptions

WaitInterruptedException when current_task::IsCancelRequested() and no TaskCancellationBlockers are present.

The documentation for this class was generated from the following file:

userver/engine/task/task_with_result.hpp

Detailed Description

Example usage:

Public Types

Public Member Functions

Static Public Member Functions

Member Enumeration Documentation

◆ Importance

◆ State

◆ WaitMode

Constructor & Destructor Documentation

◆ TaskWithResult()

Member Function Documentation

◆ BlockingWait()

◆ Detach()

◆ Get()

◆ IsValid()

◆ Wait()

◆ WaitFor()

◆ WaitNothrow()

◆ WaitNothrowUntil()

◆ WaitUntil() [1/2]

◆ WaitUntil() [2/2]