En esta página

QtTaskTree::ExecutableItem Class

class QtTaskTree::ExecutableItem

Clase base para elementos de tareas ejecutables. Más...

Encabezado: #include <qtasktree.h>
CMake: find_package(Qt6 REQUIRED COMPONENTS TaskTree)
target_link_libraries(mytarget PRIVATE Qt6::TaskTree)
qmake: QT += tasktree
Desde: Qt 6.11
Heredado de: QtTaskTree::GroupItem
Heredado por:

QtTaskTree::Forever, QtTaskTree::Group, QtTaskTree::QCustomTask y QtTaskTree::QSyncTask

Estado: Versión preliminar

Esta clase se encuentra en fase de vista previa tecnológica y está sujeta a cambios.

Nota: Todas las funciones de esta clase son reentrantes.

Funciones públicas

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)

Descripción detallada

ExecutableItem proporciona una interfaz adicional para elementos que contienen tareas ejecutables. Utiliza withTimeout() para establecer un tiempo de espera para una tarea. Utiliza withLog() para incluir información de depuración sobre el inicio de la tarea y el resultado de la ejecución.

Documentación de las funciones de miembro

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

Devuelve una copia de this ExecutableItem junto con un receptor de señal. La función getter que se pasa es una función que devuelve un ObjectSignal que describe el emisor y la señal que está esperando. Utiliza makeObjectSignal() dentro de getter para crear un objeto ObjectSignal.

Cuando this ExecutableItem finaliza con un error, el Group devuelto finaliza inmediatamente con un error, sin esperar a la señal del «awaiter».

Cuando this ExecutableItem finaliza con éxito, el Group devuelto no finaliza inmediatamente, sino que espera a que se envíe la señal de espera. Una vez enviada la señal de espera, el Group devuelto finaliza con éxito. Si la señal de espera se envía antes de que this ExecutableItem finalice, se omite la fase de espera y el Group devuelto finaliza de forma sincrónica.

La conexión con la señal del «awaiter» se establece cuando this ExecutableItem está a punto de iniciarse. Si la señal de espera se activó anteriormente, esto no se detectará una vez que se haya iniciado this ExecutableItem .

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

Hace que una copia de this ExecutableItem sea cancelable. La función getter que se pasa es una función que devuelve un ObjectSignal que describe el emisor y su señal de cancelación. Utiliza makeObjectSignal() dentro de getter para crear un objeto ObjectSignal. Cuando se emite la señal de cancelación, this ExecutableItem se cancela, se ejecuta un postCancelRecipe proporcionado opcionalmente y el Group devuelto finaliza con un error.

Cuando this ExecutableItem finaliza antes de que se emita la señal de cancelación, el Group devuelto finaliza inmediatamente con el mismo resultado con el que this ExecutableItem había finalizado. En este caso, se omite el postCancelRecipe proporcionado opcionalmente.

La conexión con la señal de cancelación se establece cuando this ExecutableItem está a punto de iniciarse. Si la señal de cancelación se activó antes, esto no se detectará una vez que se haya iniciado this ExecutableItem .

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

Añade una salida de depuración personalizada a una copia de this ExecutableItem , generada al inicio de la tarea y una vez finalizada esta, y devuelve el elemento asociado.

La salida de depuración incluye una marca de tiempo del evento (inicio o finalización) y un ` logName ` para identificar la tarea específica en el registro de depuración.

La salida de fin contiene información adicional sobre si la ejecución fue síncrona o asíncrona, su resultado (el valor descrito por la enumeración « DoneWith ») y el tiempo total de ejecución en milisegundos.

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

Asigna QTimeoutTask a una copia de this ExecutableItem , que caduca timeout milisegundos después, con un tiempo de espera opcional handler, y devuelve el elemento acoplado.

Cuando el ` ExecutableItem ` finaliza antes de que transcurra ` timeout `, el elemento devuelto finaliza inmediatamente con el resultado de la tarea. De lo contrario, se invoca ` handler ` (si se ha proporcionado), se cancela la tarea y el elemento devuelto finaliza con un error.

Elementos no miembros relacionados

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

Devuelve un grupo en el que se ha negado el DoneResult de item.

Si « item » indica « DoneResult::Success », el elemento devuelto indica « DoneResult::Error ». Si « item » indica « DoneResult::Error », el elemento devuelto indica « DoneResult::Success ».

El elemento devuelto es equivalente a:

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

Véase también operator&&() y operator||().

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

Devuelve un grupo con las tareas « first » y « second » fusionadas mediante la conjunción.

Tanto la tarea first como la second se ejecutan en secuencia. Si ambas tareas informan de DoneResult::Success, el elemento devuelto informa de DoneResult::Success. De lo contrario, el elemento devuelto informa de DoneResult::Error.

El elemento devuelto realiza un cortocircuito: si la tarea « first » devuelve « DoneResult::Error », se omite la tarea « second » y el elemento devuelto devuelve inmediatamente « DoneResult::Error ».

El elemento devuelto es equivalente a:

Group { stopOnError, first, second }

Nota: La ejecuciónparalela de una conjunción con cortocircuito se puede lograr con el siguiente código: ` Group { parallel, stopOnError, first, second }`. En este caso: si la primera tarea en finalizar devuelve ` DoneResult::Error`, la otra tarea se cancela y el grupo devuelve ` DoneResult::Error ` inmediatamente.

Véanse también operator||() y operator!().

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

Devuelve la tarea « item » si el « result » es « DoneResult::Success »; en caso contrario, devuelve la tarea « item » con su resultado «done» modificado a « DoneResult::Error ».

task && DoneResult::Error equivale a ajustar el resultado «done» de la tarea a DoneResult::Error de forma incondicional.

Esta función sobrescribe ExecutableItem::operator&&().

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

Devuelve un grupo en el que se han fusionado las tareas « first » y « second » mediante disyunción.

Tanto la tarea « first » como la tarea « second » se ejecutan en secuencia. Si ambas tareas informan de « DoneResult::Error », el elemento devuelto informa de « DoneResult::Error ». De lo contrario, el elemento devuelto informa de « DoneResult::Success ».

El elemento devuelto realiza un cortocircuito: si la tarea « first » devuelve « DoneResult::Success », se omite la tarea « second » y el elemento devuelto devuelve inmediatamente « DoneResult::Success ».

El elemento devuelto es equivalente a:

Group { stopOnSuccess, first, second }

Nota: La ejecuciónparalela de una disyunción en modo de cortocircuito se puede lograr con el siguiente código: Group { parallel, stopOnSuccess, first, second }. En este caso, si la primera tarea que finaliza informa de DoneResult::Success, la otra tarea se cancela y el grupo informa inmediatamente de DoneResult::Success.

Véase también operator&&() y operator!().

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

Devuelve la tarea « item » si el « result » es « DoneResult::Error »; en caso contrario, devuelve la tarea « item » con su resultado «done» modificado a « DoneResult::Success ».

task || DoneResult::Success equivale a ajustar el resultado «done» de la tarea a DoneResult::Success de forma incondicional.

Esta función sobrescribe 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.