clase ara::core::Future< void, E >

La función miembro get de la especialización ara::core::Future<void, E> sirve para esperar el resultado de una operación asíncrona sin valor de retorno ([SWS_CORE_06226]). Se comporta como la función correspondiente de std::future y bloquea al llamante hasta que el resultado o un error esté disponible ([SWS_CORE_06226], [SWS_CORE_00336]). Tras la llamada, la instancia de future pierde su validez, de modo que rige valid() == false ([SWS_CORE_06226]).

La función está declarada como no segura contra excepciones (not exception safe) ([SWS_CORE_06226]). Si se registró un error en el Promise vinculado, se lanza una excepción correspondiente ([SWS_CORE_06226]). Si el estado compartido se abandonó prematuramente, se produce el código de error kBrokenPromise conforme a [SWS_CORE_00400] ([SWS_CORE_06226]). Si se ejecuta get sobre una instancia que ya no es válida, la función lanza una FutureException con el código de error kNoState ([SWS_CORE_06226]).

En lo relativo a la concurrencia, el método no es seguro entre hilos (not thread-safe) ([SWS_CORE_06226]). Por lo tanto, los accesos paralelos al mismo objeto requieren sincronización externa. Además, la función no participa en la resolución de sobrecargas si las excepciones de C++ están desactivadas en la toolchain del compilador ([SWS_CORE_06226]).

En interacción con funciones afines, [SWS_CORE_00332] (is_ready) garantiza que get seguro que no bloquea si la operación ya ha finalizado. Para contextos sin excepciones, AUTOSAR ofrece como alternativa [SWS_CORE_00336] (GetResult), el cual notifica los errores a través de un tipo de resultado en lugar de lanzar excepciones.

usar

El método then registra una operación de continuación (continuation func) en una instancia de ara::core::Future<void, E> [SWS_CORE_06231]. El objeto invocable recibe el resultado de la operación como una expresión rvalue del tipo Result<void, E>, el cual se proporciona internamente a través de GetResult [SWS_CORE_06231]. La llamada a func puede tener lugar de forma síncrona en el contexto de then o de forma asíncrona en el contexto de Promise::set_value(), Promise::SetError() o en otro punto [SWS_CORE_06231].

Inmediatamente después del retorno de then, el Future original no es válido (valid() == false) [SWS_CORE_06231]. El tipo de retorno se adapta al tipo de retorno U de la continuación:

• Si func devuelve un Future<T2, E2>, se produce un desempaquetado implícito y then devuelve Future<T2, E2> [SWS_CORE_06231].
• Si func devuelve un Result<T2, E2>, este también se desempaqueta implícitamente a Future<T2, E2> [SWS_CORE_06231].
• En todos los demás casos, el tipo de retorno es Future<U, E> [SWS_CORE_06231].

Tratamiento de errores y condiciones límite

No se especifican códigos de error estandarizados para esta función [SWS_CORE_06231]. El método está declarado como noexcept, pero define dos violaciones (violations):

• FutureInvalidViolation: Se produce si el método se invoca en un Future no válido (si valid() devuelve false) [SWS_CORE_06231].
• FutureContinuationHasThrownViolation: Se produce si la continuación lanza una excepción que no implementa ninguna violation [SWS_CORE_06231]. En su lugar, los errores en la continuación deben devolverse empaquetados en un Result o Future [SWS_CORE_06231].

Concurrencia e interacción

El método no es seguro para hilos (not thread-safe) [SWS_CORE_06231]. Tras el retorno del destructor del Future devuelto ya no se ejecuta ninguna continuación registrada; sin embargo, una ejecución que ya esté en curso se completa, de modo que el destructor puede bloquear [SWS_CORE_06231]. Mientras que [SWS_CORE_06231] se aplica a Future<void, E>, [SWS_CORE_00331] describe la variante para Futures tipados Future<T, E> y [SWS_CORE_06237] la sobrecarga con ejecutor explícito.

La función then registra un objeto invocable de continuación (continuation) func en una instancia de ara::core::Future<void, E> para su ejecución en el contexto de ejecución indicado executor [SWS_CORE_06237]. Inmediatamente después del retorno de then, la instancia de future llamadora pierde su validez, de modo que es valid() == false [SWS_CORE_06237]. La continuación recibe el resultado de la instancia de future original pasado como Result<void, E> en forma de expresión rvalue [SWS_CORE_06237]. Como valor de retorno, la llamada proporciona una nueva instancia de Future, donde los tipos de retorno de la continuación de tipo Future<T2, E2> o Result<T2, E2> se desempaquetan implícitamente a Future<T2, E2>; de lo contrario, se devuelve un Future<U, E> [SWS_CORE_06237].

En relación con la concurrencia y el ciclo de vida, la función está especificada como no segura para subprocesos (not thread-safe) [SWS_CORE_06237]. La continuación se registra en el nuevo future devuelto. Tras el retorno del destructor de este nuevo future, ya no se podrá ejecutar ninguna continuación; no obstante, una continuación que ya esté en ejecución se completará en su totalidad, por lo que el destructor del future puede bloquearse [SWS_CORE_06237].

La función no declara códigos de error estandarizados y está definida como noexcept [SWS_CORE_06237]. Si se invoca sobre una instancia de future no válida, se produce la violación FutureInvalidViolation [SWS_CORE_06237]. En caso de que la continuación lance una excepción, esto da lugar a la violación FutureContinuationHasThrownViolation [SWS_CORE_06237]. Las excepciones no deben salir de la continuación, sino que, si es necesario, deben traducirse en valores de error y devolverse dentro de un Result o Future [SWS_CORE_06237]. La función complementa la variante sin ejecutor [SWS_CORE_06231] y constituye la contraparte de las sobrecargas con valor [SWS_CORE_00331] y [SWS_CORE_00337].

La función valid() comprueba de forma síncrona si la instancia de ara::core::Future<void, E> posee un estado compartido (Shared State) y, por tanto, es utilizable [SWS_CORE_06227]. Se comporta según la especificación de manera análoga a la función correspondiente de std::future [SWS_CORE_06227]. Como valor de retorno, devuelve true si el future es utilizable, y false si no es utilizable [SWS_CORE_06227].

En cuanto a la concurrencia y el tratamiento de errores, el método está declarado como noexcept, seguro frente a excepciones (exception safe) y explícitamente especificado como seguro para subprocesos (thread-safe) [SWS_CORE_06227]. Por lo tanto, puede invocarse de manera segura desde contextos concurrentes.

En combinación con otras operaciones, valid() sirve para salvaguardar el ciclo de vida:

• Si en un objeto future no válido (valid() == false) se invoca una operación como wait() [SWS_CORE_06228] o is_ready() [SWS_CORE_00332], esto desencadena la infracción FutureInvalidViolation.
• Las operaciones consumidoras invalidan el objeto: tras una llamada a get(), el future ya no es válido, por lo que las comprobaciones posteriores con valid() devuelven el valor false [SWS_CORE_06226].
• Del mismo modo, los reenvíos mediante then() [SWS_CORE_00331] o las llamadas a GetResult() [SWS_CORE_00336] hacen que el objeto future original se invalide de inmediato.

La función miembro wait de la especialización ara::core::Future<void, E> bloquea el hilo llamante de forma síncrona hasta que el resultado de la operación asíncrona esté disponible en forma de un valor o de un error [SWS_CORE_06228]. La función no toma parámetros, no devuelve ningún valor de retorno (void) y, conforme a la especificación, se comporta como la función correspondiente de std::future [SWS_CORE_06228].

Con respecto al tratamiento de errores y las condiciones de contorno se aplican los siguientes requisitos:

• Seguridad frente a excepciones y tratamiento de errores: La operación está declarada con noexcept y especificada como segura frente a excepciones (exception safe) [SWS_CORE_06228]. Si valid() devuelve para la instancia de Future false, se produce la violación FutureInvalidViolation [SWS_CORE_06228]. Es de esperar que la consecuencia concreta de esta violación esté implementada como un tratamiento de errores específico del sistema del entorno de ejecución de AUTOSAR. Pregunta Q-469e9abc947b9869 (abierta)
• Concurrencia: La función está clasificada como no segura para hilos (not thread-safe) [SWS_CORE_06228]. Por tanto, no se permite el acceso concurrente al mismo objeto Future sin sincronización externa.

En interacción con las demás funciones del módulo core existen las siguientes posibilidades:

• Con el método seguro para hilos is_ready se puede consultar de antemano si la operación ha finalizado; si se devuelve true, se garantiza que wait ya no bloqueará [SWS_CORE_06232].
• Para evitar un bloqueo indefinido están disponibles las funciones con límite de tiempo wait_for con una duración relativa [SWS_CORE_06229], así como wait_until con un punto temporal absoluto [SWS_CORE_06230].
• Para la clase plantilla primaria ara::core::Future se aplican los mismos requisitos de espera síncrona y restricciones [SWS_CORE_00328].

El método wait_for de la especialización ara::core::Future<void, E> bloquea el subproceso llamador de forma síncrona durante un periodo de tiempo máximo timeoutDuration o hasta que el resultado esté disponible [SWS_CORE_06229]. Se comporta semánticamente como la función estándar correspondiente std::future::wait_for [SWS_CORE_06229].

Como valor de retorno, la función proporciona el estado FutureStatus [SWS_CORE_06229]. Este señala con FutureStatus::kReady que un valor o un error está disponible, o bien con FutureStatus::kTimeout que el plazo ha expirado sin resultado [SWS_CORE_00361]. No se prevé un estado equivalente a std::future_status::deferred [SWS_CORE_00361]. El comportamiento se corresponde con la interfaz general de futuros [SWS_CORE_00329].

Para la llamada se aplican las siguientes condiciones respecto a la concurrencia y al tratamiento de errores:

• Concurrencia: la función está especificada como no segura para subprocesos (not thread-safe) [SWS_CORE_06229]. Las llamadas simultáneas sobre la misma instancia deben protegerse por parte del llamador.
• Casos de error y seguridad frente a excepciones: la operación está declarada como segura frente a excepciones (exception safe), así como noexcept [SWS_CORE_06229]. Si el objeto Future no es válido (valid() devuelve false), se produce una FutureInvalidViolation [SWS_CORE_06229]. Debido a la declaración noexcept, es de suponer que esta violación conducirá a la finalización inmediata del programa. Pregunta Q-4f01aa6e7fbfb12d (abierta)

La función miembro wait_until de la especialización ara::core::Future<void, E> bloquea el subproceso llamador hasta que se alcance el momento absoluto especificado deadline o hasta que haya disponible un valor o un error [SWS_CORE_06230]. La función muestra el mismo comportamiento que la correspondiente función estándar de C++ std::future::wait_until [SWS_CORE_06230] y posee la misma semántica que la sobrecarga genérica para ara::core::Future [SWS_CORE_00330].

El valor de retorno de tipo FutureStatus indica si se ha alcanzado el plazo o si hay un valor disponible [SWS_CORE_06230]. En este contexto, el estado kReady indica que el estado compartido está listo, mientras que kTimeout significa que el estado compartido no estuvo listo antes de que venciera el plazo [SWS_CORE_00361]. En FutureStatus no existe un estado análogo a std::future_status::deferred [SWS_CORE_00361].

En lo que respecta a la ejecución y a las condiciones límite, se definen las siguientes especificaciones:

• Contexto de llamada y comportamiento ante excepciones: la función está disponible a través del archivo de cabecera #include "ara/core/future.h", declarada como noexcept y especificada como segura frente a excepciones (exception safe) [SWS_CORE_06230].
• Estados de error: si el future no es válido, es decir, si valid() devuelve el valor false, se produce la violación FutureInvalidViolation [SWS_CORE_06230].
• Concurrencia: la operación está clasificada como no segura para subprocesos (not thread-safe) [SWS_CORE_06230].