Sur cette page

QtTaskTree::ExecutableItem Class

class QtTaskTree::ExecutableItem

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

En-tête : #include <qtasktree.h>
CMake : find_package(Qt6 REQUIRED COMPONENTS TaskTree)
target_link_libraries(mytarget PRIVATE Qt6::TaskTree)
qmake : QT += tasktree
Depuis : Qt 6.11
Hérite de : QtTaskTree::GroupItem
Hérité par :

QtTaskTree::Forever, QtTaskTree::Group, QtTaskTree::QCustomTask, et QtTaskTree::QSyncTask

Statut : Aperçu technologique

Cette classe est en préversion technologique et est susceptible d'être modifiée.

Remarque : toutes les fonctions de cette classe sont réentrantes.

Fonctions publiques

QtTaskTree::Group withAccept(ObjectSignalGetter &&getter) const
QtTaskTree::Group withCancel(ObjectSignalGetter &&getter, std::initializer_list<QtTaskTree::GroupItem> postCancelRecipe = {}) const
QtTaskTree::Group withLog(const QString &logName) const
QtTaskTree::Group withTimeout(std::chrono::milliseconds timeout, const std::function<void ()> &handler = {}) const
QtTaskTree::Group operator!(const QtTaskTree::ExecutableItem &item)
QtTaskTree::Group operator&&(const QtTaskTree::ExecutableItem &first, const QtTaskTree::ExecutableItem &second)
QtTaskTree::Group operator&&(const QtTaskTree::ExecutableItem &item, QtTaskTree::DoneResult result)
QtTaskTree::Group operator||(const QtTaskTree::ExecutableItem &first, const QtTaskTree::ExecutableItem &second)
QtTaskTree::Group operator||(const QtTaskTree::ExecutableItem &item, QtTaskTree::DoneResult result)

Description détaillée

ExecutableItem fournit une interface supplémentaire pour les éléments contenant des tâches exécutables. Utilisez withTimeout() pour associer un délai d'expiration à une tâche. Utilisez withLog() pour inclure des informations de débogage concernant le démarrage de la tâche et le résultat de l'exécution.

Documentation des fonctions membres

template <typename ObjectSignalGetter> QtTaskTree::Group ExecutableItem::withAccept(ObjectSignalGetter &&getter) const

Renvoie une copie de this ExecutableItem associée à un observateur de signal. La fonction getter passée est une fonction renvoyant un ObjectSignal qui décrit l'émetteur et le signal qu'il attend. Utilisez makeObjectSignal() à l'intérieur de getter pour créer un objet ObjectSignal.

Lorsque this ExecutableItem se termine par une erreur, l'Group renvoyé se termine immédiatement par une erreur, sans attendre le signal de l'awaiter.

Lorsque this ExecutableItem se termine avec succès, l'Group renvoyé ne se termine pas immédiatement, mais attend que le signal d'attente soit envoyé. Une fois le signal d'attente envoyé, l'Group renvoyé se termine avec succès. Si le signal d'attente est envoyé avant que this ExecutableItem ne se termine, la phase d'attente est ignorée et l'Group renvoyé se termine de manière synchrone.

La connexion au signal de l'attendant est établie lorsque this ExecutableItem est sur le point de démarrer. Si le signal d'attente a été déclenché auparavant, cela ne sera pas pris en compte une fois que this ExecutableItem aura démarré.

template <typename ObjectSignalGetter> QtTaskTree::Group ExecutableItem::withCancel(ObjectSignalGetter &&getter, std::initializer_list<QtTaskTree::GroupItem> postCancelRecipe = {}) const

Rend annulable une copie de this ExecutableItem . La fonction getter passée est une fonction renvoyant un ObjectSignal qui décrit l’émetteur et son signal d’annulation. Utilisez makeObjectSignal() à l’intérieur de getter pour créer un objet ObjectSignal. Lorsque le signal d’annulation est émis, this ExecutableItem est annulé, un postCancelRecipe fourni de manière facultative est exécuté, et le Group renvoyé se termine par une erreur.

Lorsque this ExecutableItem s’achève avant l’émission du signal d’annulation, le Group renvoyé se termine immédiatement avec le même résultat que celui obtenu par this ExecutableItem . Dans ce cas, la fonction postCancelRecipe, fournie en option, est ignorée.

La connexion au signal d’annulation est établie lorsque this ExecutableItem est sur le point d’être lancé. Si le signal d’annulation a été déclenché auparavant, cela ne sera pas pris en compte une fois que this ExecutableItem aura été lancé.

QtTaskTree::Group ExecutableItem::withLog(const QString &logName) const

Ajoute un message de débogage personnalisé à une copie de this ExecutableItem , générée au démarrage de la tâche et à la fin de celle-ci, puis renvoie l'élément associé.

Le message de débogage comprend un horodatage de l’événement (début ou fin) ainsi que l’ logName permettant d’identifier la tâche spécifique dans le journal de débogage.

Le message de fin contient des informations supplémentaires indiquant si l’exécution était synchrone ou asynchrone, son résultat (la valeur décrite par l’énumération DoneWith ) et la durée totale d’exécution en millisecondes.

QtTaskTree::Group ExecutableItem::withTimeout(std::chrono::milliseconds timeout, const std::function<void ()> &handler = {}) const

Associe l'QTimeoutTask à une copie de l'this ExecutableItem , qui expire après timeout en millisecondes, avec un délai d'expiration fourni de manière facultative handler, et renvoie l'élément couplé.

Lorsque l’ ExecutableItem se termine avant l’expiration de timeout, l’élément renvoyé se termine immédiatement avec le résultat de la tâche. Sinon, handler est appelé (s’il est fourni), la tâche est annulée et l’élément renvoyé se termine avec une erreur.

Éléments non membres associés

QtTaskTree::Group operator!(const QtTaskTree::ExecutableItem &item)

Renvoie un groupe dont l'DoneResult, item, a été inversée.

Si item renvoie DoneResult::Success, l'élément renvoyé renvoie DoneResult::Error. Si item renvoie DoneResult::Error, l'élément renvoyé renvoie DoneResult::Success.

L'élément renvoyé est équivalent à :

Group {
    item,
    onGroupDone([](DoneWith doneWith) { return toDoneResult(doneWith == DoneWith::Error); })
}

Voir également operator&&() et operator||().

QtTaskTree::Group operator&&(const QtTaskTree::ExecutableItem &first, const QtTaskTree::ExecutableItem &second)

Renvoie un groupe contenant les tâches « first » et « second » fusionnées par conjonction.

Les tâches « first » et « second » s’exécutent l’une après l’autre. Si les deux tâches signalent « DoneResult::Success », l’élément renvoyé indique « DoneResult::Success ». Sinon, l’élément renvoyé indique « DoneResult::Error ».

L’élément renvoyé est de type « court-circuit »: si la tâche first renvoie DoneResult::Error, la tâche second est ignorée et l’élément renvoyé indique immédiatement DoneResult::Error.

L'élément renvoyé est équivalent à :

Group { stopOnError, first, second }

Remarque : l’exécutionparallèle d’une conjonction en court-circuit peut être réalisée à l’aide du code suivant : Group { parallel, stopOnError, first, second }. Dans ce cas : si la première tâche terminée signale DoneResult::Error, l’autre tâche est annulée et le groupe signale immédiatement DoneResult::Error.

Voir également operator||() et operator!().

QtTaskTree::Group operator&&(const QtTaskTree::ExecutableItem &item, QtTaskTree::DoneResult result)

Renvoie la tâche « item » si l'result est « DoneResult::Success » ; sinon, renvoie la tâche « item » dont le résultat « done » a été modifié pour devenir « DoneResult::Error ».

La fonction task && DoneResult::Error revient à modifier sans condition le résultat « done » de la tâche pour le remplacer par DoneResult::Error.

Cette fonction surcharge la méthode ExecutableItem::operator&&().

QtTaskTree::Group operator||(const QtTaskTree::ExecutableItem &first, const QtTaskTree::ExecutableItem &second)

Renvoie un groupe dans lequel les tâches first et second sont fusionnées par disjonction.

Les tâches « first » et « second » s’exécutent toutes deux en séquence. Si les deux tâches signalent « DoneResult::Error », l’élément renvoyé indique « DoneResult::Error ». Sinon, l’élément renvoyé indique « DoneResult::Success ».

L’élément renvoyé est de type « court-circuit »: si la tâche first renvoie DoneResult::Success, la tâche second est ignorée et l’élément renvoyé indique immédiatement DoneResult::Success.

L'élément renvoyé est équivalent à :

Group { stopOnSuccess, first, second }

Remarque : l’exécutionparallèle d’une disjonction en court-circuit peut être réalisée à l’aide du code suivant : Group { parallel, stopOnSuccess, first, second }. Dans ce cas, si la première tâche terminée signale DoneResult::Success, l’autre tâche est annulée et le groupe signale immédiatement DoneResult::Success.

Voir également operator&&() et operator!().

QtTaskTree::Group operator||(const QtTaskTree::ExecutableItem &item, QtTaskTree::DoneResult result)

Renvoie la tâche « item » si la tâche « result » est « DoneResult::Error » ; sinon, renvoie la tâche « item » dont le résultat final a été modifié pour devenir « DoneResult::Success ».

La fonction task || DoneResult::Success revient à modifier sans condition le résultat « done » de la tâche pour le remplacer par DoneResult::Success.

Cette fonction surcharge la méthode ExecutableItem::operator||().

© 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.