qfuture_impl.h File Reference

#include <QtCore/qglobal.h>
#include <QtCore/qbasicfuturewatcher.h>
#include <QtCore/qfutureinterface.h>
#include <QtCore/qthreadpool.h>
#include <QtCore/qexception.h>
#include <QtCore/qpointer.h>
#include <QtCore/qpromise.h>
#include <memory>

Include dependency graph for qfuture_impl.h:

Go to the source code of this file.

Classes
struct	QtFuture::WhenAnyResult< T >
struct	QtPrivate::ResultTypeHelper< F, Arg, Enable >
struct	QtPrivate::ResultTypeHelper< F, Arg, typename std::enable_if_t<!std::is_invocable_v< std::decay_t< F >, QFuture< Arg > > > >
struct	QtPrivate::ResultTypeHelper< F, Arg, typename std::enable_if_t< std::is_invocable_v< std::decay_t< F >, QFuture< Arg > > > >
struct	QtPrivate::ResultTypeHelper< F, void, typename std::enable_if_t< std::is_invocable_v< std::decay_t< F >, QFuture< void > > > >
struct	QtPrivate::ResultTypeHelper< F, void, typename std::enable_if_t<!std::is_invocable_v< std::decay_t< F >, QFuture< void > > > >
struct	QtPrivate::ArgsType< Arg, Args... >
struct	QtPrivate::ArgsType< QPromise< Arg > &, Args... >
struct	QtPrivate::ArgsType<>
struct	QtPrivate::ArgResolver< F >
struct	QtPrivate::ArgResolver< std::reference_wrapper< F > >
struct	QtPrivate::ArgResolver< R(Args...)>
struct	QtPrivate::ArgResolver< R(*)(Args...)>
struct	QtPrivate::ArgResolver< R(*&)(Args...)>
struct	QtPrivate::ArgResolver< R(*const)(Args...)>
struct	QtPrivate::ArgResolver< R(&)(Args...)>
struct	QtPrivate::ArgResolver< R(Class::*)(Args...)>
struct	QtPrivate::ArgResolver< R(Class::*)(Args...) noexcept >
struct	QtPrivate::ArgResolver< R(Class::*)(Args...) const >
struct	QtPrivate::ArgResolver< R(Class::*)(Args...) const noexcept >
struct	QtPrivate::ArgResolver< R(Class::*const)(Args...) const >
struct	QtPrivate::ArgResolver< R(Class::*const)(Args...) const noexcept >
struct	QtPrivate::Future< T >
struct	QtPrivate::Future< QFuture< T > >
class	QtPrivate::Continuation< Function, ResultType, ParentResultType >
class	QtPrivate::SyncContinuation< Function, ResultType, ParentResultType >
class	QtPrivate::AsyncContinuation< Function, ResultType, ParentResultType >
class	QtPrivate::FailureHandler< Function, ResultType >
struct	QtPrivate::ContinuationWrapper< Function >
class	QtPrivate::CanceledHandler< Function, ResultType >
struct	QtPrivate::UnwrapHandler
struct	QtPrivate::WhenAllContext< ResultFutures >
struct	QtPrivate::WhenAnyContext< ResultType >

Namespaces
namespace	QtFuture
namespace	QtPrivate
	\macro QT_NAMESPACE

Typedefs
template<class T >
using	QtPrivate::EnableForVoid = std::enable_if_t< std::is_same_v< T, void > >
template<class T >
using	QtPrivate::EnableForNonVoid = std::enable_if_t<!std::is_same_v< T, void > >
template<class Arg , class... Args>
using	QtPrivate::FilterLastPrivateSignalArg = std::conditional_t<(sizeof...(Args) > 0), std::invoke_result_t< decltype(createTuple< Arg, Args... >), Arg, Args... >, std::conditional_t< IsPrivateSignalArg< Arg >, void, Arg > >
template<class Class , class Callable >
using	QtPrivate::EnableIfInvocable = std::enable_if_t< QtPrivate::ArgResolver< Callable >::template CanInvokeWithArgs< Class, Callable > >
template<class T >
using	QtPrivate::isQFuture = std::bool_constant< isQFutureV< T > >
template<class... Args>
using	QtPrivate::NotEmpty = std::bool_constant<(sizeof...(Args) > 0)>
template<class Sequence >
using	QtPrivate::IsRandomAccessible = std::is_convertible< typename std::iterator_traits< std::decay_t< decltype(std::begin(std::declval< Sequence >()))> >::iterator_category, std::random_access_iterator_tag >
template<class Sequence >
using	QtPrivate::HasInputIterator = std::is_convertible< typename std::iterator_traits< std::decay_t< decltype(std::begin(std::declval< Sequence >()))> >::iterator_category, std::input_iterator_tag >
template<class Iterator >
using	QtPrivate::IsForwardIterable = std::is_convertible< typename std::iterator_traits< Iterator >::iterator_category, std::forward_iterator_tag >
template<class Signal >
using	QtFuture::ArgsType = typename QtPrivate::ArgResolver< Signal >::AllArgs
template<typename Container >
using	QtFuture::if_container_with_input_iterators = std::enable_if_t< QtPrivate::HasInputIterator< Container >::value, bool >
template<typename Container >
using	QtFuture::ContainedType = typename std::iterator_traits< decltype(std::cbegin(std::declval< Container & >()))>::value_type

Enumerations
enum class	QtFuture::Launch { QtFuture::Sync , QtFuture::Async , QtFuture::Inherit }

Functions
template<class T >
	QtFuture::WhenAnyResult (qsizetype, const QFuture< T > &) -> WhenAnyResult< T >
template<class Tuple , std::size_t... I>
auto	QtPrivate::cutTuple (Tuple &&t, std::index_sequence< I... >)
template<class Arg , class... Args>
auto	QtPrivate::createTuple (Arg &&arg, Args &&... args)
template<class T >
void	QtPrivate::fulfillPromise (QPromise< T > &promise, QFuture< T > &future)
template<class T , class Function >
void	QtPrivate::fulfillPromise (QPromise< T > &promise, Function &&handler)
template<typename ValueType >
QFuture< ValueType >	QtPrivate::makeReadyRangeFutureImpl (const QList< ValueType > &values)
template<class Sender , class Signal , typename = QtPrivate::EnableIfInvocable<Sender, Signal>>
static QFuture< ArgsType< Signal > >	QtFuture::connect (Sender *sender, Signal signal)
template<typename Container , if_container_with_input_iterators< Container > = true>
static QFuture< ContainedType< Container > >	QtFuture::makeReadyRangeFuture (Container &&container)
template<typename ValueType >
static QFuture< ValueType >	QtFuture::makeReadyRangeFuture (std::initializer_list< ValueType > values)
template<typename T >
static QFuture< std::decay_t< T > >	QtFuture::makeReadyValueFuture (T &&value)
Q_CORE_EXPORT QFuture< void >	QtFuture::makeReadyVoidFuture ()
template<typename T = void>
static QFuture< T >	QtFuture::makeExceptionalFuture (std::exception_ptr exception)
template<typename T = void>
static QFuture< T >	QtFuture::makeExceptionalFuture (const QException &exception)
template<qsizetype Index, typename ContextType , typename... Ts>
void	QtPrivate::addCompletionHandlersImpl (const std::shared_ptr< ContextType > &context, const std::tuple< Ts... > &t)
template<typename ContextType , typename... Ts>
void	QtPrivate::addCompletionHandlers (const std::shared_ptr< ContextType > &context, const std::tuple< Ts... > &t)
template<typename OutputSequence , typename InputIt , typename ValueType >
QFuture< OutputSequence >	QtPrivate::whenAllImpl (InputIt first, InputIt last)
template<typename OutputSequence , typename... Futures>
QFuture< OutputSequence >	QtPrivate::whenAllImpl (Futures &&... futures)
template<typename InputIt , typename ValueType >
QFuture< QtFuture::WhenAnyResult< typename Future< ValueType >::type > >	QtPrivate::whenAnyImpl (InputIt first, InputIt last)
template<typename... Futures>
QFuture< std::variant< std::decay_t< Futures >... > >	QtPrivate::whenAnyImpl (Futures &&... futures)

Variables
template<class T , class Enable = void>
constexpr bool	QtPrivate::IsPrivateSignalArg = false
template<class T >
constexpr bool	QtPrivate::isQFutureV = false
template<class T >
constexpr bool	QtPrivate::isQFutureV< QFuture< T > > = true