En esta página

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)

Descripción detallada

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.

ConstanteValorDescripción
QtTaskTree::CallDoneFlag::Never0El controlador de finalización nunca se invoca.
QtTaskTree::CallDoneFlag::OnSuccess1 << 0El controlador de finalización se invoca únicamente tras una ejecución correcta, es decir, cuando DoneWith::Success.
QtTaskTree::CallDoneFlag::OnError1 << 1El controlador «done» solo se invoca tras una ejecución fallida, es decir, cuando DoneWith::Error.
QtTaskTree::CallDoneFlag::OnCancel1 << 2El controlador «done» solo se invoca tras una ejecución cancelada, es decir, cuando DoneWith::Cancel.
QtTaskTree::CallDoneFlag::AlwaysOnSuccess | OnError | OnCancelEl 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.

ConstanteValorDescripción
QtTaskTree::DoneResult::Success0La ejecución del grupo o de la tarea finaliza con éxito.
QtTaskTree::DoneResult::Error1La 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 ».

ConstanteValorDescripción
QtTaskTree::DoneWith::Success0La ejecución del grupo o de la tarea finalizó con éxito.
QtTaskTree::DoneWith::Error1La ejecución del grupo o de la tarea finalizó con un error.
QtTaskTree::DoneWith::Cancel2La 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.

ConstanteValorDescripción
QtTaskTree::SetupResult::Continue0Por 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::StopWithSuccess1La 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::StopWithError2La 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.

ConstanteValorDescripción
QtTaskTree::WorkflowPolicy::StopOnError0Por 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::ContinueOnError1Corresponde 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::StopOnSuccess2Corresponde 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::ContinueOnSuccess3Corresponde 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::StopOnSuccessOrError4Corresponde 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::FinishAllAndSuccess5Corresponde 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::FinishAllAndError6Se 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:

WorkflowPolicyEjecuta todas las tareas secundariasResultadoResultado cuando el grupo está vacío
StopOnErrorSe detiene cuando alguna tarea secundaria finaliza con un error y notifica dicho errorUn error si al menos una tarea secundaria ha fallado; en caso contrario, se considera un éxitoÉxito
Continuar en caso de errorSíError si al menos una tarea secundaria falla; en caso contrario, éxitoÉxito
Detener si se completa con éxitoSe 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 errorUn error
Continuar si hay éxitoSíÉxito si al menos una tarea secundaria se ha completado con éxito; en caso contrario, errorUn error
StopOnSuccessOrErrorSe 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 finalizadaUn error
FinishAllAndSuccessSíÉxitoÉxito
FinalizarTodoYErrorSíUn errorUn 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:

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

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.