En esta página

QtTaskTree Namespace

El espacio de nombres QtTaskTree contiene todas las clases y funciones globales del módulo TaskTree. Más...

Cabecera: #include <QtTaskTree>
CMake: find_package(Qt6 REQUIRED COMPONENTS TaskTree)
target_link_libraries(mytarget PRIVATE Qt6::TaskTree)
qmake: QT += tasktree
Desde: Qt 6.11

Clases

(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

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

Un elemento de cuerpo utilizado con las construcciones For y When. Más...

clase Else

Un elemento "else" utilizado en expresiones condicionales. Más...

clase ElseIf

Elemento "else if" utilizado en expresiones condicionales. Más información...

clase ExecutableItem

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

clase ExecutionMode

Elemento del 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 ser utilizado dentro del elemento For. Más...

clase Group

Group representa el elemento básico para componer recetas declarativas que describen cómo ejecutar y manejar 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

Elemento "if" utilizado en expresiones condicionales. Más...

clase Iterator

Clase base para ser utilizada como iterador dentro de un elemento For. Más...

clase ListIterator

El iterador de lista a utilizar dentro del elemento For. Más...

clase ObjectSignal

Estructura que describe la subclase QObject y su señal. Más...

clase ParallelLimit

El modo de ejecución en paralelo con un límite personalizado. Más...

clase QBarrier

Una tarea asíncrona que termina bajo demanda. Más...

clase QCustomTask

Una plantilla de clase utilizada para declarar elementos de tareas personalizadas y definir sus manejadores de configuración y finalización. Más...

clase QDefaultTaskAdapter

Una plantilla de clase que proporciona adaptador de tarea por defecto utilizado en QCustomTask. Más...

clase QMappedTaskTreeRunner

Un controlador de ejecución de árbol de tareas mapeado con un tipo de Clave dado. Más...

clase QNetworkReplyWrapper

Una envoltura alrededor de QNetworkReply y QNetworkAccessManager. Más información...

clase QParallelTaskTreeRunner

Un controlador de ejecución de árbol 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 árbol de tareas. Más...

clase QSingleTaskTreeRunner

Un controlador de ejecución de árbol de tarea única. Más...

clase QStartedBarrier

Un iniciado QBarrier con un límite dado. Más...

clase QSyncTask

Sincrónicamente ejecuta un controlador personalizado entre otras tareas. Más...

clase QTaskInterface

QTaskInterface es una clase de ayuda utilizada cuando se adapta la interfaz de tareas personalizadas. Más...

clase QTaskTree

La clase QTaskTree ejecuta el árbol de tareas asíncronas definidas de forma declarativa. Más...

clase QTcpSocketWrapper

Una envoltura alrededor de QTcpSocket. Más...

clase QThreadFunction

Una plantilla de clase que controla la ejecución de una función en un hilo separado a través de QtConcurrent::run(). Más...

clase QThreadFunctionBase

Una clase base para QThreadFunction plantilla de clase. Más...

clase RepeatIterator

El iterador repetitivo que se utilizará dentro del elemento For. Más...

clase Storage

Una plantilla de clase para el intercambio de datos personalizados 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 utilizará dentro del elemento For. Más...

clase When

Un elemento que retrasa la ejecución de un cuerpo hasta que avance la barrera. Más...

Documentación de la clase

[alias] BarrierKickerGetter

Tipo de alias para la función que toma un QStoredBarrier y devuelve ExecutableItem, es decir std::function<ExecutableItem(const QStoredBarrier &)>, para ser usado dentro del constructor When.

enum class QtTaskTree::CallDoneFlag
flags QtTaskTree::CallDone

Esta enum es un argumento opcional para el elemento onGroupDone() o el constructor de la tarea personalizada. Indica al árbol de tareas cuándo debe invocarse el manejador de grupo o tarea.

ConstanteValorDescripción
QtTaskTree::CallDoneFlag::Never0El gestor de tareas finalizadas nunca se invoca.
QtTaskTree::CallDoneFlag::OnSuccess1 << 0El manejador de tareas terminadas se invoca sólo después de una ejecución exitosa, es decir, cuando DoneWith::Success.
QtTaskTree::CallDoneFlag::OnError1 << 1El manejador done es invocado sólo después de una ejecución fallida, es decir, cuando DoneWith::Error.
QtTaskTree::CallDoneFlag::OnCancel1 << 2El manejador done se invoca sólo después de una ejecución cancelada, es decir, cuando DoneWith::Cancel.
QtTaskTree::CallDoneFlag::AlwaysOnSuccess | OnError | OnCancelEl manejador done se invoca siempre.

El tipo CallDone es un typedef para QFlags<CallDoneFlag>. Almacena una combinación OR de valores CallDoneFlag.

enum class QtTaskTree::DoneResult

Este enum se devuelve opcionalmente desde la función del gestor de tareas o grupos. Cuando el gestor realizado no devuelve ningún valor, es decir, su tipo de retorno es void, su valor de retorno final es deducido automáticamente por el árbol de tareas en ejecución e informado a su grupo padre.

Cuando el gestor final devuelve el DoneResult, puede modificar el valor de retorno final dentro del gestor.

Cuando el DoneResult es devuelto por el manejador hecho del grupo, la política de flujo de trabajo del grupo es ignorada.

Este enum también se utiliza dentro de la señal TaskInterface::done() e indica si la tarea finalizó con éxito o con un error.

ConstanteValorDescripción
QtTaskTree::DoneResult::Success0La ejecución del grupo o tarea finaliza con éxito.
QtTaskTree::DoneResult::Error1La ejecución del grupo o tarea finaliza con un error.

enum class QtTaskTree::DoneWith

Este enum es un argumento opcional para el manejador de grupo o tarea terminada. Indica si el grupo o tarea ha finalizado con éxito o con un error, o si se ha 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 tarea ha finalizado con éxito.
QtTaskTree::DoneWith::Error1La ejecución del grupo o tarea ha finalizado con error.
QtTaskTree::DoneWith::Cancel2La ejecución del grupo o tarea ha sido cancelada. 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 provoca la cancelación de algunos de sus hijos en ejecución. Si se cancela la ejecución del grupo o de la tarea, no es posible modificar el resultado final del manejador de tareas mediante la devolución de DoneResult desde el manejador.

[alias] QtTaskTree::GroupItems

Escriba el alias para QList<GroupItem>.

[alias] QBarrierTask

Tipo de alias para el QCustomTask<QBarrier>, que se utilizará dentro de las recetas.

[alias] QNetworkReplyWrapperTask

Tipo de alias para el QCustomTask<QNetworkReplyWrapper>, que se utilizará dentro de las recetas.

[alias] QProcessTask

Escriba un alias para el QCustomTask<QProcess>, utilizando QProcessTaskDeleter, que se utilizará dentro de las recetas.

[alias] QStoredBarrier

Tipo de alias para el QtTaskTree::Storage<QStartedBarrier>, que se utilizará dentro de las recetas.

[alias] QTaskTreeTask

Tipo de alias para el QCustomTask<QTaskTree>, que se utilizará dentro de las recetas.

[alias] QTcpSocketWrapperTask

Tipo de alias para el QCustomTask<QTcpSocketWrapper>, que se utilizará dentro de las recetas.

[alias] template <typename ResultType> QThreadFunctionTask

Alias de tipo para el QCustomTask<QThreadFunction<ResultType>>, para ser utilizado dentro de recetas.

[alias] QTimeoutTask

Tipo de alias para el QCustomTask<std::chrono::milliseconds>, que se utilizará dentro de las recetas. El std::chrono::milliseconds se utiliza para establecer la duración del tiempo de espera. El tiempo de espera por defecto es std::chrono::milliseconds::zero(), es decir, la QTimeoutTask termina 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)
};

Ver también timeoutTask().

enum class QtTaskTree::SetupResult

Este enum se devuelve opcionalmente desde la función del manejador de configuración del grupo o tarea. Indica al árbol de tareas en ejecución cómo proceder una vez finalizada la ejecución del gestor de configuración.

ConstanteValorDescripción
QtTaskTree::SetupResult::Continue0Valor por defecto. La ejecución del grupo o tarea continúa normalmente. Cuando el manejador de configuración de un grupo o tarea devuelve void, se asume que ha devuelto Continue.
QtTaskTree::SetupResult::StopWithSuccess1La ejecución del grupo o tarea se detiene inmediatamente con éxito. Cuando se devuelve desde el manejador de configuración del grupo, todas las tareas hijas se omiten, y el manejador onGroupDone() del grupo se invoca con DoneWith::Success. El grupo informa del éxito a su padre. La política de flujo de trabajo del grupo se ignora. Cuando se devuelve desde el manejador de configuración de la tarea, la tarea no se inicia, su manejador no se invoca, 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. Cuando se devuelve desde el controlador de configuración del grupo, se omiten todas las tareas secundarias y se invoca al controlador onGroupDone() del grupo con DoneWith::Error. El grupo informa de un error a su padre. La política de flujo de trabajo del grupo se ignora. Cuando se devuelve desde el manejador de configuración de la tarea, la tarea no se inicia, su manejador de error no se invoca, y la tarea informa de un error a su padre.

[alias] QtTaskTree::TreeDoneHandler

Alias de tipo para std::function<void(const QTaskTree &, QtTaskTree::DoneWith)>.

TreeDoneHandler es un argumento opcional de las funciones de los ejecutores del árbol de tareas que programan la ejecución del árbol de tareas. La función se llama cuando la receta del ejecutor del árbol de tareas finaliza la ejecución. El acceso a QTaskTree y al resultado de la receta se realiza a través de los argumentos pasados.

Los ejecutores del árbol 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 &)>.

TreeSetupHandler es un argumento opcional de las funciones de los ejecutores del árbol de tareas que programan la ejecución del árbol de tareas. Se llama a la función 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 del árbol de tareas también aceptan manejadores en una forma abreviada de std::function<void(void)>.

enum class QtTaskTree::WorkflowPolicy

Este enum describe el posible comportamiento del elemento Grupo cuando la tarea hija de cualquier grupo finaliza su ejecución. También se utiliza cuando se cancela el Grupo en ejecución.

ConstanteValorDescripción
QtTaskTree::WorkflowPolicy::StopOnError0Por defecto. Corresponde al 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 con éxito, el grupo finaliza con éxito. Si un grupo está vacío, finaliza con éxito.
QtTaskTree::WorkflowPolicy::ContinueOnError1Corresponde al elemento global continueOnError. Similar a stopOnError, pero en caso de que algún hijo termine con un error, la ejecución continúa hasta que todas las tareas terminan, y el grupo informa de un error después, incluso cuando algunas otras tareas en el grupo terminaron 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 algún hijo termine con éxito, la ejecución continúa hasta que todas las tareas terminan, y el grupo informa de éxito después, incluso cuando algunas otras tareas en el grupo terminaron con un error. Si todas las tareas secundarias terminan con un error, el grupo termina 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 puede. Cuando alguna tarea termina, el grupo se detiene e informa del resultado de la tarea. Útil sólo en modo paralelo. En modo secuencial, sólo se inicia la primera tarea, y cuando termina, el grupo también termina, por lo que las demás tareas siempre se omiten. Si un grupo está vacío, termina con un error.
QtTaskTree::WorkflowPolicy::FinishAllAndSuccess5Corresponde al elemento global finishAllAndSuccess. El grupo ejecuta todas las tareas e ignora sus resultados. Cuando todas las tareas finalizan, el grupo termina con éxito. Si un grupo está vacío, finaliza con éxito.
QtTaskTree::WorkflowPolicy::FinishAllAndError6Corresponde al elemento global finishAllAndError. El grupo ejecuta todas las tareas e ignora sus resultados. Cuando todas las tareas han finalizado, el grupo termina con un error. Si un grupo está vacío, finaliza con un error.

Cuando el resultado de una tarea secundaria hace que el grupo se detenga, es decir, en el 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 el modo paralelo) y omite la ejecución de las tareas que aún no ha iniciado (por ejemplo, en el modo secuencial, las que se colocan después de la tarea que ha fallado). Tanto la cancelación como la omisión de tareas secundarias pueden ocurrir cuando se utiliza ParallelLimit.

La siguiente tabla resume las diferencias entre varias políticas de flujo de trabajo:

Política de flujo de trabajoEjecuta todas las tareas secundariasResultadoResultado cuando el grupo está vacío
StopOnErrorSe detiene cuando cualquier tarea secundaria finaliza con un error e informa de un errorUn error cuando al menos una tarea secundaria falla, éxito en caso contrarioÉxito
ContinuarEnErrorUn error cuando al menos una tarea secundaria falla, éxito en caso contrarioÉxito
StopOnSuccessSe detiene cuando cualquier tarea secundaria finaliza con éxito e informa del éxitoÉxito cuando al menos una tarea secundaria ha tenido éxito, error en caso contrarioError
ContinueOnSuccessÉxito cuando al menos una tarea secundaria ha tenido éxito, error en caso contrarioError
StopOnSuccessOrErrorSe detiene cuando finaliza cualquier tarea secundaria e informa del resultado de la mismaÉxito o error, dependiendo del resultado de la tarea secundaria finalizadaError
FinishAllAndSuccessÉxitoÉxito
FinishAllAndErrorUn errorUn error

Si un grupo hijo de un grupo es también un grupo, el grupo hijo ejecuta sus tareas según su propia política de flujo de trabajo. Cuando un grupo padre detiene la ejecución del grupo hijo debido a la política de flujo de trabajo del grupo padre, es decir, cuando se utilizó la política StopOnError, StopOnSuccess o StopOnSuccessOrError para el padre, el resultado del grupo hijo se informa según la columna Resultado y la fila de política de flujo de trabajo del grupo hijo en la tabla anterior.

Documentación de variables

const QtTaskTree::GroupItem QtTaskTree::continueOnError

Un cómodo elemento del grupo global que describe la política de flujo de trabajo de ContinueOnError.

const QtTaskTree::GroupItem QtTaskTree::continueOnSuccess

Un cómodo elemento del grupo global que describe la política de flujo de trabajo de ContinueOnSuccess.

const QtTaskTree::ExecutableItem QtTaskTree::errorItem

Un elemento ejecutable global conveniente que contiene una tarea vacía, errónea y sincrónica.

Es ú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 conditionalTask termina con un error, se elige la rama Else, que termina inmediatamente con un error. Esto hace que se salte la rama nextTask (debido a la política de flujo de trabajo stopOnError de la rama group) y que la rama group termine con un error.

Véase también successItem.

const QtTaskTree::GroupItem QtTaskTree::finishAllAndError

Un cómodo elemento del grupo global que describe la política de flujo de trabajo de FinishAllAndError.

const QtTaskTree::GroupItem QtTaskTree::finishAllAndSuccess

Un cómodo elemento del grupo global que describe la política de flujo de trabajo de FinishAllAndSuccess.

const QtTaskTree::GroupItem QtTaskTree::nullItem

Un elemento conveniente del grupo global que indica un elemento no-op.

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

Práctico elemento global del grupo que describe el modo de ejecución en paralelo.

Todas las tareas hijas directas de un grupo se inician después de que se inicie 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 conveniente del grupo global que describe el modo de ejecución paralela con un número limitado de tareas que se ejecutan simultáneamente. El límite es igual al número ideal de subprocesos, excluyendo el subproceso de llamada.

Es un atajo para:

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

Véase también parallel y ParallelLimit.

const QtTaskTree::ExecutionMode QtTaskTree::sequential

Práctico elemento global del grupo que describe el modo de ejecución secuencial.

Este es el modo de ejecución por defecto 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 forma 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 se inicie. Este modo garantiza que la siguiente tarea se inicie sólo después de que finalice la anterior.

Véase también parallel y ParallelLimit.

const QtTaskTree::GroupItem QtTaskTree::stopOnError

Práctico elemento global del grupo que describe la política de flujo de trabajo de StopOnError.

Esta es la política de flujo de trabajo por defecto del elemento Grupo.

const QtTaskTree::GroupItem QtTaskTree::stopOnSuccess

Un cómodo elemento del grupo global que describe la política de flujo de trabajo de StopOnSuccess.

const QtTaskTree::GroupItem QtTaskTree::stopOnSuccessOrError

Un cómodo elemento del grupo global que describe la política de flujo de trabajo de StopOnSuccessOrError.

const QtTaskTree::ExecutableItem QtTaskTree::successItem

Un elemento ejecutable global conveniente que contiene una tarea vacía, exitosa y sincrónica.

Es útil en las sentencias if para indicar que una rama termina con éxito:

const ExecutableItem conditionalTask = ...;

const Group group {
    stopOnSuccess,
    If (conditionalTask) >> Then {
        ...
    } >> Else {
        successItem
    },
    nextTask
};

En el ejemplo anterior, si conditionalTask termina con un error, se elige la rama Else, que termina inmediatamente con éxito. Esto hace que se omita nextTask (debido a la política de flujo de trabajo de stopOnSuccess de group) y que group termine con éxito.

Véase también errorItem.

Documentación de funciones

QtTaskTree::ExecutableItem QtTaskTree::barrierAwaiterTask(const QtTaskTree::QStoredBarrier &storedBarrier)

Devuelve la tarea awaiter que finaliza cuando se pasa storedBarrier.

Nota: El storedBarrier pasado necesita ser colocado en la misma receta como un elemento hermano de la tarea devuelta o en cualquier Group ancestro, de lo contrario puede esperar un fallo.

template <typename Signal> QtTaskTree::ObjectSignal<std::decay_t<Signal>> QtTaskTree::makeObjectSignal(typename QtPrivate::FunctionPointer<Signal>::Object *object, Signal &&signal)

Una función conveniente para crear ObjectSignal dentro de la función ObjectSignalGetter pasada a ExecutableItem::withCancel() o ExecutableItem::withAccept(). Pasa un object y su signal para crear una instancia de ObjectSignal struct.

Véase también ObjectSignal, ExecutableItem::withCancel(), y ExecutableItem::withAccept().

template <typename Handler> QtTaskTree::GroupItem QtTaskTree::onGroupDone(Handler &&handler, QtTaskTree::CallDone callDone = CallDoneFlag::Always)

Construye un elemento de grupo que contiene el manejador de grupo terminado. Por defecto, handler se invoca siempre que el grupo finaliza. Pasa un valor no predeterminado para el argumento callDone cuando quieras que el manejador sea llamado sólo en una ejecución exitosa, fallida o cancelada. Dependiendo de la política de flujo de trabajo del grupo, también se puede llamar a este manejador cuando se cancela el grupo en ejecución (por ejemplo, cuando se utilizó el elemento stopOnError ).

El handler pasado es del tipo std::function<DoneResult(DoneWith)>. Opcionalmente, se puede omitir el tipo de retorno DoneResult o el tipo de argumento DoneWith (es decir, su tipo de retorno puede ser void). Para más información sobre un posible tipo de manejador, consulte GroupItem::GroupDoneHandler.

Cuando se invoca handler, todas las tareas hijas del grupo ya han finalizado.

Si un grupo contiene los elementos Almacenamiento, se invoca el handler antes de que se destruyan los almacenamientos, para que el handler todavía pueda realizar una última lectura de los datos de los almacenamientos activos.

Véase también GroupItem::GroupDoneHandler y onGroupSetup().

template <typename Handler> QtTaskTree::GroupItem QtTaskTree::onGroupSetup(Handler &&handler)

Construye un elemento de grupo que contiene el manejador de configuración del grupo. El handler se invoca cada vez que se inicia el grupo.

El handler pasado es del tipo std::function<SetupResult()> o std::function<void()>. Para más información sobre un posible tipo de manejador, consulta GroupItem::GroupSetupHandler.

Cuando se invoca el handler, todavía no se está ejecutando ninguna de las tareas secundarias del grupo.

Si un grupo contiene los elementos Almacenamiento, el handler se invoca después de que se construyan los almacenamientos, de modo que el handler ya puede realizar algunas modificaciones iniciales en los almacenamientos 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 awaiter que finaliza cuando la sender pasada emite la signal.

Nota: La conexión con los sender y signal pasados no se establece cuando la tarea devuelta se crea o se coloca en una receta, sino cuando la tarea es iniciada por el QTaskTree. Asegúrese de que el sender pasado sobreviva a cualquier árbol de tareas en ejecución que contenga la tarea devuelta. Si el signal se emitió 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 después de que se iniciara 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)

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