#include <functional>
#include <vector>
#include <dispenso/detail/future_impl.h>
#include <dispenso/detail/result_of.h>
#include <dispenso/schedulable.h>
#include <dispenso/detail/future_impl2.h>

Classes
class	dispenso::Future< Result >

class	dispenso::Future< Result & >

class	dispenso::Future< void >

Functions
template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (std::launch policy, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (ThreadPool &pool, std::launch policy, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (ThreadPool &pool, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (TaskSet &tasks, std::launch policy, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (TaskSet &tasks, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (ConcurrentTaskSet &tasks, std::launch policy, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (ConcurrentTaskSet &tasks, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (NewThreadInvoker sched, std::launch policy, F &&f, Args &&... args)

template<class F , class... Args>
Future< detail::ResultOf< F, Args... > >	dispenso::async (NewThreadInvoker sched, F &&f, Args &&... args)

template<typename T >
Future< std::decay_t< T > >	dispenso::make_ready_future (T &&t)

template<typename X >
Future< X & >	dispenso::make_ready_future (std::reference_wrapper< X > x)

Future< void >	dispenso::make_ready_future ()

template<class InputIt >
Future< std::vector< typename std::iterator_traits< InputIt >::value_type > >	dispenso::when_all (InputIt first, InputIt last)

template<class... Futures>
auto	dispenso::when_all (Futures &&... futures) -> Future< std::tuple< std::decay_t< Futures >... > >

template<class InputIt >
Future< std::vector< typename std::iterator_traits< InputIt >::value_type > >	dispenso::when_all (TaskSet &taskSet, InputIt first, InputIt last)

template<class InputIt >
Future< std::vector< typename std::iterator_traits< InputIt >::value_type > >	dispenso::when_all (ConcurrentTaskSet &taskSet, InputIt first, InputIt last)

template<class... Futures>
auto	dispenso::when_all (TaskSet &taskSet, Futures &&... futures) -> Future< std::tuple< std::decay_t< Futures >... > >

template<class... Futures>
auto	dispenso::when_all (ConcurrentTaskSet &taskSet, Futures &&... futures) -> Future< std::tuple< std::decay_t< Futures >... > >

template<class InputIt >
Future< size_t >	dispenso::when_any (InputIt first, InputIt last)

template<class... Futures>
auto	dispenso::when_any (Futures &&... futures) -> Future< size_t >

template<class InputIt >
Future< size_t >	dispenso::when_any (TaskSet &taskSet, InputIt first, InputIt last)

template<class InputIt >
Future< size_t >	dispenso::when_any (ConcurrentTaskSet &taskSet, InputIt first, InputIt last)

template<class... Futures>
auto	dispenso::when_any (TaskSet &taskSet, Futures &&... futures) -> Future< size_t >

template<class... Futures>
auto	dispenso::when_any (ConcurrentTaskSet &taskSet, Futures &&... futures) -> Future< size_t >

Variables
constexpr std::launch	dispenso::kNotAsync = static_cast<std::launch>(0)

constexpr std::launch	dispenso::kNotDeferred = static_cast<std::launch>(0)

Detailed Description

A file providing Futures, as well as functionality for creating futures, and for how to invoke Futures' closures.

See https://en.cppreference.com/w/cpp/experimental/future for details on the API.

Definition in file future.h.

Function Documentation

◆ async() [1/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	ConcurrentTaskSet &	tasks,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor through the specified dispenso ConcurrentTaskSet.

Parameters

tasks	The ConcurrentTaskSet to run the Future.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 557 of file future.h.

◆ async() [2/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	ConcurrentTaskSet &	tasks,
		std::launch	policy,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor through the specified dispenso ConcurrentTaskSet.

Parameters

tasks	The ConcurrentTaskSet to run the Future.
policy	The bitmask policy for when/how the functor can be invoked. `std::launch::async` will result in the functor being forced onto a ThreadPool work queue. `std::launch::deferred` specifies that `Future::wait_for` and `Future::wait_until` may invoke the functor.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 544 of file future.h.

◆ async() [3/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	F &&	f,
		Args &&...	args )

inline

Invoke a functor through the global dispenso thread pool.

Parameters

f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 465 of file future.h.

◆ async() [4/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	NewThreadInvoker	sched,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor on a new thread.

Parameters

sched	A NewThreadInvoker.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 588 of file future.h.

◆ async() [5/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	NewThreadInvoker	sched,
		std::launch	policy,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor on a new thread.

Parameters

sched	A NewThreadInvoker
policy	The bitmask policy for when/how the functor can be invoked. `std::launch::async` will result in the functor being forced onto a ThreadPool work queue. `std::launch::deferred` specifies that `Future::wait_for` and `Future::wait_until` may invoke the functor.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 575 of file future.h.

◆ async() [6/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	std::launch	policy,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor through the global dispenso thread pool.

Parameters

policy	The bitmask policy for when/how the functor can be invoked. `std::launch::async` will result in the functor being forced onto a ThreadPool work queue. `std::launch::deferred` specifies that `Future::wait_for` and `Future::wait_until` may invoke the functor.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 453 of file future.h.

◆ async() [7/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	TaskSet &	tasks,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor through the specified dispenso TaskSet.

Parameters

tasks	The TaskSet to run the Future.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 526 of file future.h.

◆ async() [8/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	TaskSet &	tasks,
		std::launch	policy,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor through the specified dispenso TaskSet.

Parameters

tasks	The TaskSet to run the Future.
policy	The bitmask policy for when/how the functor can be invoked. `std::launch::async` will result in the functor being forced onto a ThreadPool work queue. `std::launch::deferred` specifies that `Future::wait_for` and `Future::wait_until` may invoke the functor.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 513 of file future.h.

◆ async() [9/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	ThreadPool &	pool,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor through the specified dispenso thread pool.

Parameters

pool	The ThreadPool to run the Future.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 495 of file future.h.

◆ async() [10/10]

template<class F , class... Args>

Future< detail::ResultOf< F, Args... > > dispenso::async	(	ThreadPool &	pool,
		std::launch	policy,
		F &&	f,
		Args &&...	args )

inline

Invoke a functor through the specified dispenso thread pool.

Parameters

pool	The ThreadPool to run the Future.
policy	The bitmask policy for when/how the functor can be invoked. `std::launch::async` will result in the functor being forced onto a ThreadPool work queue. `std::launch::deferred` specifies that `Future::wait_for` and `Future::wait_until` may invoke the functor.
f	The functor to be passed, or a function to be executed
args	The remaining arguments that will be passed to `f`

Definition at line 482 of file future.h.

◆ make_ready_future() [1/3]

Future< void > dispenso::make_ready_future ( )

inline

Make a Future<void> in a ready state.

Definition at line 619 of file future.h.

◆ make_ready_future() [2/3]

template<typename X >

Future< X & > dispenso::make_ready_future ( std::reference_wrapper< X > x )

inline

Make a Future in a ready state with the reference_wrapper passed into make_ready_future

Parameters

x	the wrapped reference to use to create the returned future.

Definition at line 611 of file future.h.

◆ make_ready_future() [3/3]

template<typename T >

Future< std::decay_t< T > > dispenso::make_ready_future ( T && t )

inline

Make a Future in a ready state with the value passed into make_ready_future

Parameters

t	the value to use to create the returned future.

Definition at line 600 of file future.h.

◆ when_all() [1/6]

template<class... Futures>

auto dispenso::when_all	(	ConcurrentTaskSet &	taskSet,
		Futures &&...	futures ) -> Future< std::tuple< std::decay_t< Futures >... > >

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ when_all() [2/6]

template<class InputIt >

Future< std::vector< typename std::iterator_traits< InputIt >::value_type > > dispenso::when_all	(	ConcurrentTaskSet &	taskSet,
		InputIt	first,
		InputIt	last )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ when_all() [3/6]

template<class... Futures>

auto dispenso::when_all ( Futures &&... futures ) -> Future< std::tuple< std::decay_t< Futures >... > >

Take a specific set of futures, and return a future which will be ready when all input futures are ready.

Parameters

futures A parameter pack of futures.

Returns: A Future containing a tuple holding copies of the input Futures. The returned Future will be in ready state when all input Futures are ready.

◆ when_all() [4/6]

template<class InputIt >

Future< std::vector< typename std::iterator_traits< InputIt >::value_type > > dispenso::when_all	(	InputIt	first,
		InputIt	last )

Take a collection of futures, and return a future which will be ready when all input futures are ready.

Parameters

first	An iterator to the start of the future collection.
last	An iterator to the end of the future collection.

Returns: A Future containing a vector holding copies of the input Futures. The returned Future will be in ready state when all input Futures are ready.

◆ when_all() [5/6]

template<class... Futures>

auto dispenso::when_all	(	TaskSet &	taskSet,
		Futures &&...	futures ) -> Future< std::tuple< std::decay_t< Futures >... > >

Take a specific set of futures, and return a future which will be ready when all input futures are ready.

Parameters

taskSet	A task set to register with such that after this call, `taskSet::wait()` implies that the resultant future `is_ready()`
futures	A parameter pack of futures.

Returns: A Future containing a tuple holding copies of the input Futures. The returned Future will be in ready state when all input Futures are ready.

◆ when_all() [6/6]

template<class InputIt >

Future< std::vector< typename std::iterator_traits< InputIt >::value_type > > dispenso::when_all	(	TaskSet &	taskSet,
		InputIt	first,
		InputIt	last )

Take a collection of futures, and return a future which will be ready when all input futures are ready.

Parameters

taskSet	A task set to register with such that after this call, `taskSet::wait()` implies that the resultant future `is_ready()`
first	An iterator to the start of the future collection.
last	An iterator to the end of the future collection.

Returns: A Future containing a vector holding copies of the input Futures. The returned Future will be in ready state when all input Futures are ready.

◆ when_any() [1/6]

template<class... Futures>

auto dispenso::when_any	(	ConcurrentTaskSet &	taskSet,
		Futures &&...	futures ) -> Future< size_t >

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ when_any() [2/6]

template<class InputIt >

Future< size_t > dispenso::when_any	(	ConcurrentTaskSet &	taskSet,
		InputIt	first,
		InputIt	last )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ when_any() [3/6]

template<class... Futures>

auto dispenso::when_any ( Futures &&... futures ) -> Future< size_t >

Take a specific set of futures, and return a future which will be ready when any one of them becomes ready. The result holds the index (in argument order) of the first to complete.

Parameters

futures A parameter pack of futures.

Returns: A Future containing the argument index of the first to become ready. If no inputs are given, returns SIZE_MAX as a sentinel.

◆ when_any() [4/6]

template<class InputIt >

Future< size_t > dispenso::when_any	(	InputIt	first,
		InputIt	last )

Take a collection of futures, and return a future which will be ready when any one of the input futures becomes ready. The result holds the index of the first input future to complete. Late completions of other inputs do not affect the result.

Parameters

first	An iterator to the start of the future collection.
last	An iterator to the end of the future collection.

Returns: A Future containing the index (in iterator order) of the first input Future to become ready. If the input range is empty, returns SIZE_MAX as a sentinel.

Note: when_any does not cancel the losing inputs. If they are tasks scheduled into a TaskSet, the caller may use TaskSet::cancel() to ask cooperatively-cancellable tasks to exit early.

◆ when_any() [5/6]

template<class... Futures>

auto dispenso::when_any	(	TaskSet &	taskSet,
		Futures &&...	futures ) -> Future< size_t >

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ when_any() [6/6]

template<class InputIt >

Future< size_t > dispenso::when_any	(	TaskSet &	taskSet,
		InputIt	first,
		InputIt	last )

Variant that registers with a TaskSet so that taskSet.wait() implies the result is ready. This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Variable Documentation

◆ kNotAsync

std::launch dispenso::kNotAsync = static_cast<std::launch>(0)

constexpr

A std::launch policy specifying we won't force asynchronicity. Opposite of std::launch::async

Definition at line 36 of file future.h.

◆ kNotDeferred

std::launch dispenso::kNotDeferred = static_cast<std::launch>(0)

constexpr

A std::launch policy specifying we won't allow Future::wait_for and Future::wait_util to invoke the Future's underlying functor. Opposite of std::launch::deferred

Definition at line 42 of file future.h.

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ async() [1/10]

◆ async() [2/10]

◆ async() [3/10]

◆ async() [4/10]

◆ async() [5/10]

◆ async() [6/10]

◆ async() [7/10]

◆ async() [8/10]

◆ async() [9/10]

◆ async() [10/10]

◆ make_ready_future() [1/3]

◆ make_ready_future() [2/3]

◆ make_ready_future() [3/3]

◆ when_all() [1/6]

◆ when_all() [2/6]

◆ when_all() [3/6]

◆ when_all() [4/6]

◆ when_all() [5/6]

◆ when_all() [6/6]

◆ when_any() [1/6]

◆ when_any() [2/6]

◆ when_any() [3/6]

◆ when_any() [4/6]

◆ when_any() [5/6]

◆ when_any() [6/6]

Variable Documentation

◆ kNotAsync

◆ kNotDeferred