Overview

Pendable wrappers and helpers.

Classes
class	pw::async2::PendFuncAwaitable< T, Func >

class	pw::async2::PendFuncTask< Func >

class	pw::async2::MemberPendableWrapper< Func >

class	pw::async2::FreePendableWrapper< Func >

class	pw::async2::PendableAsTask< Pendable >

Typedefs
template<typename T = ReadyType>
using	pw::async2::OneshotCallbackTask = internal::CallbackTask< T, false >

template<typename T = ReadyType>
using	pw::async2::RecurringCallbackTask = internal::CallbackTask< T, true >

Functions
template<auto kFunc, typename Callback , typename T = typename UnwrapPoll< std::invoke_result_t<decltype(kFunc), Context&>>::Type>
OneshotCallbackTask< T >	pw::async2::OneshotCallbackTaskFor (Callback &&callback)

template<auto kMemberFunc, typename Class , typename Callback , typename T = typename UnwrapPoll< std::invoke_result_t<decltype(kMemberFunc), Class&, Context&>>::Type>
OneshotCallbackTask< T >	pw::async2::OneshotCallbackTaskFor (Class &obj, Callback &&callback)

template<auto kFunc, typename Callback , typename T = typename UnwrapPoll< std::invoke_result_t<decltype(kFunc), Context&>>::Type>
RecurringCallbackTask< T >	pw::async2::RecurringCallbackTaskFor (Callback &&callback)

template<auto kMemberFunc, typename Class , typename Callback , typename T = typename UnwrapPoll< std::invoke_result_t<decltype(kMemberFunc), Class&, Context&>>::Type>
RecurringCallbackTask< T >	pw::async2::RecurringCallbackTaskFor (Class &obj, Callback &&callback)

template<typename Callable >
	pw::async2::PendFuncAwaitable (Callable) -> PendFuncAwaitable< typename std::invoke_result< Callable, Context & >::type::value_type, typename std::remove_reference< Callable >::type >

template<typename Func >
	pw::async2::PendFuncTask (Func &&) -> PendFuncTask< Func >

template<auto MemberFunc, typename Traits = internal::PendableTraits<decltype(MemberFunc)>, typename = std::enable_if_t< Traits::kIsPendable && std::is_member_function_pointer_v<decltype(MemberFunc)>>, typename... Args>
constexpr MemberPendableWrapper< MemberFunc >	pw::async2::PendableFor (typename Traits::Class &obj, Args &&... args)

template<auto FreeFunc, typename Traits = internal::PendableTraits<decltype(FreeFunc)>, typename = std::enable_if_t< Traits::kIsPendable && !std::is_member_function_pointer_v<decltype(FreeFunc)>>, typename... Args>
constexpr FreePendableWrapper< FreeFunc >	pw::async2::PendableFor (Args &&... args)

template<typename T >
	pw::async2::PendableAsTask (T &&) -> PendableAsTask< T >

Typedef Documentation

◆ OneshotCallbackTask

template<typename T = ReadyType>

using pw::async2::OneshotCallbackTask = typedef internal::CallbackTask<T, false>

A Task which pends a pendable function and invokes a provided callback with its output when it returns Ready.

A OneshotCallbackTask terminates after the underlying pendable returns Ready for the first time. Following this, the pendable will no longer be polled, and the callback function will not be invoked again.

◆ RecurringCallbackTask

template<typename T = ReadyType>

using pw::async2::RecurringCallbackTask = typedef internal::CallbackTask<T, true>

A Task which pends a pendable function and invokes a provided callback with its output when it returns Ready.

A RecurringCallbackTask never completes; it reschedules itself after each Ready returned by the underlying pendable. This makes it suitable to interface with pendables which continually return values, such as a data stream.

Function Documentation

◆ PendableFor() [1/2]

template<auto FreeFunc, typename Traits = internal::PendableTraits<decltype(FreeFunc)>, typename = std::enable_if_t< Traits::kIsPendable && !std::is_member_function_pointer_v<decltype(FreeFunc)>>, typename... Args>

constexpr FreePendableWrapper< FreeFunc > pw::async2::PendableFor ( Args &&... args )

inlineconstexpr

Wraps a pendable free function in an object which has a single Pend method, allowing it to be used more broadly.

The wrapper stores the arguments used to invoke the target function. As a result, the argument types must be copyable.

The wrapping pendable object can only be used a single time. After its Pend method returns Ready, it will crash if called again.

◆ PendableFor() [2/2]

template<auto MemberFunc, typename Traits = internal::PendableTraits<decltype(MemberFunc)>, typename = std::enable_if_t< Traits::kIsPendable && std::is_member_function_pointer_v<decltype(MemberFunc)>>, typename... Args>

constexpr MemberPendableWrapper< MemberFunc > pw::async2::PendableFor	(	typename Traits::Class &	obj,
		Args &&...	args
	)