QtTaskTree Namespace
El espacio de nombres QtTaskTree agrupa todas las clases y funciones globales del módulo TaskTree. Más información...
| Encabezado: | #include <QtTaskTree> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS TaskTree) target_link_libraries(mytarget PRIVATE Qt6::TaskTree) |
| qmake: | QT += tasktree |
| Desde: | Qt 6.11 |
| Estado: | Versión preliminar |
Este espacio de nombres se encuentra en fase de vista previa tecnológica y está sujeto a cambios.
Clases
(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 |
Tipos
| 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 |
Funciones
| 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) |
Clases
clase Do
Elemento del cuerpo que se utiliza con las construcciones «For» y «When». Más...
clase Else
Un elemento «else» que se utiliza en expresiones condicionales. Más...
clase ElseIf
Elemento «else if» utilizado en expresiones condicionales. Más...
clase ExecutableItem
Clase base para elementos de tarea ejecutables. Más...
clase ExecutionMode
Elemento de grupo que describe el modo de ejecución. Más...
clase For
Un elemento de bucle «for». Más...
clase Forever
Bucle infinito de subtareas. Más...
clase ForeverIterator
Iterador infinito para usar dentro del elemento «For». Más...
clase Group
Group representa el elemento básico para componer recetas declarativas que describen cómo ejecutar y gestionar un árbol anidado de tareas asíncronas. Más...
clase GroupItem
GroupItem representa el elemento básico que puede formar parte de cualquier « Group ». Más...
clase If
Un elemento «if» utilizado en expresiones condicionales. Más...
clase Iterator
Clase base que se utiliza como iterador dentro del elemento «For». Más...
clase ListIterator
El iterador de lista que se utilizará dentro del elemento «For». Más...
clase ObjectSignal
Estructura que describe una subclase de « QObject » y su señal. Más...
clase ParallelLimit
El modo de ejecución paralela con un límite personalizado. Más...
clase QBarrier
Una tarea asíncrona que finaliza bajo demanda. Más...
clase QCustomTask
Una plantilla de clase que se utiliza para declarar elementos de tarea personalizados y definir sus controladores de inicio y finalización. Más...
clase QDefaultTaskAdapter
Plantilla de clase que proporciona el adaptador de tareas predeterminado utilizado en QCustomTask. Más...
clase QMappedTaskTreeRunner
Un controlador de ejecución de árboles de tareas mapeados con un tipo de clave determinado. Más...
clase QNetworkReplyWrapper
Un envoltorio para QNetworkReply y QNetworkAccessManager. Más...
clase QParallelTaskTreeRunner
Un controlador de ejecución de árboles de tareas paralelas. Más...
clase QProcessTaskDeleter
Un eliminador personalizado para ` QProcess`, utilizado por ` QProcessTask`. Más...
clase QSequentialTaskTreeRunner
Un controlador de ejecución secuencial de árboles de tareas. Más...
clase QSingleTaskTreeRunner
Un controlador de ejecución de un único árbol de tareas. Más...
clase QStartedBarrier
Un « QBarrier » iniciado con un límite determinado. Más...
clase QSyncTask
Ejecuta de forma sincrónica un controlador personalizado entre otras tareas. Más...
clase QTaskInterface
QTaskInterface es una clase auxiliar que se utiliza al adaptar la interfaz de una tarea personalizada. Más...
clase QTaskTree
La clase QTaskTree ejecuta el árbol de tareas asíncronas definidas de forma declarativa. Más...
clase QTcpSocketWrapper
Un envoltorio para ` QTcpSocket`. Más...
clase QThreadFunction
Plantilla de clase que controla la ejecución de una función en un hilo independiente mediante QtConcurrent::run(). Más...
clase QThreadFunctionBase
Clase base para la plantilla de clas QThreadFunction. Más...
clase RepeatIterator
El iterador repetitivo que se utiliza dentro del elemento «For». Más...
clase Storage
Una plantilla de clase para el intercambio personalizado de datos en el árbol de tareas en ejecución. Más...
clase Then
Un elemento «then» utilizado en expresiones condicionales. Más...
clase UntilIterator
El iterador condicional que se utiliza dentro del elemento «For». Más información...
clase When
Un elemento que retrasa la ejecución de un cuerpo hasta que se supere una barrera. Más...
Documentación de tipos
[alias] BarrierKickerGetter
Alias de tipo para la función que toma un ` QStoredBarrier ` y devuelve un ` ExecutableItem`, es decir, ` std::function<ExecutableItem(const QStoredBarrier &)>`, para su uso dentro del constructor ` When `.
enum class QtTaskTree::CallDoneFlag
flags QtTaskTree::CallDone
Esta enumeración es un argumento opcional para el constructor del elemento ` onGroupDone()` o de una tarea personalizada. Indica al árbol de tareas cuándo debe invocarse el controlador de finalización del grupo o de la tarea.
| Constante | Valor | Descripción |
|---|---|---|
QtTaskTree::CallDoneFlag::Never | 0 | El controlador de finalización nunca se invoca. |
QtTaskTree::CallDoneFlag::OnSuccess | 1 << 0 | El controlador de finalización se invoca únicamente tras una ejecución correcta, es decir, cuando DoneWith::Success. |
QtTaskTree::CallDoneFlag::OnError | 1 << 1 | El controlador «done» solo se invoca tras una ejecución fallida, es decir, cuando DoneWith::Error. |
QtTaskTree::CallDoneFlag::OnCancel | 1 << 2 | El controlador «done» solo se invoca tras una ejecución cancelada, es decir, cuando DoneWith::Cancel. |
QtTaskTree::CallDoneFlag::Always | OnSuccess | OnError | OnCancel | El controlador «done» siempre se invoca. |
El tipo `CallDone` es un `typedef` para ` QFlags<CallDoneFlag>`. Almacena una combinación OR de valores de `CallDoneFlag`.
enum class QtTaskTree::DoneResult
Esta enumeración se devuelve de forma opcional desde la función de gestión de finalización del grupo o de la tarea. Cuando la función de gestión de finalización no devuelve ningún valor, es decir, cuando su tipo de retorno es ` void`, el árbol de tareas en ejecución deduce automáticamente su valor de retorno final y lo comunica a su grupo padre.
Cuando el controlador de finalización devuelve un `DoneResult`, se puede ajustar el valor de retorno final dentro del propio controlador.
Cuando el manipulador «done» del grupo devuelve un `DoneResult`, se ignora la política de flujo de trabajo del grupo.
Esta enumeración también se utiliza dentro de la señal TaskInterface::done() e indica si la tarea ha finalizado con éxito o con un error.
| Constante | Valor | Descripción |
|---|---|---|
QtTaskTree::DoneResult::Success | 0 | La ejecución del grupo o de la tarea finaliza con éxito. |
QtTaskTree::DoneResult::Error | 1 | La ejecución del grupo o de la tarea finaliza con un error. |
enum class QtTaskTree::DoneWith
Esta enumeración es un argumento opcional para el controlador de finalización del grupo o de la tarea. Indica si el grupo o la tarea han finalizado con éxito, con un error o si se han cancelado.
También se utiliza como argumento dentro de la señal « QTaskTree::done()», indicando el resultado final de la ejecución de « QTaskTree ».
| Constante | Valor | Descripción |
|---|---|---|
QtTaskTree::DoneWith::Success | 0 | La ejecución del grupo o de la tarea finalizó con éxito. |
QtTaskTree::DoneWith::Error | 1 | La ejecución del grupo o de la tarea finalizó con un error. |
QtTaskTree::DoneWith::Cancel | 2 | La ejecución del grupo o de la tarea se ha cancelado. Esto ocurre cuando el usuario llama a ` QTaskTree::cancel()` para el árbol de tareas en ejecución o cuando la política de flujo de trabajo del grupo da lugar a la cancelación de algunas de sus tareas secundarias en ejecución. Modificar el resultado final del controlador «done» devolviendo ` DoneResult ` desde el controlador no tiene ningún efecto cuando se ha cancelado la ejecución del grupo o de la tarea. |
[alias] QtTaskTree::GroupItems
Alias de tipo para QList<GroupItem>.
[alias] QBarrierTask
Alias de tipo para el QCustomTask<QBarrier>, para su uso en recetas.
[alias] QNetworkReplyWrapperTask
Alias de tipo para el tipo « QCustomTask » <QNetworkReplyWrapper>, para su uso dentro de recetas.
[alias] QProcessTask
Alias de tipo para el ` QCustomTask` <QProcess>, utilizando ` QProcessTaskDeleter`, para su uso dentro de recetas.
[alias] QStoredBarrier
Alias de tipo para el ` QtTaskTree::Storage` <QStartedBarrier>, para su uso dentro de recetas.
[alias] QTaskTreeTask
Alias de tipo para el tipo « QCustomTask » <QTaskTree>, para su uso en recetas.
[alias] QTcpSocketWrapperTask
Alias de tipo para el tipo « QCustomTask » <QTcpSocketWrapper>, para su uso en recetas.
[alias] template <typename ResultType> QThreadFunctionTask
Alias de tipo para « QCustomTask<QThreadFunction<ResultType>>», donde « ResultType » especifica el tipo de retorno de la función de hilo, para su uso en recetas.
[alias] QTimeoutTask
Alias de tipo para la clase ` QCustomTask` <std::chrono::milliseconds>, para su uso dentro de recetas. La propiedad ` std::chrono::milliseconds ` se utiliza para configurar la duración del tiempo de espera. El tiempo de espera por defecto es ` std::chrono::milliseconds::zero()`, es decir, la clase `QTimeoutTask` finaliza tan pronto como el control vuelve al bucle de eventos en ejecución.
Ejemplo de uso:
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)
};Véase también timeoutTask().
enum class QtTaskTree::SetupResult
Esta enumeración se devuelve de forma opcional desde la función de gestión de configuración del grupo o de la tarea. Indica al árbol de tareas en ejecución cómo debe proceder una vez finalizada la ejecución de la función de gestión de configuración.
| Constante | Valor | Descripción |
|---|---|---|
QtTaskTree::SetupResult::Continue | 0 | Por defecto. La ejecución del grupo o de la tarea continúa con normalidad. Cuando el controlador de configuración de un grupo o de una tarea devuelve void, se supone que ha devuelto Continue. |
QtTaskTree::SetupResult::StopWithSuccess | 1 | La ejecución del grupo o de la tarea se detiene inmediatamente con éxito. Cuando se devuelve desde el controlador de configuración del grupo, se omiten todas las tareas secundarias y se invoca el controlador « onGroupDone()» del grupo con « DoneWith::Success ». El grupo informa de que la operación se ha realizado con éxito a su padre. Se ignora la política de flujo de trabajo del grupo. Cuando se devuelve desde el controlador de configuración de la tarea, la tarea no se inicia, no se invoca su controlador «done» y la tarea informa de éxito a su padre. |
QtTaskTree::SetupResult::StopWithError | 2 | La ejecución del grupo o de la tarea se detiene inmediatamente con un error. Al salir del controlador de configuración del grupo, se omiten todas las tareas secundarias y se invoca el controlador onGroupDone() del grupo con DoneWith::Error. El grupo notifica un error a su padre. Se ignora la política de flujo de trabajo del grupo. Al salir del controlador de configuración de la tarea, esta no se inicia, no se invoca su controlador de error y la tarea notifica un error a su padre. |
[alias] QtTaskTree::TreeDoneHandler
Alias de tipo para std::function<void(const QTaskTree &, QtTaskTree::DoneWith)>.
El TreeDoneHandler es un argumento opcional de las funciones de los ejecutores de árboles de tareas que programan la ejecución del árbol de tareas. La función se invoca cuando la receta del ejecutor del árbol de tareas ha finalizado su ejecución. El acceso a QTaskTree y al resultado de la receta se realiza a través de los argumentos pasados.
Los ejecutores de árboles de tareas también aceptan manejadores en una forma abreviada de std::function<void(const QTaskTree &)>, std::function<void(QtTaskTree::DoneWith)> o std::function<void(void)>.
[alias] QtTaskTree::TreeSetupHandler
Alias de tipo para std::function<void(QTaskTree &)>.
El TreeSetupHandler es un argumento opcional de las funciones de los ejecutores de árboles de tareas que programan la ejecución del árbol de tareas. La función se invoca cuando el ejecutor del árbol de tareas está a punto de ejecutar su receta. El acceso a QTaskTree se realiza a través del argumento pasado.
Los ejecutores de árboles de tareas también aceptan controladores en una forma abreviada de ` std::function<void(void)>`.
enum class QtTaskTree::WorkflowPolicy
Esta enumeración describe los posibles comportamientos del elemento «Group» cuando una tarea secundaria de cualquier grupo finaliza su ejecución. También se utiliza cuando se cancela el «Group» en ejecución.
| Constante | Valor | Descripción |
|---|---|---|
QtTaskTree::WorkflowPolicy::StopOnError | 0 | Por defecto. Se corresponde con el elemento global « stopOnError ». Si alguna tarea secundaria finaliza con un error, el grupo se detiene y finaliza con un error. Si todas las tareas secundarias finalizan correctamente, el grupo finaliza correctamente. Si un grupo está vacío, finaliza correctamente. |
QtTaskTree::WorkflowPolicy::ContinueOnError | 1 | Corresponde al elemento global continueOnError. Similar a stopOnError, pero en caso de que cualquier tarea secundaria finalice con un error, la ejecución continúa hasta que finalicen todas las tareas, y el grupo informa de un error posteriormente, incluso cuando otras tareas del grupo hayan finalizado con éxito. Si todas las tareas secundarias finalizan con éxito, el grupo finaliza con éxito. Si un grupo está vacío, finaliza con éxito. |
QtTaskTree::WorkflowPolicy::StopOnSuccess | 2 | Corresponde al elemento global « stopOnSuccess ». Si alguna tarea secundaria finaliza con éxito, el grupo se detiene y finaliza con éxito. Si todas las tareas secundarias finalizan con un error, el grupo finaliza con un error. Si un grupo está vacío, finaliza con un error. |
QtTaskTree::WorkflowPolicy::ContinueOnSuccess | 3 | Corresponde al elemento global continueOnSuccess. Similar a stopOnSuccess, pero en caso de que cualquier tarea secundaria finalice con éxito, la ejecución continúa hasta que finalicen todas las tareas, y el grupo informa de éxito posteriormente, incluso cuando otras tareas del grupo hayan finalizado con un error. Si todas las tareas secundarias finalizan con un error, el grupo finaliza con un error. Si un grupo está vacío, finaliza con un error. |
QtTaskTree::WorkflowPolicy::StopOnSuccessOrError | 4 | Corresponde al elemento global « stopOnSuccessOrError ». El grupo inicia tantas tareas como pueda. Cuando cualquier tarea finaliza, el grupo se detiene e informa del resultado de la tarea. Útil únicamente en modo paralelo. En modo secuencial, solo se inicia la primera tarea y, cuando esta finaliza, el grupo también finaliza, por lo que las demás tareas siempre se omiten. Si un grupo está vacío, finaliza con un error. |
QtTaskTree::WorkflowPolicy::FinishAllAndSuccess | 5 | Corresponde al elemento global finishAllAndSuccess. El grupo ejecuta todas las tareas e ignora sus resultados de retorno. Cuando todas las tareas han finalizado, el grupo finaliza con éxito. Si un grupo está vacío, finaliza con éxito. |
QtTaskTree::WorkflowPolicy::FinishAllAndError | 6 | Se corresponde con el elemento global « finishAllAndError ». El grupo ejecuta todas las tareas e ignora sus resultados de retorno. Cuando todas las tareas han finalizado, el grupo finaliza con un error. Si un grupo está vacío, finaliza con un error. |
Siempre que el resultado de una tarea hija provoque que el grupo se detenga, es decir, en caso de las políticas «StopOnError», StopOnSuccess o StopOnSuccessOrError, el grupo cancela las demás tareas secundarias en ejecución (si las hay, por ejemplo, en modo paralelo) y omite la ejecución de las tareas que aún no ha iniciado (por ejemplo, en modo secuencial, aquellas que se encuentran después de la tarea fallida). Tanto la cancelación como el salto de tareas secundarias pueden producirse cuando se utiliza « ParallelLimit ».
La tabla siguiente resume las diferencias entre las distintas políticas de flujo de trabajo:
| WorkflowPolicy | Ejecuta todas las tareas secundarias | Resultado | Resultado cuando el grupo está vacío |
|---|---|---|---|
| StopOnError | Se detiene cuando alguna tarea secundaria finaliza con un error y notifica dicho error | Un error si al menos una tarea secundaria ha fallado; en caso contrario, se considera un éxito | Éxito |
| Continuar en caso de error | Sí | Error si al menos una tarea secundaria falla; en caso contrario, éxito | Éxito |
| Detener si se completa con éxito | Se detiene cuando cualquier tarea secundaria finaliza con éxito y se informa de ello | Éxito si al menos una tarea secundaria se ha completado con éxito; en caso contrario, se produce un error | Un error |
| Continuar si hay éxito | Sí | Éxito si al menos una tarea secundaria se ha completado con éxito; en caso contrario, error | Un error |
| StopOnSuccessOrError | Se detiene cuando cualquier tarea secundaria haya finalizado e informa del resultado de la tarea secundaria | Éxito o error, dependiendo del resultado de la tarea secundaria finalizada | Un error |
| FinishAllAndSuccess | Sí | Éxito | Éxito |
| FinalizarTodoYError | Sí | Un error | Un error |
Si un grupo secundario de un grupo es también un grupo, dicho grupo secundario ejecuta sus tareas de acuerdo con su propia política de flujo de trabajo. Cuando un grupo padre detiene el grupo hijo en ejecución debido a la política de flujo de trabajo del grupo padre —es decir, cuando se ha utilizado la política StopOnError, StopOnSuccess o StopOnSuccessOrError para el grupo padre—, el resultado del grupo hijo se indica según la columna «Resultado» y la fila correspondiente a la política de flujo de trabajo del grupo hijo en la tabla anterior.
Documentación de variables
const QtTaskTree::GroupItem QtTaskTree::continueOnError
Un elemento de grupo global práctico que describe la política de flujo de trabajo « ContinueOnError ».
const QtTaskTree::GroupItem QtTaskTree::continueOnSuccess
Un elemento de grupo global práctico que describe la política de flujo de trabajo « ContinueOnSuccess ».
const QtTaskTree::ExecutableItem QtTaskTree::errorItem
Un elemento ejecutable global muy práctico que contiene una tarea vacía, errónea y síncrona.
Esto resulta útil en las sentencias «if» para indicar que una rama termina con un error:
const ExecutableItem conditionalTask = ...;
Group group {
stopOnError,
If (conditionalTask) >> Then {
...
} >> Else {
errorItem
},
nextTask
};En el ejemplo anterior, si la tarea « conditionalTask » finaliza con un error, se elige la rama « Else », que finaliza inmediatamente con un error. Esto hace que se omita la tarea « nextTask » (debido a la política de flujo de trabajo « stopOnError » de group) y que la tarea « group » finalice con un error.
Véase también successItem.
const QtTaskTree::GroupItem QtTaskTree::finishAllAndError
Un elemento de grupo global práctico que describe la política de flujo de trabajo « FinishAllAndError ».
const QtTaskTree::GroupItem QtTaskTree::finishAllAndSuccess
Un elemento de grupo global práctico que describe la política de flujo de trabajo « FinishAllAndSuccess ».
const QtTaskTree::GroupItem QtTaskTree::nullItem
Un elemento práctico del grupo global que indica un elemento sin operación.
Resulta útil en expresiones condicionales para indicar la ausencia de un elemento opcional:
const ExecutableItem task = ...;
const std::optional<ExecutableItem> optionalTask = ...;
Group group {
task,
optionalTask ? *optionalTask : nullItem
};const QtTaskTree::ExecutionMode QtTaskTree::parallel
Un elemento práctico del grupo global que describe el modo de ejecución en paralelo.
Todas las tareas hijas directas de un grupo se inician una vez que se ha iniciado el grupo, sin esperar a que finalicen las tareas hijas anteriores. En este modo, todas las tareas hijas se ejecutan simultáneamente.
Véase también sequential y ParallelLimit.
const QtTaskTree::ExecutionMode QtTaskTree::parallelIdealThreadCountLimit
Un elemento práctico del grupo global que describe el modo de ejecución en paralelo con un número limitado de tareas ejecutándose simultáneamente. El límite es igual al número ideal de subprocesos, excluyendo el subproceso de llamada.
Esto equivale a:
Véase también parallel y ParallelLimit.
const QtTaskTree::ExecutionMode QtTaskTree::sequential
Un elemento de grupo global muy práctico que describe el modo de ejecución secuencial.
Este es el modo de ejecución predeterminado del elemento «Grupo».
Cuando un grupo no tiene modo de ejecución, se ejecuta en modo secuencial. Todas las tareas hijas directas de un grupo se inician en cadena, de modo que, cuando una tarea finaliza, se inicia la siguiente. Esto permite pasar los resultados de la tarea anterior como entrada a la siguiente tarea antes de que esta se inicie. Este modo garantiza que la siguiente tarea solo se inicie una vez que la anterior haya finalizado.
Véase también parallel y ParallelLimit.
const QtTaskTree::GroupItem QtTaskTree::stopOnError
Un elemento de grupo global muy práctico que describe la política de flujo de trabajo « StopOnError ».
Esta es la política de flujo de trabajo predeterminada del elemento «Grupo».
const QtTaskTree::GroupItem QtTaskTree::stopOnSuccess
Un elemento de grupo global práctico que describe la política de flujo de trabajo « StopOnSuccess ».
const QtTaskTree::GroupItem QtTaskTree::stopOnSuccessOrError
Un elemento de grupo global práctico que describe la política de flujo de trabajo « StopOnSuccessOrError ».
const QtTaskTree::ExecutableItem QtTaskTree::successItem
Un elemento ejecutable global muy práctico que contiene una tarea vacía, que se ejecuta con éxito y de forma sincrónica.
Esto resulta útil en sentencias «if» para indicar que una rama finaliza con éxito:
const ExecutableItem conditionalTask = ...;
const Group group {
stopOnSuccess,
If (conditionalTask) >> Then {
...
} >> Else {
successItem
},
nextTask
};En el ejemplo anterior, si la tarea « conditionalTask » finaliza con un error, se elige la rama « Else », que finaliza inmediatamente con éxito. Esto hace que se omita la tarea « nextTask » (debido a la política de flujo de trabajo « stopOnSuccess » del group) y que la tarea « group » finalice con éxito.
Véase también errorItem.
Documentación de la función
QtTaskTree::ExecutableItem QtTaskTree::barrierAwaiterTask(const QtTaskTree::QStoredBarrier &storedBarrier)
Devuelve la tarea de espera que finaliza cuando termina la tarea « storedBarrier » pasada como parámetro.
Nota: El ` storedBarrier ` pasado debe colocarse en la misma receta como elemento hermano de la tarea devuelta o en cualquier antepasado Group; de lo contrario, es posible que se produzca un fallo del sistema.
template <typename Signal> QtTaskTree::ObjectSignal<std::decay_t<Signal>> QtTaskTree::makeObjectSignal(typename QtPrivate::FunctionPointer<Signal>::Object *object, Signal &&signal)
Una función muy práctica para crear un ` ObjectSignal ` dentro de la función ` ObjectSignalGetter ` que se pasa a ` ExecutableItem::withCancel()` o ` ExecutableItem::withAccept()`. Se le pasan un ` object ` y su ` signal ` para crear una instancia de la estructura ` ObjectSignal `.
Véase también ObjectSignal, ExecutableItem::withCancel() y ExecutableItem::withAccept().
template <typename Handler> QtTaskTree::GroupItem QtTaskTree::onGroupDone(Handler &&handler, QtTaskTree::CallDone callDone = CallDoneFlag::Always)
Crea un elemento del grupo que contiene el controlador de finalización del grupo. Por defecto, se invoca el controlador « handler » cada vez que el grupo finaliza. Pase un valor distinto del predeterminado para el argumento « callDone » cuando desee que el controlador solo se llame en caso de ejecución correcta, fallida o cancelada. Dependiendo de la política de flujo de trabajo del grupo, este controlador también puede llamarse cuando se cancela el grupo en ejecución (por ejemplo, cuando se ha utilizado un elemento « stopOnError »).
El objeto ` handler ` pasado es de tipo ` std::function<DoneResult(DoneWith)> `. Opcionalmente, se puede omitir tanto el tipo de retorno ` DoneResult ` como el tipo del argumento ` DoneWith ` (es decir, su tipo de retorno puede ser ` void`). Para obtener más información sobre los posibles tipos de controlador, consulte GroupItem::GroupDoneHandler.
Cuando se invoca a ` handler `, todas las tareas secundarias del grupo ya han finalizado.
Si un grupo contiene elementos de almacenamiento (Storage), se invoca el método handler antes de que se destruyan los almacenes, de modo que el método handler pueda seguir realizando una última lectura de los datos de los almacenes activos.
Véase también « GroupItem::GroupDoneHandler » y « onGroupSetup()».
template <typename Handler> QtTaskTree::GroupItem QtTaskTree::onGroupSetup(Handler &&handler)
Crea un elemento del grupo que contiene el controlador de configuración del grupo. El ` handler ` se invoca cada vez que se inicia el grupo.
El « handler » pasado es de tipo « std::function<SetupResult()> » o « std::function<void()> ». Para obtener más información sobre los tipos de controladores posibles, consulte GroupItem::GroupSetupHandler.
Cuando se invoca el ` handler `, aún no se está ejecutando ninguna de las tareas secundarias del grupo.
Si un grupo contiene elementos de almacenamiento, el método handler se invoca una vez construidos los almacenes, de modo que el método handler ya pueda realizar algunas modificaciones iniciales en los almacenes activos.
Véase también « GroupItem::GroupSetupHandler » y « onGroupDone()».
template <typename Signal> QtTaskTree::ExecutableItem QtTaskTree::signalAwaiterTask(const typename QtPrivate::FunctionPointer<Signal>::Object *sender, Signal signal)
Devuelve la tarea de espera que finaliza cuando, al pasar sender, se emite el signal.
Nota: La conexión con los elementos « sender » y « signal » pasados no se establece cuando se crea la tarea devuelta o se incluye en una receta, sino cuando la tarea se inicia mediante « QTaskTree ». Asegúrate de que el elemento « sender » pasado permanezca activo más tiempo que cualquier árbol de tareas en ejecución que contenga la tarea devuelta. Si se emitió el signal antes de que se iniciara la tarea, es decir, antes de que se estableciera la conexión, la tarea finalizará con la primera emisión del signal tras el inicio de la tarea.
QtTaskTree::ExecutableItem QtTaskTree::timeoutTask(const std::chrono::milliseconds &timeout, QtTaskTree::DoneResult result = DoneResult::Error)
Crea « QTimeoutTask » con una duración de « timeout », tras lo cual la tarea finaliza con « result ».
Véase también « QTimeoutTask ».
QtTaskTree::GroupItem QtTaskTree::workflowPolicy(QtTaskTree::WorkflowPolicy policy)
Crea el elemento « workflow policy » de un grupo para un « policy » dado.
Por comodidad, se pueden utilizar elementos globales en su lugar.
Véase también stopOnError, continueOnError, stopOnSuccess, continueOnSuccess, stopOnSuccessOrError, finishAllAndSuccess, finishAllAndError y 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.