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) |
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é.
| Constante | Valeur | Description de la constante |
|---|---|---|
QtTaskTree::CallDoneFlag::Never | 0 | Le gestionnaire done n'est jamais invoqué. |
QtTaskTree::CallDoneFlag::OnSuccess | 1 << 0 | Le gestionnaire done n'est invoqué qu'après une exécution réussie, c'est-à-dire lorsque DoneWith::Success. |
QtTaskTree::CallDoneFlag::OnError | 1 << 1 | Le gestionnaire done n'est invoqué qu'après une exécution ratée, c'est-à-dire lorsque DoneWith::Error. |
QtTaskTree::CallDoneFlag::OnCancel | 1 << 2 | Le gestionnaire "done" n'est invoqué qu'après une exécution annulée, c'est-à-dire lorsque DoneWith::Cancel. |
QtTaskTree::CallDoneFlag::Always | OnSuccess | OnError | OnCancel | Le 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.
| Constante | Valeur | Description |
|---|---|---|
QtTaskTree::DoneResult::Success | 0 | L'exécution du groupe ou de la tâche se termine par un succès. |
QtTaskTree::DoneResult::Error | 1 | L'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.
| Constante | Valeur | Description du groupe ou de la tâche |
|---|---|---|
QtTaskTree::DoneWith::Success | 0 | L'exécution du groupe ou de la tâche s'est terminée avec succès. |
QtTaskTree::DoneWith::Error | 1 | L'exécution du groupe ou de la tâche s'est terminée par une erreur. |
QtTaskTree::DoneWith::Cancel | 2 | L'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.
| Constante | Valeur | Description de la constante |
|---|---|---|
QtTaskTree::SetupResult::Continue | 0 | Valeur 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::StopWithSuccess | 1 | L'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::StopWithError | 2 | L'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é.
| Constante | Valeur | Description |
|---|---|---|
QtTaskTree::WorkflowPolicy::StopOnError | 0 | Valeur 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::ContinueOnError | 1 | Correspond à 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::StopOnSuccess | 2 | Correspond à 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::ContinueOnSuccess | 3 | Correspond à 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::StopOnSuccessOrError | 4 | Correspond à 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::FinishAllAndSuccess | 5 | Correspond à 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::FinishAllAndError | 6 | Correspond à 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 :
| WorkflowPolicy | Exécute toutes les tâches enfant | Résultat | Résultat lorsque le groupe est vide |
|---|---|---|---|
| StopOnError | S'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 contraire | Réussite |
| ContinueOnError | Oui | Une erreur lorsqu'au moins une tâche enfant a échoué, succès sinon | Succès |
| StopOnSuccess | S'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 contraire | Une erreur |
| ContinueOnSuccess | Oui | Succès lorsqu'au moins une tâche enfant a réussi, erreur dans le cas contraire | Une erreur |
| StopOnSuccessOrError | S'arrête lorsque l'une des tâches enfant est terminée et signale le résultat de la tâche enfant | Succès ou erreur, en fonction du résultat de la tâche enfant terminée | Une erreur |
| FinishAllAndSuccess | Oui | Succès | Succès |
| FinirToutEtErreur | Oui | Une erreur | Une 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 :
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.