Sur cette page

QtTaskTree Namespace

L'espace de noms QtTaskTree regroupe toutes les classes et fonctions globales du module TaskTree. En savoir plus...

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
Statut : Aperçu technologique

Cet espace de noms est en préversion technologique et est susceptible d'être modifié.

Classes

(technology preview) class Do
(technology preview) class Else
(technology preview) class ElseIf
(technology preview) class ExecutableItem
(technology preview) class ExecutionMode
(technology preview) class For
(technology preview) class Forever
(technology preview) class ForeverIterator
(technology preview) class Group
(technology preview) class GroupItem
(technology preview) class If
(technology preview) class Iterator
(technology preview) class ListIterator
(technology preview) struct ObjectSignal
(technology preview) class ParallelLimit
(technology preview) class QBarrier
(technology preview) class QCustomTask
(technology preview) class QDefaultTaskAdapter
(technology preview) class QMappedTaskTreeRunner
(technology preview) class QNetworkReplyWrapper
(technology preview) class QParallelTaskTreeRunner
(technology preview) class QProcessTaskDeleter
(technology preview) class QSequentialTaskTreeRunner
(technology preview) class QSingleTaskTreeRunner
(technology preview) class QStartedBarrier
(technology preview) class QSyncTask
(technology preview) class QTaskInterface
(technology preview) class QTaskTree
(technology preview) class QTcpSocketWrapper
(technology preview) class QThreadFunction
(technology preview) class QThreadFunctionBase
(technology preview) class RepeatIterator
(technology preview) class Storage
(technology preview) class Then
(technology preview) class UntilIterator
(technology preview) 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

Élément de corps utilisé avec les constructions « For » et « When ». En savoir plus…

classe Else

Élément « else » utilisé dans les expressions conditionnelles. En savoir plus...

classe ElseIf

Élément « else if » utilisé dans les expressions conditionnelles. En savoir plus...

classe ExecutableItem

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

classe ExecutionMode

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

classe For

Élément de boucle « for ». En savoir plus...

classe Forever

Boucle infinie de sous-tâches. En savoir plus...

classe ForeverIterator

Itérateur infini à utiliser à l'intérieur d'un élément « For ». En savoir plus...

classe Group

La classe Group représente l'élément de base permettant de composer des recettes déclaratives décrivant comment exécuter et gérer une arborescence imbriquée de tâches asynchrones. En savoir plus...

classe GroupItem

GroupItem représente l'élément de base pouvant faire partie de n'importe quel « Group ». En savoir plus...

classe If

Élément « if » utilisé dans les expressions conditionnelles. En savoir plus...

classe Iterator

Classe de base à utiliser comme itérateur à l'intérieur de l'élément « For ». En savoir plus...

classe ListIterator

L'itérateur de liste à utiliser à l'intérieur de l'élément « For ». En savoir plus...

classe ObjectSignal

Structure décrivant une sous-classe d QObject s et son signal. En savoir 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 éléments de tâche personnalisés et définir leurs gestionnaires de configuration et de fin. En savoir plus...

classe QDefaultTaskAdapter

Modèle de classe fournissant un adaptateur de tâche par défaut utilisé dans ` QCustomTask`. En savoir plus...

classe QMappedTaskTreeRunner

Contrôleur d'exécution d'arborescence de tâches mappées avec un type de clé donné. En savoir plus...

classe QNetworkReplyWrapper

Un wrapper autour de QNetworkReply et QNetworkAccessManager. En savoir plus...

classe QParallelTaskTreeRunner

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

classe QProcessTaskDeleter

Un destructeur personnalisé pour ` QProcess`, utilisé par ` QProcessTask`. En savoir plus...

classe QSequentialTaskTreeRunner

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

classe QSingleTaskTreeRunner

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

classe QStartedBarrier

Une « QBarrier » démarrée avec une limite donnée. En savoir 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 lors de l'adaptation de l'interface d'une tâche personnalisée. En savoir plus...

classe QTaskTree

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

classe QTcpSocketWrapper

Un wrapper autour de ` QTcpSocket`. En savoir plus...

classe QThreadFunction

Modèle de classe contrôlant l'exécution d'une fonction dans un thread distinct via QtConcurrent::run(). En savoir plus...

classe QThreadFunctionBase

Une classe de base pour le modèle de classe ` QThreadFunction `. En savoir plus...

classe RepeatIterator

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

classe Storage

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

classe Then

Élément « then » utilisé dans les expressions conditionnelles. En savoir plus...

classe UntilIterator

L'itérateur conditionnel à utiliser à l'intérieur de l'élément « For ». En savoir plus...

classe When

Élément retardant l'exécution d'un corps jusqu'à l'avancement d'une barrière. En savoir plus...

Documentation sur les types

[alias] BarrierKickerGetter

Alias de type pour la fonction prenant un ` QStoredBarrier ` et renvoyant un ` 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 du constructeur de l'élément onGroupDone() ou d'une tâche personnalisée. Elle indique à l'arborescence des tâches à quel moment le gestionnaire « done » du groupe ou de la tâche doit être appelé.

ConstanteValeurDescription
QtTaskTree::CallDoneFlag::Never0Le gestionnaire de fin n'est jamais appelé.
QtTaskTree::CallDoneFlag::OnSuccess1 << 0Le gestionnaire de fin est appelé uniquement après une exécution réussie, c'est-à-dire lorsque DoneWith::Success.
QtTaskTree::CallDoneFlag::OnError1 << 1Le gestionnaire « done » n’est appelé qu’après un échec d’exécution, c’est-à-dire lorsque DoneWith::Error.
QtTaskTree::CallDoneFlag::OnCancel1 << 2Le gestionnaire « done » n'est appelé qu'après une exécution annulée, c'est-à-dire lorsque DoneWith::Cancel.
QtTaskTree::CallDoneFlag::AlwaysOnSuccess | OnError | OnCancelLe gestionnaire « done » est toujours appelé.

Le type `CallDone` est un `typedef` de ` QFlags<CallDoneFlag>`. Il stocke une combinaison « ou » (OR) de valeurs `CallDoneFlag`.

enum class QtTaskTree::DoneResult

Cette énumération est renvoyée de manière facultative par la fonction de gestionnaire « done » 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'arborescence des tâches en cours d'exécution et signalée à son groupe parent.

Lorsque la fonction de gestion « done » renvoie un `DoneResult`, vous pouvez modifier la valeur de retour finale au sein de cette fonction.

Lorsque `DoneResult` est renvoyé par la fonction de gestion « done » du groupe, la politique de workflow 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 a généré une erreur.

ConstanteValeurDescription
QtTaskTree::DoneResult::Success0L'exécution du groupe ou de la tâche s'achève avec 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 de fin d'exécution du groupe ou de la tâche. Elle indique si le groupe ou la tâche s'est terminée avec succès, a généré une erreur ou a été annulée.

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

ConstanteValeurDescription
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 la méthode ` QTaskTree::cancel()` pour l'arborescence des tâches en cours d'exécution ou lorsque la politique de workflow du groupe entraîne l'annulation de certaines de ses tâches enfants en cours d'exécution. Modifier le résultat final du gestionnaire `done` en renvoyant ` DoneResult ` depuis ce gestionnaire n'a aucun effet lorsque l'exécution du groupe ou de la tâche a été annulée.

[alias] QtTaskTree::GroupItems

Alias de type pour QList<GroupItem>.

[alias] QBarrierTask

Alias de type pour l'QCustomTask<QBarrier>, à utiliser dans les recettes.

[alias] QNetworkReplyWrapperTask

Alias de type pour l'QCustomTask<QNetworkReplyWrapper>, à utiliser dans les recettes.

[alias] QProcessTask

Alias de type pour l'QCustomTask<QProcess>, utilisant QProcessTaskDeleter, à utiliser dans les recettes.

[alias] QStoredBarrier

Alias de type pour l'QtTaskTree::Storage<QStartedBarrier>, à utiliser dans les recettes.

[alias] QTaskTreeTask

Alias de type pour l'QCustomTask<QTaskTree>, à utiliser dans les recettes.

[alias] QTcpSocketWrapperTask

Alias de type pour l'QCustomTask<QTcpSocketWrapper>, à utiliser dans les recettes.

[alias] template <typename ResultType> QThreadFunctionTask

Alias de type pour QCustomTask<QThreadFunction<ResultType>>, où ResultType spécifie le type de retour de la fonction de thread, à utiliser dans les recettes.

[alias] QTimeoutTask

Alias de type pour l’ QCustomTask<std::chrono::milliseconds>, à utiliser dans les recettes. L’ std::chrono::milliseconds permet de définir la durée du délai d’expiration. Le délai d’expiration par défaut est std::chrono::milliseconds::zero(), c’est-à-dire que la QTimeoutTask se termine dès que le contrôle revient à la boucle d’événements en cours d’exécution.

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 renvoyée de manière facultative par la fonction de gestion de la configuration du groupe ou de la tâche. Elle indique à l'arborescence des tâches en cours d'exécution comment procéder une fois l'exécution de la fonction de gestion de la configuration terminée.

ConstanteValeurDescription
QtTaskTree::SetupResult::Continue0Valeur par défaut. L'exécution du groupe ou de la tâche se poursuit normalement. Lorsqu’une fonction de gestion de configuration de groupe ou de tâche renvoie `void`, on considère qu’elle a renvoyé `Continue`.
QtTaskTree::SetupResult::StopWithSuccess1L'exécution du groupe ou de la tâche s'arrête immédiatement avec succès. Lorsqu'elle est renvoyée par la fonction de gestion de configuration du groupe, toutes les tâches enfants sont ignorées, et la fonction de gestion onGroupDone() du groupe est appelée avec l'argument DoneWith::Success. Le groupe signale la réussite à son parent. La politique de workflow du groupe est ignorée. Lorsque la valeur est renvoyée depuis le gestionnaire de configuration de la tâche, la tâche n’est pas lancée, son gestionnaire `done` n’est pas appelé et la tâche signale la réussite à son parent.
QtTaskTree::SetupResult::StopWithError2L'exécution du groupe ou de la tâche s'arrête immédiatement avec une erreur. Lorsque le retour s'effectue depuis le gestionnaire de configuration du groupe, toutes les tâches enfants sont ignorées et le gestionnaire onGroupDone() du groupe est appelé avec DoneWith::Error. Le groupe signale une erreur à son parent. La politique de workflow du groupe est ignorée. Lorsque le gestionnaire de configuration de la tâche renvoie une valeur, la tâche n’est pas lancée, son gestionnaire d’erreurs n’est pas appelé et la tâche signale une erreur à son parent.

[alias] QtTaskTree::TreeDoneHandler

Alias de type pour std::function<void(const QTaskTree &, QtTaskTree::DoneWith)>.

TreeDoneHandler est un argument facultatif des fonctions des exécuteurs d’arbres de tâches chargées de planifier l’exécution de l’arbre de tâches. La fonction est appelée lorsque la recette de l’exécuteur d’arbres de tâches a terminé son exécution. L’accès à QTaskTree et au résultat de la recette s’effectue via les arguments passés.

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

[alias] QtTaskTree::TreeSetupHandler

Alias de type pour std::function<void(QTaskTree &)>.

TreeSetupHandler est un argument facultatif des fonctions des exécuteurs d’arbres de tâches chargées de planifier l’exécution de l’arbre de tâches. La fonction est appelée lorsque l’exécuteur d’arbres de tâches s’apprête à exécuter sa recette. L’accès à QTaskTree se fait via l’argument passé.

Les exécuteurs d'arbres de tâches acceptent également des gestionnaires sous une forme abrégée de ` std::function<void(void)>`.

enum class QtTaskTree::WorkflowPolicy

Cette énumération décrit les comportements possibles de l'élément « Group » lorsqu'une tâche enfant d'un groupe quelconque termine son exécution. Elle est également utilisée lorsque le « Group » en cours d'exécution est annulé.

ConstanteValeurDescription
QtTaskTree::WorkflowPolicy::StopOnError0Par 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 enfants 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. Similaire à stopOnError, mais si une tâche enfant se termine par une erreur, l’exécution se poursuit jusqu’à ce que toutes les tâches soient terminées, et le groupe signale ensuite une erreur, 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. Similaire à stopOnSuccess, mais si une tâche enfant aboutit, l’exécution se poursuit jusqu’à ce que toutes les tâches soient terminées, et le groupe signale ensuite un succès, 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 lance autant de tâches que possible. Dès qu’une tâche s’achève, le groupe s’arrête et signale le résultat de cette 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 s’arrête également ; les autres tâches sont donc 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 de retour. Lorsque toutes les tâches sont terminées, le groupe se termine avec 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 de retour. 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.

Dès que le résultat d’une tâche enfant provoque 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 (le cas échéant, par exemple en mode parallèle) et ignore l’exécution des 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 ayant échoué). L’annulation et le saut des tâches filles peuvent tous deux se produire lorsque l’on utilise « ParallelLimit ».

Le tableau ci-dessous résume les différences entre les différentes politiques de workflow :

WorkflowPolicyExécute toutes les tâches enfantsRésultatRésultat lorsque le groupe est vide
StopOnErrorS'arrête lorsqu'une tâche enfant se termine par une erreur et signale une erreurUne erreur si au moins une tâche enfant a échoué, sinon succèsSuccès
ContinueOnErrorOuiUne erreur si au moins une tâche enfant a échoué, réussite dans le cas contraireSuccès
Arrêt en cas de réussiteS'arrête dès qu'une tâche enfant s'est terminée avec succès et signale la réussiteSuccès si au moins une tâche fille a abouti, erreur dans le cas contraireUne erreur
ContinueOnSuccessOuiSuccès si au moins une tâche enfant a abouti, erreur dans le cas contraireUne erreur
StopOnSuccessOrErrorS'arrête dès qu'une tâche enfant est terminée et signale le résultat de cette tâche enfantSuccès ou erreur, selon le résultat de la tâche enfant terminéeUne erreur
FinishAllAndSuccessOuiSuccèsSuccès
ToutTerminerEtErreurOuiUne erreurUne erreur

Si un enfant d’un groupe est lui-même un groupe, ce groupe enfant exécute ses tâches conformément à sa propre stratégie de workflow. Lorsqu’un groupe parent arrête le groupe enfant en cours d’exécution en raison de sa propre politique de workflow, c’est-à-dire lorsque la politique StopOnError, StopOnSuccess ou StopOnSuccessOrError a été appliquée au groupe parent, le résultat du groupe enfant est indiqué conformément à la colonne Résultat et à la ligne correspondant à la politique de workflow du groupe enfant dans le tableau ci-dessus.

Documentation sur les variables

const QtTaskTree::GroupItem QtTaskTree::continueOnError

Élément pratique d’un groupe global décrivant la politique relative au flux de travail « ContinueOnError ».

const QtTaskTree::GroupItem QtTaskTree::continueOnSuccess

Élément pratique d'un groupe global décrivant la politique relative au flux de travail « ContinueOnSuccess ».

const QtTaskTree::ExecutableItem QtTaskTree::errorItem

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

Cela s'avère utile dans les instructions « 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 l’ conditionalTask se termine par une erreur, la branche Else est choisie, qui se termine immédiatement par une erreur. Cela entraîne l’ignorance de l’ nextTask (en raison de la politique de workflow « stopOnError » de l’ group) et l’ group se termine par une erreur.

Voir également successItem.

const QtTaskTree::GroupItem QtTaskTree::finishAllAndError

Élément pratique d'un groupe global décrivant la politique relative au flux de travail « FinishAllAndError ».

const QtTaskTree::GroupItem QtTaskTree::finishAllAndSuccess

Élément pratique d'un groupe global décrivant la politique relative au flux de travail « FinishAllAndSuccess ».

const QtTaskTree::GroupItem QtTaskTree::nullItem

Élément pratique d'un groupe global indiquant un élément sans effet.

Cela s'avère utile dans les expressions conditionnelles pour indiquer l'absence d'un élément facultatif :

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

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

const QtTaskTree::ExecutionMode QtTaskTree::parallel

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

Toutes les tâches filles directes d’un groupe sont lancées après le démarrage du groupe, sans attendre que les tâches filles précédentes soient terminées. Dans ce mode, toutes les tâches filles s’exécutent simultanément.

Voir également sequential et ParallelLimit.

const QtTaskTree::ExecutionMode QtTaskTree::parallelIdealThreadCountLimit

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

Cela équivaut à :

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

Voir également parallel et ParallelLimit.

const QtTaskTree::ExecutionMode QtTaskTree::sequential

Élément pratique du groupe global 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 défini, il s'exécute en mode séquentiel. Toutes les tâches enfants 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 comme entrée à la tâche suivante avant que celle-ci ne démarre. Ce mode garantit que la tâche suivante n’est lancée qu’une fois la tâche précédente terminée.

Voir également parallel et ParallelLimit.

const QtTaskTree::GroupItem QtTaskTree::stopOnError

Élément pratique du groupe global décrivant la politique de workflow « StopOnError ».

Il s'agit de la politique de workflow par défaut de l'élément « Groupe ».

const QtTaskTree::GroupItem QtTaskTree::stopOnSuccess

Élément pratique d'un groupe global décrivant la politique relative au flux de travail « StopOnSuccess ».

const QtTaskTree::GroupItem QtTaskTree::stopOnSuccessOrError

Élément pratique d'un groupe global décrivant la politique relative au flux de travail « StopOnSuccessOrError ».

const QtTaskTree::ExecutableItem QtTaskTree::successItem

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

Cela s'avère utile dans les instructions « 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 l’ conditionalTask se termine par une erreur, la branche Else est choisie, qui se termine immédiatement avec succès. Cela entraîne l’omission de l’ nextTask (en raison de la politique de workflow « stopOnSuccess » de group) et l’ group se termine avec succès.

Voir également errorItem.

Documentation de la fonction

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

Renvoie la tâche d'attente qui s'achève lorsque l'storedBarrier qui lui est transmise est terminée.

Remarque : l’ storedBarrier transmis doit être placé dans la même recette que la tâche renvoyée, en tant qu’élément frère, ou dans n’importe quelle recette ancêtre Group; dans le cas contraire, un plantage est à prévoir.

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

Une fonction pratique permettant de créer un objet ` ObjectSignal ` au sein de la fonction ` ObjectSignalGetter ` transmise aux fonctions ` ExecutableItem::withCancel()` ou ` ExecutableItem::withAccept()`. Passez un ` object ` et son ` signal ` pour créer une instance de la structure ` ObjectSignal `.

Voir également ObjectSignal, ExecutableItem::withCancel() et ExecutableItem::withAccept().

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

Crée un élément de groupe contenant le gestionnaire « done » du groupe. Par défaut, la méthode ` handler ` est appelée dès que le groupe a terminé. Passez une valeur non 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 workflow 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’objet ` handler ` passé est de type ` std::function<DoneResult(DoneWith)> `. En option, le type de retour ` DoneResult ` ou le type de l’argument ` DoneWith ` peut être omis (c’est-à-dire que son type de retour peut être ` void`). Pour plus d’informations sur les types de gestionnaires possibles, consultez GroupItem::GroupDoneHandler.

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

Si un groupe contient des éléments de type « Storage », la fonction « handler » est appelée avant la destruction des stockages, afin que la fonction « handler » puisse encore effectuer une dernière lecture des données des stockages actifs.

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

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

Crée un élément de groupe contenant le gestionnaire de configuration du groupe. La méthode ` handler ` est appelée à chaque démarrage du groupe.

L'handler transmis est de type « std::function<SetupResult()> » ou « std::function<void()> ». Pour plus d'informations sur les types de gestionnaires possibles, consultez GroupItem::GroupSetupHandler.

Lorsque la méthode ` handler ` est appelée, aucune des tâches enfants du groupe n’est encore en cours d’exécution.

Si un groupe contient des éléments de type « Storage », la méthode ` handler ` est appelée après la création des stockages, de sorte que la méthode ` handler ` puisse déjà effectuer certaines modifications initiales sur les stockages 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 « awaiter » qui s'achève lorsque l'sender qui lui est transmis émet l'signal.

Remarque : la connexion aux sender et signal passés n’est pas établie lors de la création de la tâche renvoyée ou de son insertion dans une recette, mais lorsque la tâche est lancée par la méthode QTaskTree. Assurez-vous que l’ sender passé survit à toute arborescence de tâches en cours d’exécution contenant la tâche renvoyée. Si l’ signal a été émise avant le démarrage de la tâche, c’est-à-dire avant l’établissement de la connexion, la tâche s’achèvera lors de la première émission de l’ 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 une tâche QTimeoutTask d'une durée de timeout, à l'issue de laquelle la tâche se termine avec le message result.

Voir également QTimeoutTask.

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

Crée l'élément « workflow policy » d'un groupe pour une « policy » donnée.

Pour plus de commodité, il est possible d’utiliser des éléments globaux à la place.

Voir également 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.