Sur cette page

QtTaskTree Namespace

L'espace de noms QtTaskTree contient toutes les classes et fonctions globales du module TaskTree. Plus d'informations...

En-tête : #include <QtTaskTree>
CMake : find_package(Qt6 REQUIRED COMPONENTS TaskTree)
target_link_libraries(mytarget PRIVATE Qt6::TaskTree)
qmake : QT += tasktree
Depuis : Qt 6.11

Classes

(since 6.11) class Do
(since 6.11) class Else
(since 6.11) class ElseIf
(since 6.11) class ExecutableItem
(since 6.11) class ExecutionMode
(since 6.11) class For
(since 6.11) class Forever
(since 6.11) class ForeverIterator
(since 6.11) class Group
(since 6.11) class GroupItem
(since 6.11) class If
(since 6.11) class Iterator
(since 6.11) class ListIterator
(since 6.11) struct ObjectSignal
(since 6.11) class ParallelLimit
(since 6.11) class QBarrier
(since 6.11) class QCustomTask
(since 6.11) class QDefaultTaskAdapter
(since 6.11) class QMappedTaskTreeRunner
(since 6.11) class QNetworkReplyWrapper
(since 6.11) class QParallelTaskTreeRunner
(since 6.11) class QProcessTaskDeleter
(since 6.11) class QSequentialTaskTreeRunner
(since 6.11) class QSingleTaskTreeRunner
(since 6.11) class QStartedBarrier
(since 6.11) class QSyncTask
(since 6.11) class QTaskInterface
(since 6.11) class QTaskTree
(since 6.11) class QTcpSocketWrapper
(since 6.11) class QThreadFunction
(since 6.11) class QThreadFunctionBase
(since 6.11) class RepeatIterator
(since 6.11) class Storage
(since 6.11) class Then
(since 6.11) class UntilIterator
(since 6.11) class When

Types

BarrierKickerGetter
flags CallDone
enum class CallDoneFlag { Never, OnSuccess, OnError, OnCancel, Always }
enum class DoneResult { Success, Error }
enum class DoneWith { Success, Error, Cancel }
GroupItems
QBarrierTask
QNetworkReplyWrapperTask
QProcessTask
QStoredBarrier
QTaskTreeTask
QTcpSocketWrapperTask
QThreadFunctionTask
QTimeoutTask
enum class SetupResult { Continue, StopWithSuccess, StopWithError }
TreeDoneHandler
TreeSetupHandler
enum class WorkflowPolicy { StopOnError, ContinueOnError, StopOnSuccess, ContinueOnSuccess, StopOnSuccessOrError, …, FinishAllAndError }

Variables

const QtTaskTree::GroupItem continueOnError
const QtTaskTree::GroupItem continueOnSuccess
const QtTaskTree::ExecutableItem errorItem
const QtTaskTree::GroupItem finishAllAndError
const QtTaskTree::GroupItem finishAllAndSuccess
const QtTaskTree::GroupItem nullItem
const QtTaskTree::ExecutionMode parallel
const QtTaskTree::ExecutionMode parallelIdealThreadCountLimit
const QtTaskTree::ExecutionMode sequential
const QtTaskTree::GroupItem stopOnError
const QtTaskTree::GroupItem stopOnSuccess
const QtTaskTree::GroupItem stopOnSuccessOrError
const QtTaskTree::ExecutableItem successItem

Fonctions

QtTaskTree::ExecutableItem barrierAwaiterTask(const QtTaskTree::QStoredBarrier &storedBarrier)
QtTaskTree::ObjectSignal<std::decay_t<Signal>> makeObjectSignal(typename QtPrivate::FunctionPointer<Signal>::Object *object, Signal &&signal)
QtTaskTree::GroupItem onGroupDone(Handler &&handler, QtTaskTree::CallDone callDone = CallDoneFlag::Always)
QtTaskTree::GroupItem onGroupSetup(Handler &&handler)
QtTaskTree::ExecutableItem signalAwaiterTask(const typename QtPrivate::FunctionPointer<Signal>::Object *sender, Signal signal)
QtTaskTree::ExecutableItem timeoutTask(const std::chrono::milliseconds &timeout, QtTaskTree::DoneResult result = DoneResult::Error)
QtTaskTree::GroupItem workflowPolicy(QtTaskTree::WorkflowPolicy policy)

Description détaillée

Classes

classe Do

Un élément de corps utilisé avec les constructions For et When. Plus...

classe Else

Un élément "else" utilisé dans les expressions conditionnelles. En savoir plus...

Classe ElseIf

Un élément "else if" utilisé dans les expressions conditionnelles. En savoir plus...

classe ExecutableItem

Classe de base pour les éléments de tâches exécutables. En savoir plus...

classe ExecutionMode

L'élément de groupe décrivant le mode d'exécution. En savoir plus...

classe For

Élément d'une boucle for. Plus...

classe Forever

Boucle infinie de sous-tâches. Plus...

classe ForeverIterator

Itérateur infini à utiliser dans l'élément For. En savoir plus...

classe Group

Group représente l'élément de base pour composer des recettes déclaratives décrivant comment exécuter et gérer un arbre imbriqué de tâches asynchrones. En savoir plus...

Classe GroupItem

GroupItem représente l'élément de base qui peut faire partie de n'importe quel site Group. Plus...

classe If

Un élément "if" utilisé dans les expressions conditionnelles. En savoir plus...

classe Iterator

Classe de base utilisée comme itérateur à l'intérieur d'un élément For. En savoir plus...

classe ListIterator

Itérateur de liste à utiliser dans l'élément For. En savoir plus...

classe ObjectSignal

Structure décrivant la sous-classe QObject et son signal. Plus...

classe ParallelLimit

Mode d'exécution parallèle avec une limite personnalisée. En savoir plus...

classe QBarrier

Une tâche asynchrone qui se termine à la demande. En savoir plus...

classe QCustomTask

Un modèle de classe utilisé pour déclarer des tâches personnalisées et définir leurs gestionnaires de configuration et d'exécution. En savoir plus...

classe QDefaultTaskAdapter

Un modèle de classe fournissant l'adaptateur de tâche par défaut utilisé dans QCustomTask. Plus...

classe QMappedTaskTreeRunner

Contrôleur d'exécution d'un arbre de tâches mappé avec un type de clé donné. Plus...

Classe QNetworkReplyWrapper

Une enveloppe autour de QNetworkReply et QNetworkAccessManager. Plus...

Classe QParallelTaskTreeRunner

Contrôleur d'exécution d'un arbre de tâches parallèles. En savoir plus...

Classe QProcessTaskDeleter

Un suppresseur personnalisé pour QProcess, utilisé par QProcessTask. Plus...

Classe QSequentialTaskTreeRunner

Contrôleur d'exécution d'un arbre de tâches séquentiel. En savoir plus...

Classe QSingleTaskTreeRunner

Un contrôleur d'exécution d'arbre de tâches unique. Plus d'informations...

Classe QStartedBarrier

Une barrière démarrée QBarrier avec une limite donnée. Plus...

classe QSyncTask

Exécute de manière synchrone un gestionnaire personnalisé entre d'autres tâches. En savoir plus...

classe QTaskInterface

QTaskInterface est une classe d'aide utilisée pour adapter l'interface d'une tâche personnalisée. En savoir plus...

classe QTaskTree

La classe QTaskTree gère l'arbre des tâches asynchrones définies de manière déclarative. En savoir plus...

Classe QTcpSocketWrapper

Un wrapper autour de QTcpSocket. Plus...

classe QThreadFunction

Un modèle de classe contrôlant l'exécution d'une fonction dans un thread séparé via QtConcurrent::run(). Plus...

classe QThreadFunctionBase

Une classe de base pour le modèle de classe QThreadFunction. Plus...

classe RepeatIterator

L'itérateur répétitif à utiliser à l'intérieur de For element. En savoir plus...

classe Storage

Un modèle de classe pour l'échange de données personnalisées dans l'arbre des tâches en cours d'exécution. En savoir plus...

classe Then

Un élément "then" utilisé dans les expressions conditionnelles. En savoir plus...

classe UntilIterator

L'itérateur conditionnel à utiliser dans l'élément For. En savoir plus...

classe When

Un élément qui retarde l'exécution d'un corps jusqu'à ce que la barrière avance. Plus...

Documentation des types

[alias] BarrierKickerGetter

Type alias pour la fonction prenant QStoredBarrier et retournant ExecutableItem, c'est-à-dire std::function<ExecutableItem(const QStoredBarrier &)>, à utiliser dans le constructeur When.

enum class QtTaskTree::CallDoneFlag
flags QtTaskTree::CallDone

Cette énumération est un argument facultatif pour l'élément onGroupDone() ou le constructeur d'une tâche personnalisée. Elle indique à l'arbre des tâches quand le gestionnaire de tâches du groupe ou de la tâche doit être invoqué.

ConstanteValeurDescription de la constante
QtTaskTree::CallDoneFlag::Never0Le gestionnaire done n'est jamais invoqué.
QtTaskTree::CallDoneFlag::OnSuccess1 << 0Le gestionnaire done n'est invoqué qu'après une exécution réussie, c'est-à-dire lorsque DoneWith::Success.
QtTaskTree::CallDoneFlag::OnError1 << 1Le gestionnaire done n'est invoqué qu'après une exécution ratée, c'est-à-dire lorsque DoneWith::Error.
QtTaskTree::CallDoneFlag::OnCancel1 << 2Le gestionnaire "done" n'est invoqué qu'après une exécution annulée, c'est-à-dire lorsque DoneWith::Cancel.
QtTaskTree::CallDoneFlag::AlwaysOnSuccess | OnError | OnCancelLe gestionnaire done est toujours invoqué.

Le type CallDone est un typedef pour QFlags<CallDoneFlag>. Il stocke une combinaison OU de valeurs CallDoneFlag.

enum class QtTaskTree::DoneResult

Cette énumération est optionnellement renvoyée par la fonction done handler du groupe ou de la tâche. Lorsque le gestionnaire done ne renvoie aucune valeur, c'est-à-dire que son type de retour est void, sa valeur de retour finale est automatiquement déduite par l'arbre des tâches en cours d'exécution et communiquée à son groupe parent.

Lorsque le gestionnaire done renvoie le DoneResult, vous pouvez modifier la valeur de retour finale à l'intérieur du gestionnaire.

Lorsque le DoneResult est renvoyé par le gestionnaire done du groupe, la politique de flux de travail du groupe est ignorée.

Cette énumération est également utilisée dans le signal TaskInterface::done() et indique si la tâche s'est terminée avec succès ou avec une erreur.

ConstanteValeurDescription
QtTaskTree::DoneResult::Success0L'exécution du groupe ou de la tâche se termine par un succès.
QtTaskTree::DoneResult::Error1L'exécution du groupe ou de la tâche se termine par une erreur.

enum class QtTaskTree::DoneWith

Cette énumération est un argument facultatif pour le gestionnaire d'achèvement du groupe ou de la tâche. Elle indique si le groupe ou la tâche s'est terminé par un succès ou une erreur, ou s'il a été annulé.

Il est également utilisé comme argument dans le signal QTaskTree::done(), indiquant le résultat final de l'exécution de QTaskTree.

ConstanteValeurDescription du groupe ou de la tâche
QtTaskTree::DoneWith::Success0L'exécution du groupe ou de la tâche s'est terminée avec succès.
QtTaskTree::DoneWith::Error1L'exécution du groupe ou de la tâche s'est terminée par une erreur.
QtTaskTree::DoneWith::Cancel2L'exécution du groupe ou de la tâche a été annulée. Cela se produit lorsque l'utilisateur appelle QTaskTree::cancel() pour l'arbre des tâches en cours d'exécution ou lorsque la politique de flux de travail du groupe entraîne l'annulation de certains de ses enfants en cours d'exécution. Modifier le résultat final du gestionnaire done en renvoyant DoneResult depuis le gestionnaire n'est pas possible lorsque l'exécution du groupe ou de la tâche a été annulée.

[alias] QtTaskTree::GroupItems

Type d'alias pour QList<GroupItem>.

[alias] QBarrierTask

Type d'alias pour le QCustomTask<QBarrier>, à utiliser dans les recettes.

[alias] QNetworkReplyWrapperTask

Type d'alias pour le QCustomTask<QNetworkReplyWrapper>, à utiliser dans les recettes.

[alias] QProcessTask

Type d'alias pour le QCustomTask<QProcess>, utilisant QProcessTaskDeleter, à utiliser dans les recettes.

[alias] QStoredBarrier

Type d'alias pour le QtTaskTree::Storage<QStartedBarrier>, à utiliser dans les recettes.

[alias] QTaskTreeTask

Type d'alias pour le QCustomTask<QTaskTree>, à utiliser dans les recettes.

[alias] QTcpSocketWrapperTask

Type d'alias pour le QCustomTask<QTcpSocketWrapper>, à utiliser dans les recettes.

[alias] template <typename ResultType> QThreadFunctionTask

Type alias pour le QCustomTask<QThreadFunction<ResultType>>, à utiliser dans les recettes.

[alias] QTimeoutTask

Type d'alias pour le QCustomTask<std::chrono::milliseconds>, à utiliser dans les recettes. std::chrono::milliseconds est utilisé pour définir la durée du délai d'attente. La durée par défaut est std::chrono::milliseconds::zero(), c'est-à-dire que la QTimeoutTask se termine dès que le contrôle revient dans la boucle d'événements en cours.

Exemple d'utilisation :

using namespace std::chrono;
using namespace std::chrono_literals;

const auto onSetup = [](milliseconds &timeout) { timeout = 1000ms; }
const auto onDone = [] { qDebug() << "Timed out."; }

const Group root {
    QTimeoutTask(onSetup, onDone)
};

Voir également timeoutTask().

enum class QtTaskTree::SetupResult

Cette énumération est optionnellement renvoyée par la fonction de gestion de l'installation du groupe ou de la tâche. Elle indique à l'arbre des tâches en cours d'exécution comment procéder après la fin de l'exécution du gestionnaire de configuration.

ConstanteValeurDescription de la constante
QtTaskTree::SetupResult::Continue0Valeur par défaut. L'exécution du groupe ou de la tâche se poursuit normalement. Lorsque le gestionnaire de configuration d'un groupe ou d'une tâche renvoie void, on suppose qu'il a renvoyé Continue.
QtTaskTree::SetupResult::StopWithSuccess1L'exécution du groupe ou de la tâche s'arrête immédiatement en cas de succès. Lorsque le gestionnaire de configuration du groupe renvoie void, toutes les tâches enfants sont ignorées et le gestionnaire onGroupDone() du groupe est invoqué avec DoneWith::Success. Le groupe signale le succès à son parent. La politique de flux de travail du groupe est ignorée. Lorsqu'elle est renvoyée par le gestionnaire de configuration de la tâche, la tâche n'est pas démarrée, son gestionnaire done n'est pas invoqué et la tâche signale son succès à son parent.
QtTaskTree::SetupResult::StopWithError2L'exécution du groupe ou de la tâche s'arrête immédiatement avec une erreur. Lors du retour du gestionnaire de configuration du groupe, toutes les tâches enfants sont ignorées et le gestionnaire onGroupDone() du groupe est invoqué avec DoneWith::Error. Le groupe signale une erreur à son parent. La politique de flux de travail du groupe est ignorée. Lorsqu'elle est renvoyée par le gestionnaire de configuration de la tâche, la tâche n'est pas lancée, son gestionnaire d'erreur n'est pas invoqué et la tâche signale une erreur à son parent.

[alias] QtTaskTree::TreeDoneHandler

Type alias de std::function<void(const QTaskTree &, QtTaskTree::DoneWith)>.

Le TreeDoneHandler est un argument facultatif des fonctions des exécutants de l'arbre des tâches qui planifient l'exécution de l'arbre des tâches. La fonction est appelée lorsque la recette de l'exécutant de l'arbre des tâches a terminé l'exécution. L'accès à QTaskTree et au résultat de la recette se fait via les arguments passés.

Les exécutants d'arborescence des tâches acceptent également les gestionnaires sous une forme abrégée de std::function<void(const QTaskTree &)>, std::function<void(QtTaskTree::DoneWith)>, ou std::function<void(void)>.

[alias] QtTaskTree::TreeSetupHandler

Type alias pour std::function<void(QTaskTree &)>.

L'adresse TreeSetupHandler est un argument facultatif des fonctions des exécutants de l'arbre des tâches qui planifient l'exécution de l'arbre des tâches. La fonction est appelée lorsque l'exécutant de l'arbre des tâches est sur le point d'exécuter sa recette. L'accès à QTaskTree se fait via l'argument passé.

Les exécutants d'arborescence des tâches acceptent également des gestionnaires sous la forme abrégée de std::function<void(void)>.

enum class QtTaskTree::WorkflowPolicy

Cette énumération décrit le comportement possible de l'élément Group lorsque la tâche enfant d'un groupe termine son exécution. Elle est également utilisée lorsque le groupe en cours d'exécution est annulé.

ConstanteValeurDescription
QtTaskTree::WorkflowPolicy::StopOnError0Valeur par défaut. Correspond à l'élément global stopOnError. Si une tâche enfant se termine par une erreur, le groupe s'arrête et se termine par une erreur. Si toutes les tâches enfant se sont terminées avec succès, le groupe se termine avec succès. Si un groupe est vide, il se termine avec succès.
QtTaskTree::WorkflowPolicy::ContinueOnError1Correspond à l'élément global continueOnError. Semblable à stopOnError, mais si un enfant termine avec une erreur, l'exécution se poursuit jusqu'à ce que toutes les tâches se terminent, et le groupe signale une erreur par la suite, même si d'autres tâches du groupe se sont terminées avec succès. Si toutes les tâches enfants se terminent avec succès, le groupe se termine avec succès. Si un groupe est vide, il se termine avec succès.
QtTaskTree::WorkflowPolicy::StopOnSuccess2Correspond à l'élément global stopOnSuccess. Si une tâche enfant se termine avec succès, le groupe s'arrête et se termine avec succès. Si toutes les tâches enfants se sont terminées par une erreur, le groupe se termine par une erreur. Si un groupe est vide, il se termine par une erreur.
QtTaskTree::WorkflowPolicy::ContinueOnSuccess3Correspond à l'élément global continueOnSuccess. Semblable à stopOnSuccess, mais si un enfant termine avec succès, l'exécution se poursuit jusqu'à ce que toutes les tâches se terminent, et le groupe indique ensuite qu'il a réussi, même si d'autres tâches du groupe se sont terminées par une erreur. Si toutes les tâches enfants se terminent par une erreur, le groupe se termine par une erreur. Si un groupe est vide, il se termine par une erreur.
QtTaskTree::WorkflowPolicy::StopOnSuccessOrError4Correspond à l'élément global stopOnSuccessOrError. Le groupe démarre autant de tâches qu'il le peut. Lorsqu'une tâche se termine, le groupe s'arrête et communique le résultat de la tâche. Utile uniquement en mode parallèle. En mode séquentiel, seule la première tâche est lancée et, lorsqu'elle est terminée, le groupe se termine également, de sorte que les autres tâches sont toujours ignorées. Si un groupe est vide, il se termine par une erreur.
QtTaskTree::WorkflowPolicy::FinishAllAndSuccess5Correspond à l'élément global finishAllAndSuccess. Le groupe exécute toutes les tâches et ignore leurs résultats. Lorsque toutes les tâches sont terminées, le groupe se termine par un succès. Si un groupe est vide, il se termine avec succès.
QtTaskTree::WorkflowPolicy::FinishAllAndError6Correspond à l'élément global finishAllAndError. Le groupe exécute toutes les tâches et ignore leurs résultats. Lorsque toutes les tâches sont terminées, le groupe se termine par une erreur. Si un groupe est vide, il se termine par une erreur.

Lorsque le résultat d'une tâche enfant entraîne l'arrêt du groupe, c'est-à-dire dans le cas des politiques StopOnError, StopOnSuccess ou StopOnSuccessOrError, le groupe annule les autres tâches enfants en cours d'exécution (s'il y en a - par exemple en mode parallèle) et saute les tâches qu'il n'a pas encore lancées (par exemple, en mode séquentiel - celles qui sont placées après la tâche qui a échoué). L'annulation et le saut de tâches enfantines peuvent se produire lorsque ParallelLimit est utilisé.

Le tableau ci-dessous résume les différences entre les diverses politiques de flux de travail :

WorkflowPolicyExécute toutes les tâches enfantRésultatRésultat lorsque le groupe est vide
StopOnErrorS'arrête lorsqu'une tâche enfant s'est terminée avec une erreur et signale une erreur.Erreur si au moins une tâche enfant a échoué, succès dans le cas contraireRéussite
ContinueOnErrorOuiUne erreur lorsqu'au moins une tâche enfant a échoué, succès sinonSuccès
StopOnSuccessS'arrête lorsqu'une tâche enfant s'est terminée avec succès et signale le succès.Succès lorsqu'au moins une tâche enfant a réussi, erreur dans le cas contraireUne erreur
ContinueOnSuccessOuiSuccès lorsqu'au moins une tâche enfant a réussi, erreur dans le cas contraireUne erreur
StopOnSuccessOrErrorS'arrête lorsque l'une des tâches enfant est terminée et signale le résultat de la tâche enfantSuccès ou erreur, en fonction du résultat de la tâche enfant terminéeUne erreur
FinishAllAndSuccessOuiSuccèsSuccès
FinirToutEtErreurOuiUne erreurUne erreur

Si un enfant d'un groupe est également un groupe, le groupe enfant exécute ses tâches conformément à sa propre politique de flux de travail. Lorsqu'un groupe parent arrête le groupe enfant en cours d'exécution en raison de la politique de flux de travail du groupe parent, c'est-à-dire lorsque la politique StopOnError, StopOnSuccess ou StopOnSuccessOrError a été utilisée pour le parent, le résultat du groupe enfant est indiqué dans la colonne Result et sur la ligne Politique de flux de travail du groupe enfant dans le tableau ci-dessus.

Documentation des variables

const QtTaskTree::GroupItem QtTaskTree::continueOnError

Un élément pratique du groupe global décrivant la politique de flux de travail de ContinueOnError.

const QtTaskTree::GroupItem QtTaskTree::continueOnSuccess

Un élément pratique du groupe global décrivant la politique de flux de travail de ContinueOnSuccess.

const QtTaskTree::ExecutableItem QtTaskTree::errorItem

Un élément exécutable global pratique contenant une tâche synchrone vide et erronée.

Cet élément est utile dans les énoncés if pour indiquer qu'une branche se termine par une erreur :

const ExecutableItem conditionalTask = ...;

Group group {
    stopOnError,
    If (conditionalTask) >> Then {
        ...
    } >> Else {
        errorItem
    },
    nextTask
};

Dans l'exemple ci-dessus, si la branche conditionalTask se termine par une erreur, la branche Else est choisie, qui se termine immédiatement par une erreur. stopOnError La branche nextTask est alors ignorée (en raison de la politique de flux de travail de la branche group) et la branche group se termine par une erreur.

Voir aussi successItem.

const QtTaskTree::GroupItem QtTaskTree::finishAllAndError

Un élément pratique du groupe global décrivant la politique de flux de travail de FinishAllAndError.

const QtTaskTree::GroupItem QtTaskTree::finishAllAndSuccess

Un élément pratique du groupe global décrivant la politique de flux de travail de FinishAllAndSuccess.

const QtTaskTree::GroupItem QtTaskTree::nullItem

Un élément de groupe global pratique indiquant un élément non optionnel.

Il est utile dans les expressions conditionnelles pour indiquer l'absence d'un élément optionnel :

const ExecutableItem task = ...;
const std::optional<ExecutableItem> optionalTask = ...;

Group group {
    task,
    optionalTask ? *optionalTask : nullItem
};

const QtTaskTree::ExecutionMode QtTaskTree::parallel

Un élément de groupe global pratique décrivant le mode d'exécution parallèle.

Toutes les tâches enfant directes d'un groupe sont lancées après le démarrage du groupe, sans attendre la fin des tâches enfant précédentes. Dans ce mode, toutes les tâches enfants s'exécutent simultanément.

Voir également sequential et ParallelLimit.

const QtTaskTree::ExecutionMode QtTaskTree::parallelIdealThreadCountLimit

Un élément de groupe global pratique décrivant le mode d'exécution parallèle avec un nombre limité de tâches s'exécutant simultanément. La limite est égale au nombre idéal de threads, à l'exclusion du thread appelant.

Il s'agit d'un raccourci vers :

ParallelLimit(qMax(QThread::idealThreadCount() - 1, 1))

Voir également parallel et ParallelLimit.

const QtTaskTree::ExecutionMode QtTaskTree::sequential

Un élément de groupe global pratique décrivant le mode d'exécution séquentiel.

Il s'agit du mode d'exécution par défaut de l'élément Group.

Lorsqu'un groupe n'a pas de mode d'exécution, il fonctionne en mode séquentiel. Toutes les tâches enfant directes d'un groupe sont lancées en chaîne, de sorte que lorsqu'une tâche se termine, la suivante démarre. Cela vous permet de transmettre les résultats de la tâche précédente à la tâche suivante avant qu'elle ne démarre. Ce mode garantit que la tâche suivante n'est lancée qu'après la fin de la tâche précédente.

Voir également parallel et ParallelLimit.

const QtTaskTree::GroupItem QtTaskTree::stopOnError

Un élément de groupe global pratique décrivant la politique de flux de travail de StopOnError.

Il s'agit de la politique de flux de travail par défaut de l'élément Group.

const QtTaskTree::GroupItem QtTaskTree::stopOnSuccess

Un élément pratique du groupe global décrivant la politique de flux de travail de StopOnSuccess.

const QtTaskTree::GroupItem QtTaskTree::stopOnSuccessOrError

Un élément pratique du groupe global décrivant la politique de flux de travail de StopOnSuccessOrError.

const QtTaskTree::ExecutableItem QtTaskTree::successItem

Un élément exécutable global pratique contenant une tâche synchrone vide et réussie.

Cet élément est utile dans les déclarations "if" pour indiquer qu'une branche se termine par un succès :

const ExecutableItem conditionalTask = ...;

const Group group {
    stopOnSuccess,
    If (conditionalTask) >> Then {
        ...
    } >> Else {
        successItem
    },
    nextTask
};

Dans l'exemple ci-dessus, si la tâche conditionalTask se termine par une erreur, la branche Else est choisie, qui se termine immédiatement par un succès. La branche nextTask est donc ignorée (en raison de la politique de flux de travail stopOnSuccess de la branche group) et la branche group se termine avec succès.

Voir également errorItem.

Documentation sur les fonctions

QtTaskTree::ExecutableItem QtTaskTree::barrierAwaiterTask(const QtTaskTree::QStoredBarrier &storedBarrier)

Renvoie la tâche d'attente qui se termine lorsque la tâche storedBarrier est terminée.

Note : Le storedBarrier passé doit être placé dans la même recette qu'un élément frère de la tâche renvoyée ou dans un ancêtre Group, sinon vous pouvez vous attendre à un plantage.

template <typename Signal> QtTaskTree::ObjectSignal<std::decay_t<Signal>> QtTaskTree::makeObjectSignal(typename QtPrivate::FunctionPointer<Signal>::Object *object, Signal &&signal)

Une fonction conventionnelle pour créer ObjectSignal à l'intérieur de la fonction ObjectSignalGetter passée à ExecutableItem::withCancel() ou ExecutableItem::withAccept(). Passez un object et son signal pour créer une instance de la structure ObjectSignal.

Voir aussi ObjectSignal, ExecutableItem::withCancel(), et ExecutableItem::withAccept().

template <typename Handler> QtTaskTree::GroupItem QtTaskTree::onGroupDone(Handler &&handler, QtTaskTree::CallDone callDone = CallDoneFlag::Always)

Construit un élément de groupe contenant le gestionnaire de fin de groupe. Par défaut, le handler est invoqué à chaque fois que le groupe se termine. Passez une valeur différente de la valeur par défaut pour l'argument callDone si vous souhaitez que le gestionnaire ne soit appelé qu'en cas de réussite, d'échec ou d'annulation de l'exécution. En fonction de la politique de flux de travail du groupe, ce gestionnaire peut également être appelé lorsque le groupe en cours d'exécution est annulé (par exemple, lorsque l'élément stopOnError a été utilisé).

L'élément handler transmis est du type std::function<DoneResult(DoneWith)>. En option, le type de retour DoneResult ou le type d'argument DoneWith peut être omis (c'est-à-dire que le type de retour peut être void). Pour plus d'informations sur un type de gestionnaire possible, voir GroupItem::GroupDoneHandler.

Lorsque handler est invoqué, toutes les tâches enfant du groupe sont déjà terminées.

Si un groupe contient des éléments Storage, le handler est invoqué avant que les storages ne soient détruits, de sorte que le handler puisse encore effectuer une dernière lecture des données des storages actifs.

Voir également GroupItem::GroupDoneHandler et onGroupSetup().

template <typename Handler> QtTaskTree::GroupItem QtTaskTree::onGroupSetup(Handler &&handler)

Construit un élément de groupe contenant le gestionnaire de configuration du groupe. Le handler est invoqué chaque fois que le groupe démarre.

L'adresse handler transmise est de type std::function<SetupResult()> ou std::function<void()>. Pour plus d'informations sur un type de gestionnaire possible, voir GroupItem::GroupSetupHandler.

Lorsque le handler est invoqué, aucune des tâches enfant du groupe n'est encore en cours d'exécution.

Si un groupe contient des éléments Storage, le handler est invoqué après la construction des storages, de sorte que le handler peut déjà effectuer certaines modifications initiales sur les storages actifs.

Voir également GroupItem::GroupSetupHandler et onGroupDone().

template <typename Signal> QtTaskTree::ExecutableItem QtTaskTree::signalAwaiterTask(const typename QtPrivate::FunctionPointer<Signal>::Object *sender, Signal signal)

Renvoie la tâche d'attente qui se termine lorsque la tâche sender émet la tâche signal.

Remarque : la connexion avec sender et signal n'est pas établie lorsque la tâche renvoyée est créée ou placée dans une recette, mais lorsque la tâche est lancée par QTaskTree. Ainsi, sender survit à tout arbre de tâches en cours d'exécution contenant la tâche renvoyée. Si le signal a été émis avant le démarrage de la tâche, c'est-à-dire avant l'établissement de la connexion, la tâche se terminera à la première émission du signal après le démarrage de la tâche.

QtTaskTree::ExecutableItem QtTaskTree::timeoutTask(const std::chrono::milliseconds &timeout, QtTaskTree::DoneResult result = DoneResult::Error)

Crée QTimeoutTask avec une durée de timeout, après quoi la tâche se termine avec result.

Voir aussi QTimeoutTask.

QtTaskTree::GroupItem QtTaskTree::workflowPolicy(QtTaskTree::WorkflowPolicy policy)

Construit l'élément workflow policy d'un groupe pour un policy donné.

Pour des raisons de commodité, des éléments globaux peuvent être utilisés à la place.

Voir aussi stopOnError, continueOnError, stopOnSuccess, continueOnSuccess, stopOnSuccessOrError, finishAllAndSuccess, finishAllAndError, et WorkflowPolicy.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.