\inheaderfile solutions/tasking/tasktree.h \inmodule TaskingSolution More...

#include <tasktree.h>

Inheritance diagram for Tasking::TaskTree:

Collaboration diagram for Tasking::TaskTree:

Signals
void	started ()
	This signal is emitted when the task tree is started.

void	done (DoneWith result)
	This signal is emitted when the task tree finished, passing the final result of the execution.

void	asyncCountChanged (int count)
	This signal is emitted when the running task tree is about to return control to the caller's event loop.

void	progressValueChanged (int value)
	This signal is emitted when the running task tree finished, canceled, or skipped some tasks.

Signals inherited from QObject
void	destroyed (QObject *=nullptr)
	This signal is emitted immediately before the object obj is destroyed, after any instances of QPointer have been notified, and cannot be blocked.

void	objectNameChanged (const QString &objectName, QPrivateSignal)
	This signal is emitted after the object's name has been changed.

Public Member Functions
	TaskTree ()
	Constructs an empty task tree.

	TaskTree (const Group &recipe)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Constructs a task tree with a given recipe.

	~TaskTree ()
	Destroys the task tree.

void	setRecipe (const Group &recipe)
	Sets a given recipe for the task tree.

void	start ()
	Starts the task tree.

void	cancel ()
	Cancels the execution of the running task tree.

bool	isRunning () const
	Returns `true` if the task tree is currently running; otherwise returns `false`.

DoneWith	runBlocking ()
	Executes a local event loop with QEventLoop::ExcludeUserInputEvents and starts the task tree.

DoneWith	runBlocking (const QFuture< void > &future)

int	asyncCount () const
	Returns the current real count of asynchronous chains of invocations.

int	taskCount () const
	Returns the number of asynchronous tasks contained in the stored recipe.

int	progressMaximum () const
	Returns the maximum progressValue().

int	progressValue () const
	Returns the current progress value, which is between the `0` and progressMaximum().

template<typename StorageStruct , typename Handler >
void	onStorageSetup (const Storage< StorageStruct > &storage, Handler &&handler)
	Installs a storage setup handler for the storage to pass the initial data dynamically to the running task tree.

template<typename StorageStruct , typename Handler >
void	onStorageDone (const Storage< StorageStruct > &storage, Handler &&handler)
	Installs a storage done handler for the storage to retrieve the final data dynamically from the running task tree.

Public Member Functions inherited from QObject
Q_INVOKABLE	QObject (QObject *parent=nullptr)
	Constructs an object with parent object parent.

virtual	~QObject ()
	Destroys the object, deleting all its child objects.

virtual bool	event (QEvent *event)
	This virtual function receives events to an object and should return true if the event e was recognized and processed.

virtual bool	eventFilter (QObject watched, QEvent event)
	Filters events if this object has been installed as an event filter for the watched object.

QString	objectName () const

Q_WEAK_OVERLOAD void	setObjectName (const QString &name)
	Sets the object's name to name.

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

QBindable< QString >	bindableObjectName ()

bool	isWidgetType () const
	Returns `true` if the object is a widget; otherwise returns `false`.

bool	isWindowType () const
	Returns `true` if the object is a window; otherwise returns `false`.

bool	isQuickItemType () const
	Returns `true` if the object is a QQuickItem; otherwise returns `false`.

bool	signalsBlocked () const noexcept
	Returns `true` if signals are blocked; otherwise returns `false`.

bool	blockSignals (bool b) noexcept
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it).

QThread *	thread () const
	Returns the thread in which the object lives.

bool	moveToThread (QThread *thread QT6_DECL_NEW_OVERLOAD_TAIL)
	Changes the thread affinity for this object and its children and returns `true` on success.

int	startTimer (int interval, Qt::TimerType timerType=Qt::CoarseTimer)
	This is an overloaded function that will start a timer of type timerType and a timeout of interval milliseconds.

int	startTimer (std::chrono::nanoseconds time, Qt::TimerType timerType=Qt::CoarseTimer)

void	killTimer (int id)
	Kills the timer with timer identifier, id.

void	killTimer (Qt::TimerId id)

template<typename T >
T	findChild (QAnyStringView aName, Qt::FindChildOptions options=Qt::FindChildrenRecursively) const
	Returns the child of this object that can be cast into type T and that is called name, or \nullptr if there is no such object.

template<typename T >
QList< T >	findChildren (QAnyStringView aName, Qt::FindChildOptions options=Qt::FindChildrenRecursively) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects.

template<typename T >
T	findChild (Qt::FindChildOptions options=Qt::FindChildrenRecursively) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T >
QList< T >	findChildren (Qt::FindChildOptions options=Qt::FindChildrenRecursively) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

const QObjectList &	children () const
	Returns a list of child objects.

void	setParent (QObject *parent)
	Makes the object a child of parent.

void	installEventFilter (QObject *filterObj)
	Installs an event filter filterObj on this object.

void	removeEventFilter (QObject *obj)
	Removes an event filter object obj from this object.

QMetaObject::Connection	connect (const QObject sender, const char signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const

bool	disconnect (const char signal=nullptr, const QObject receiver=nullptr, const char *member=nullptr) const

bool	disconnect (const QObject receiver, const char member=nullptr) const

void	dumpObjectTree () const
	Dumps a tree of children to the debug output.

void	dumpObjectInfo () const
	Dumps information about signal connections, etc.

bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value.

bool	setProperty (const char *name, QVariant &&value)

QVariant	property (const char *name) const
	Returns the value of the object's name property.

QList< QByteArray >	dynamicPropertyNames () const

QBindingStorage *	bindingStorage ()

const QBindingStorage *	bindingStorage () const

QObject *	parent () const
	Returns a pointer to the parent object.

bool	inherits (const char *classname) const
	Returns `true` if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns `false`.

Static Public Member Functions
static DoneWith	runBlocking (const Group &recipe, std::chrono::milliseconds timeout=std::chrono::milliseconds::max())

static DoneWith	runBlocking (const Group &recipe, const QFuture< void > &future, std::chrono::milliseconds timeout=std::chrono::milliseconds::max())

Static Public Member Functions inherited from QObject
static QMetaObject::Connection	connect (const QObject sender, const char signal, const QObject receiver, const char member, Qt::ConnectionType=Qt::AutoConnection)
	\threadsafe

static QMetaObject::Connection	connect (const QObject sender, const QMetaMethod &signal, const QObject receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)

template<typename Func1 , typename Func2 >
static QMetaObject::Connection	connect (const typename QtPrivate::FunctionPointer< Func1 >::Object sender, Func1 signal, const typename QtPrivate::ContextTypeForFunctor< Func2 >::ContextType context, Func2 &&slot, Qt::ConnectionType type=Qt::AutoConnection)

template<typename Func1 , typename Func2 >
static QMetaObject::Connection	connect (const typename QtPrivate::FunctionPointer< Func1 >::Object *sender, Func1 signal, Func2 &&slot)

static bool	disconnect (const QObject sender, const char signal, const QObject receiver, const char member)
	\threadsafe

static bool	disconnect (const QObject sender, const QMetaMethod &signal, const QObject receiver, const QMetaMethod &member)

static bool	disconnect (const QMetaObject::Connection &)
	Disconnect a connection.

template<typename Func1 , typename Func2 >
static bool	disconnect (const typename QtPrivate::FunctionPointer< Func1 >::Object sender, Func1 signal, const typename QtPrivate::FunctionPointer< Func2 >::Object receiver, Func2 slot)

template<typename Func1 >
static bool	disconnect (const typename QtPrivate::FunctionPointer< Func1 >::Object sender, Func1 signal, const QObject receiver, void **zero)

Related Symbols
(Note that these are not member symbols.)
	runBlocking
	The passed future is used for listening to the cancel event.

	runBlocking
	The passed future is used for listening to the cancel event.

Related Symbols inherited from QObject
template< class T > T	qobject_cast (const QObject *object)
	Returns the given object cast to type T if the object is of type T (or of a subclass); otherwise returns \nullptr.

template< typename T > T	qFindChildqFindChildren (const QObject *obj, const QString &name)()

template< typename T > QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()

	QObjectList
	\macro Q_CLASSINFO(Name, Value)

Additional Inherited Members
Public Slots inherited from QObject
void	deleteLater ()
	\threadsafe

Protected Member Functions inherited from QObject
QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns \nullptr.

int	senderSignalIndex () const

int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal.

bool	isSignalConnected (const QMetaMethod &signal) const

virtual void	timerEvent (QTimerEvent *event)
	This event handler can be reimplemented in a subclass to receive timer events for the object.

virtual void	childEvent (QChildEvent *event)
	This event handler can be reimplemented in a subclass to receive child events.

virtual void	customEvent (QEvent *event)
	This event handler can be reimplemented in a subclass to receive custom events.

virtual void	connectNotify (const QMetaMethod &signal)

virtual void	disconnectNotify (const QMetaMethod &signal)

	QObject (QObjectPrivate &dd, QObject *parent=nullptr)

Protected Attributes inherited from QObject
QScopedPointer< QObjectData >	d_ptr

Properties inherited from QObject
QString	objectName
	the name of this object

Detailed Description

\inheaderfile solutions/tasking/tasktree.h \inmodule TaskingSolution

The TaskTree class runs an async task tree structure defined in a declarative way. \reentrant

Use the Tasking namespace to build extensible, declarative task tree structures that contain possibly asynchronous tasks, such as QProcess, NetworkQuery, or ConcurrentCall<ReturnType>. TaskTree structures enable you to create a sophisticated mixture of a parallel or sequential flow of tasks in the form of a tree and to run it any time later.

Definition at line 547 of file tasktree.h.

Constructor & Destructor Documentation

◆ TaskTree() [1/2]

Tasking::TaskTree::TaskTree ( )

Constructs an empty task tree.

Use setRecipe() to pass a declarative description on how the task tree should execute the tasks and how it should handle the finished tasks.

Starting an empty task tree is no-op and the relevant warning message is issued.

See also: setRecipe(), start()

Definition at line 2841 of file tasktree.cpp.

◆ TaskTree() [2/2]

Tasking::TaskTree::TaskTree ( const Group & recipe )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Constructs a task tree with a given recipe.

After the task tree is started, it executes the tasks contained inside the recipe and handles finished tasks according to the passed description.

See also: setRecipe(), start()

Definition at line 2854 of file tasktree.cpp.

References setRecipe().

Here is the call graph for this function:

◆ ~TaskTree()

Tasking::TaskTree::~TaskTree ( )

Destroys the task tree.

When the task tree is running while being destructed, it cancels all the running tasks immediately. In this case, no handlers are called, not even the groups' and tasks' done handlers or onStorageDone() handlers. The task tree also doesn't emit any signals from the destructor, not even done() or progressValueChanged() signals. This behavior may always be relied on. It is completely safe to destruct the running task tree.

It's a usual pattern to destruct the running task tree. It's guaranteed that the destruction will run quickly, without having to wait for the currently running tasks to finish, provided that the used tasks implement their destructors in a non-blocking way.

Note: Do not call the destructor directly from any of the running task's handlers or task tree's signals. In these cases, use \l deleteLater() instead.

See also: cancel()

Definition at line 2879 of file tasktree.cpp.

References Tasking::Guard::isLocked(), Tasking::TaskTreePrivate::m_guard, QT_ASSERT, and qWarning.

Here is the call graph for this function:

Member Function Documentation

◆ asyncCount()

int Tasking::TaskTree::asyncCount ( ) const

Returns the current real count of asynchronous chains of invocations.

The returned value indicates how many times the control returns to the caller's event loop while the task tree is running. Initially, this value is 0. If the execution of the task tree finishes fully synchronously, this value remains 0. If the task tree contains any asynchronous tasks that are successfully started during a call to start(), this value is bumped to 1 just before the call to start() finishes. Later, when any asynchronous task finishes and any possible continuations are started, this value is bumped again. The bumping continues until the task tree finishes. When the task tree emits the done() signal, the bumping stops. The asyncCountChanged() signal is emitted on every bump of this value.

See also: asyncCountChanged()

Definition at line 3106 of file tasktree.cpp.

References Tasking::TaskTreePrivate::m_asyncCount.

◆ asyncCountChanged

void Tasking::TaskTree::asyncCountChanged ( int count )

signal

This signal is emitted when the running task tree is about to return control to the caller's event loop.

When the task tree is started, this signal is emitted with count value of 0, and emitted later on every asyncCount() value bump with an updated count value. Every signal sent (except the initial one with the value of 0) guarantees that the task tree is still running asynchronously after the emission.

See also: asyncCount()

◆ cancel()

void Tasking::TaskTree::cancel ( )

Cancels the execution of the running task tree.

Cancels all the running tasks immediately. All running tasks finish with an error, invoking their error handlers. All running groups dispatch their handlers according to their workflow policies, invoking their done handlers. The storages' onStorageDone() handlers are invoked, too. The progressValueChanged() signals are also being sent. This behavior may always be relied on.

The cancel() function is executed synchronously, so that after a call to cancel() all running tasks are finished and the tree is already canceled. It's guaranteed that cancel() will run quickly, without any blocking wait for the currently running tasks to finish, provided the used tasks implement their destructors in a non-blocking way.

When the task tree is empty, that is, constructed with a default constructor, a call to cancel() is no-op and the relevant warning message is issued.

Otherwise, when the task tree wasn't started, a call to cancel() is ignored.

Note: Do not call this function directly from any of the running task's handlers or task tree's signals.

See also: ~TaskTree()

Definition at line 2988 of file tasktree.cpp.

References Tasking::Guard::isLocked(), Tasking::TaskTreePrivate::m_guard, QT_ASSERT, qWarning, and Tasking::TaskTreePrivate::stop().

Referenced by runBlocking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ done

void Tasking::TaskTree::done ( DoneWith result )

signal

This signal is emitted when the task tree finished, passing the final result of the execution.

The task tree neither calls any handler, nor emits any signal anymore after this signal was emitted.

Note: Do not delete the task tree directly from this signal's handler. Use deleteLater() instead.

See also: started()

Referenced by Tasking::TaskTreeTaskAdapter::TaskTreeTaskAdapter(), runBlocking(), and Tasking::TaskTreeRunner::start().

Here is the caller graph for this function:

◆ isRunning()

bool Tasking::TaskTree::isRunning ( ) const

Returns true if the task tree is currently running; otherwise returns false.

See also: start(), cancel()

Definition at line 3000 of file tasktree.cpp.

References Tasking::TaskTreePrivate::m_runtimeRoot.

Referenced by setRecipe(), and start().

Here is the caller graph for this function:

◆ onStorageDone()

template<typename StorageStruct , typename Handler >

template< typename StorageStruct, typename Handler > void Tasking::TaskTree::onStorageDone	(	const Storage< StorageStruct > &	storage,
		Handler &&	handler )

inline

Installs a storage done handler for the storage to retrieve the final data dynamically from the running task tree.

The StorageHandler takes a const reference to the StorageStruct instance:

static QByteArray load(const QString &fileName) { ... }
 
Storage<QByteArray> storage;
 
const auto onLoaderSetup = [](ConcurrentCall<QByteArray> &concurrent) {
    concurrent.setConcurrentCallData(&load, "foo.txt");
};
const auto onLoaderDone = [storage](const ConcurrentCall<QByteArray> &concurrent) {
    *storage = concurrent.result();
};
 
const Group root {
    storage,
    ConcurrentCallTask(onLoaderSetup, onLoaderDone, CallDoneIf::Success)
};
 
TaskTree taskTree(root);
auto collectStorage = [](const QByteArray &storage){
    qDebug() << "final content" << storage;
};
taskTree.onStorageDone(storage, collectStorage);
taskTree.start();

When the running task tree is about to leave a Group where the storage is placed in, it destructs a StorageStruct instance. Just before the StorageStruct instance is destructed, and after all possible handlers from this group were called, the task tree invokes the passed handler. This enables reading the final content of the given storage dynamically and processing it further outside of the task tree.

This handler is called also when the running tree is canceled. However, it's not called when the running tree is destructed.

See also: onStorageSetup()

Definition at line 586 of file tasktree.h.

References storage.

◆ onStorageSetup()

template<typename StorageStruct , typename Handler >

template< typename StorageStruct, typename Handler > void Tasking::TaskTree::onStorageSetup	(	const Storage< StorageStruct > &	storage,
		Handler &&	handler )

inline

Installs a storage setup handler for the storage to pass the initial data dynamically to the running task tree.

The StorageHandler takes a reference to the StorageStruct instance:

static void save(const QString &fileName, const QByteArray &array) { ... }
 
Storage<QByteArray> storage;
 
const auto onSaverSetup = [storage](ConcurrentCall<QByteArray> &concurrent) {
    concurrent.setConcurrentCallData(&save, "foo.txt", *storage);
};
 
const Group root {
    storage,
    ConcurrentCallTask(onSaverSetup)
};
 
TaskTree taskTree(root);
auto initStorage = [](QByteArray &storage){
    storage = "initial content";
};
taskTree.onStorageSetup(storage, initStorage);
taskTree.start();

When the running task tree enters a Group where the storage is placed in, it creates a StorageStruct instance, ready to be used inside this group. Just after the StorageStruct instance is created, and before any handler of this group is called, the task tree invokes the passed handler. This enables setting up initial content for the given storage dynamically. Later, when any group's handler is invoked, the task tree activates the created and initialized storage, so that it's available inside any group's handler.

See also: onStorageDone()

Definition at line 578 of file tasktree.h.

References storage.

◆ progressMaximum()

int Tasking::TaskTree::progressMaximum ( ) const

inline

Returns the maximum progressValue().

Note: Currently, it's the same as taskCount(). This might change in the future.

See also: progressValue()

Definition at line 574 of file tasktree.h.

◆ progressValue()

int Tasking::TaskTree::progressValue ( ) const

Returns the current progress value, which is between the 0 and progressMaximum().

The returned number indicates how many tasks have been already finished, canceled, or skipped while the task tree is running. When the task tree is started, this number is set to 0. When the task tree is finished, this number always equals progressMaximum().

See also: progressMaximum(), progressValueChanged()

Definition at line 3170 of file tasktree.cpp.

References Tasking::TaskTreePrivate::m_progressValue.

◆ progressValueChanged

void Tasking::TaskTree::progressValueChanged ( int value )

signal

This signal is emitted when the running task tree finished, canceled, or skipped some tasks.

The value gives the current total number of finished, canceled or skipped tasks. When the task tree is started, and after the started() signal was emitted, this signal is emitted with an initial value of 0. When the task tree is about to finish, and before the done() signal is emitted, this signal is emitted with the final value of progressMaximum().

See also: progressValue(), progressMaximum()

◆ runBlocking() [1/4]

DoneWith Tasking::TaskTree::runBlocking ( )

Executes a local event loop with QEventLoop::ExcludeUserInputEvents and starts the task tree.

Returns DoneWith::Success if the task tree finished successfully; otherwise returns DoneWith::Error.

Note: Avoid using this method from the main thread. Use asynchronous start() instead. This method is to be used in non-main threads or in auto tests.

See also: start()

Definition at line 3016 of file tasktree.cpp.

References runBlocking().

Referenced by runBlocking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ runBlocking() [2/4]

static DoneWith Tasking::TaskTree::runBlocking	(	const Group &	recipe,
		const QFuture< void > &	future,
		std::chrono::milliseconds	timeout = std::chrono::milliseconds::max() )

static

◆ runBlocking() [3/4]

static DoneWith Tasking::TaskTree::runBlocking	(	const Group &	recipe,
		std::chrono::milliseconds	timeout = std::chrono::milliseconds::max() )

static

◆ runBlocking() [4/4]

DoneWith Tasking::TaskTree::runBlocking ( const QFuture< void > & future )

Definition at line 3029 of file tasktree.cpp.

References Tasking::Cancel, cancel(), QFuture< T >::cancel(), QFutureWatcherBase::canceled(), QObject::connect(), done(), QEventLoop::ExcludeUserInputEvents, QEventLoop::exec(), future, QMetaObject::invokeMethod(), QFuture< T >::isCanceled(), Qt::QueuedConnection, QEventLoop::quit(), QTimer::singleShot, start(), and watcher.

Here is the call graph for this function:

◆ setRecipe()

void Tasking::TaskTree::setRecipe ( const Group & recipe )

Sets a given recipe for the task tree.

After the task tree is started, it executes the tasks contained inside the recipe and handles finished tasks according to the passed description.

Note: When called for a running task tree, the call is ignored.

See also: TaskTree(const Tasking::Group &recipe), start()

Definition at line 2896 of file tasktree.cpp.

References Tasking::Guard::isLocked(), isRunning(), Tasking::TaskTreePrivate::m_guard, Tasking::TaskTreePrivate::m_root, Tasking::TaskTreePrivate::m_storages, QT_ASSERT, and qWarning.

Referenced by TaskTree().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start()

void Tasking::TaskTree::start ( )

Starts the task tree.

Use setRecipe() or the constructor to set the declarative description according to which the task tree will execute the contained tasks and handle finished tasks.

When the task tree is empty, that is, constructed with a default constructor, a call to start() is no-op and the relevant warning message is issued.

Otherwise, when the task tree is already running, a call to start() is ignored and the relevant warning message is issued.

Otherwise, the task tree is started.

The started task tree may finish synchronously, for example when the main group's start handler returns SetupResult::StopWithError. For this reason, the connection to the done signal should be established before calling start(). Use isRunning() in order to detect whether the task tree is still running after a call to start().

The task tree implementation relies on the running event loop. Make sure you have a QEventLoop or QCoreApplication or one of its subclasses running (or about to be run) when calling this method.

See also: TaskTree(const Tasking::Group &), setRecipe(), isRunning(), cancel()

Definition at line 2932 of file tasktree.cpp.

References Tasking::Guard::isLocked(), isRunning(), Tasking::TaskTreePrivate::m_guard, QT_ASSERT, qWarning, and Tasking::TaskTreePrivate::start().

Referenced by runBlocking(), and Tasking::TaskTreeTaskAdapter::start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ started

void Tasking::TaskTree::started ( )

signal

This signal is emitted when the task tree is started.

The emission of this signal is followed synchronously by the progressValueChanged() signal with an initial 0 value.

See also: start(), done()

◆ taskCount()

int Tasking::TaskTree::taskCount ( ) const

Returns the number of asynchronous tasks contained in the stored recipe.

Note: The returned number doesn't include \l {Tasking::Sync} {Sync} tasks.; Any task or group that was set up using withTimeout() increases the total number of tasks by 1.

See also: setRecipe(), progressMaximum()

Definition at line 3132 of file tasktree.cpp.

References Tasking::TaskTreePrivate::m_root.

Friends And Related Symbol Documentation

◆ runBlocking() [1/2]

Tasking::runBlocking ( )

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

When the task tree is canceled, this method cancels the passed future.

◆ runBlocking() [2/2]

Tasking::runBlocking	(	const Group &	recipe,
		milliseconds	timeout )

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

When the task tree is canceled, this method cancels the passed future.

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

qtbase/src/assets/downloader/tasking/tasktree.h (78de81e286d89a5396b08b67ca98ccedda8a836f)
qtbase/src/assets/downloader/tasking/tasktree.cpp (78de81e286d89a5396b08b67ca98ccedda8a836f)

Signals

Public Member Functions

Static Public Member Functions

Related Symbols

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TaskTree() [1/2]

◆ TaskTree() [2/2]

◆ ~TaskTree()

Member Function Documentation

◆ asyncCount()

◆ asyncCountChanged

◆ cancel()

◆ done

◆ isRunning()

◆ onStorageDone()

◆ onStorageSetup()

◆ progressMaximum()

◆ progressValue()

◆ progressValueChanged

◆ runBlocking() [1/4]

◆ runBlocking() [2/4]

◆ runBlocking() [3/4]

◆ runBlocking() [4/4]

◆ setRecipe()

◆ start()

◆ started

◆ taskCount()

Friends And Related Symbol Documentation

◆ runBlocking() [1/2]

◆ runBlocking() [2/2]