clase ara::core::Future

usar

El método get() recupera sincrónicamente el resultado de tipo T de un ara::core::Future [SWS_CORE_00326]. La función se comporta de forma idéntica a su homóloga en std::future; si el cómputo asincrónico aún continúa, la llamada se bloquea hasta su finalización o hasta que ocurra un error [SWS_CORE_00336]. Debido a la llamada, el objeto pierde su estado, de modo que el Future queda invalidado de inmediato (valid() == false) [SWS_CORE_00326]. Una llamada sin bloqueo puede asegurarse previamente mediante is_ready() [SWS_CORE_00332].

Manejo de errores

Los fallos se señalan a través de excepciones de C++ [SWS_CORE_00326]:

• Si en el Promise asignado se registró un error mediante SetError() o SetResult(), se lanza una excepción del tipo de error correspondiente [SWS_CORE_00326].
• Si la operación asincrónica abandona prematuramente el Shared State, esto da lugar al error kBrokenPromise conforme a FutureErrc [SWS_CORE_00326], [SWS_CORE_00400].
• Si la llamada se realiza en una instancia no válida, se lanza una FutureException con el código de error kNoState [SWS_CORE_00326].

Concurrencia y restricciones

La operación no es ni segura para subprocesos ni segura frente a excepciones (not exception safe) [SWS_CORE_00326]. Los accesos simultáneos al mismo Future desde varios subprocesos requieren sincronización externa. Si las excepciones están desactivadas en la cadena de herramientas del compilador, get() no participa en la resolución de sobrecargas [SWS_CORE_00326]; para este caso existe la alternativa sin excepciones GetResult() [SWS_CORE_00336]. Para instancias sin valor de retorno está disponible la especialización Future<void, E>::get() [SWS_CORE_06226].

La función miembro then sirve para encadenar cálculos asincrónicos y registra un objeto invocable func como continuación en una instancia de ara::core::Future [SWS_CORE_00331]. Al retornar la llamada, el Future original queda invalidado (valid() == false). El destino de invocación recibe el resultado de la instancia obtenido mediante GetResult() como un Rvalue de tipo Result<T, E> [SWS_CORE_00331].

El tipo de retorno de then se rige por el tipo de retorno U de la continuación [SWS_CORE_00331]:

• Si func devuelve un Future<T2, E2>, se produce un desempaquetado implícito de Future (Future-Unwrapping) a Future<T2, E2> [SWS_CORE_00331].
• Si func devuelve un Result<T2, E2>, se produce un desempaquetado implícito de Result (Result-Unwrapping) a Future<T2, E2> [SWS_CORE_00331].
• En todos los demás casos, el tipo de retorno es Future<U, E> [SWS_CORE_00331].

La ejecución de func puede tener lugar sincrónicamente en el contexto de la llamada de then, en el contexto de Promise::set_result o Promise::SetError, o en otro contexto [SWS_CORE_00331]. La llamada está especificada como no segura para subprocesos. La continuación se registra en el Future devuelto; tras el retorno de su destructor no se podrá ejecutar ninguna continuación más, mientras que una ejecución que ya esté en curso se ejecutará hasta el final [SWS_CORE_00331].

No existen códigos de error estandarizados [SWS_CORE_00331]. Los errores deben ser capturados por los usuarios y transmitidos como código de error en un Result o un Future devuelto, ya que las excepciones no deben salir de la continuación. Una llamada en un Future no válido desencadena FutureInvalidViolation; si la continuación lanza una excepción, esto resulta en FutureContinuationHasThrownViolation [SWS_CORE_00331].

Para ejecuciones en un contexto de ejecución explícito se encuentra disponible la sobrecarga con ejecutor [SWS_CORE_00337], mientras que para operaciones sin valor de retorno se aplica la especialización void [SWS_CORE_06231].

Uso y semántica

El método then registra una continuación (func) que se ejecuta de forma asíncrona en el contexto del executor pasado en cuanto se dispone del resultado de la instancia de Future actual [SWS_CORE_00337]. La unidad invocable toma el resultado de la instancia como una expresión rvalue del tipo Result<T,E> [SWS_CORE_00337]. El tipo de retorno depende del tipo de retorno U de la continuación:

• Si la continuación devuelve un Future<T2,E2>, se produce un desempaquetado implícito a Future<T2,E2> [SWS_CORE_00337].
• Si la continuación devuelve un Result<T2,E2>, este también se resuelve implícitamente a Future<T2,E2> [SWS_CORE_00337].
• En todos los demás casos, la llamada devuelve Future<U,E> [SWS_CORE_00337].

Concurrencia y ciclo de vida

Inmediatamente después del retorno de la llamada al método, la instancia original de Future pasa a ser no válida (valid() == false) [SWS_CORE_00337]. La función está declarada como no segura para subprocesos [SWS_CORE_00337]. Las continuaciones registradas se gestionan en el Future devuelto de nuevo. Tras la finalización de su destructor, no se debe iniciar ninguna continuación más; una ejecución que ya esté en curso se completará, por lo que el destructor puede bloquearse [SWS_CORE_00337].

Tratamiento de errores e interacción

No hay definidos códigos de error estandarizados [SWS_CORE_00337]. Una llamada en una instancia no válida desencadena la infracción FutureInvalidViolation [SWS_CORE_00337]. Si la continuación lanza una excepción, esto resulta en una FutureContinuationHasThrownViolation; por lo tanto, las excepciones deben capturarse y transmitirse como errores mediante ara::core::Result o ara::core::Future [SWS_CORE_00337]. En comparación con la sobrecarga sin contexto de ejecución [SWS_CORE_00331], esta variante impone la ejecución en el ejecutor pasado; para tipos de resultado void existe la especialización análoga [SWS_CORE_06237].

La función de consulta síncrona valid() comprueba sin parámetros si una instancia de ara::core::Future posee un estado compartido (Shared State) y, con ello, si es utilizable [SWS_CORE_00327]. Devuelve true si el objeto está listo para su uso, y false si no existe ningún estado compartido [SWS_CORE_00327]. El comportamiento corresponde a la función estándar std::future::valid y es aplicable del mismo modo para la especialización de plantilla ara::core::Future<void, E> [SWS_CORE_06227].

La función está declarada como noexcept, se considera segura frente a excepciones (exception safe) y está especificada expresamente como segura para subprocesos (thread-safe) [SWS_CORE_00327]. Ella misma no desencadena códigos de error ni excepciones y, por lo tanto, puede utilizarse sin peligro para la comprobación del estado [SWS_CORE_00327].

En la interacción con otros métodos de Future, la comprobación de validez es crucial, ya que las operaciones invocadoras como wait() [SWS_CORE_00328] o is_ready() [SWS_CORE_00332] lanzan una FutureInvalidViolation en caso de estado no válido (valid() == false). Un Future previamente válido pasa a ser automáticamente no válido tan pronto como se consume su resultado mediante get() [SWS_CORE_00326] o GetResult() [SWS_CORE_00336] o se registra un procesamiento posterior a través de then() [SWS_CORE_00331], [SWS_CORE_00337].

La función miembro wait de la clase ara::core::Future bloquea el hilo llamador de forma síncrona hasta que esté disponible un valor resultante o un error de la operación asíncrona [SWS_CORE_00328]. La función no acepta parámetros, no devuelve ningún valor y, conforme a la especificación, se comporta de forma análoga a la función correspondiente de std::future [SWS_CORE_00328]. El mismo comportamiento es aplicable a la especialización de plantilla ara::core::Future<void, E> [SWS_CORE_06228].

En cuanto al tratamiento de errores y la concurrencia, se definen las siguientes prescripciones:

• Condición de error: Si el objeto Future no es válido (valid == FALSE), se produce un FutureInvalidViolation [SWS_CORE_00328], [SWS_CORE_06228]. No obstante, la función está declarada como noexcept y clasificada como segura frente a excepciones (exception safe) [SWS_CORE_00328].
• Seguridad frente a hilos: La invocación está clasificada explícitamente como not thread-safe [SWS_CORE_00328]. Un acceso concurrente al mismo objeto Future sin sincronización externa no está permitido.

En interacción con interfaces afines, se recomienda realizar la comprobación mediante is_ready [SWS_CORE_00332], [SWS_CORE_06232] antes de la llamada: si esta devuelve true, se garantiza que la invocación de wait ya no se bloqueará. Si en lugar de una espera indefinida se requiere un proceso de bloqueo limitado en el tiempo, están disponibles alternativamente wait_for con una duración temporal relativa [SWS_CORE_00329], [SWS_CORE_06229], así como wait_until con un punto temporal absoluto [SWS_CORE_00330], [SWS_CORE_06230].

usar

La función miembro wait_for de la clase ara::core::Future bloquea el hilo que realiza la llamada durante un tiempo máximo igual al intervalo de tiempo pasado timeoutDuration o hasta que un valor de resultado o un error esté disponible en el estado compartido [SWS_CORE_00329]. Su comportamiento corresponde a la función equivalente de std::future [SWS_CORE_00329]. Como valor de retorno proporciona un FutureStatus [SWS_CORE_00329], que indica si el estado compartido está disponible (kReady) o si el tiempo de espera predeterminado ha expirado (kTimeout) [SWS_CORE_00361].

Tratamiento de errores y condiciones límite

La función está declarada como noexcept y especificada como segura ante excepciones (exception safe) [SWS_CORE_00329]. Si el objeto Future no es válido (valid == FALSE), se produce una infracción en forma de FutureInvalidViolation [SWS_CORE_00329]. Interpretación: dado que no se deben lanzar excepciones de C++, es de suponer que dicha infracción sea tratada por la plataforma como un error fatal en tiempo de ejecución. Pregunta Q-2f22a07f6e143856 (abierta)

Concurrencia e interacción

La operación está clasificada como not thread-safe [SWS_CORE_00329]; por lo tanto, los accesos simultáneos a la misma instancia requieren sincronización externa. La semántica y la firma aplican de forma idéntica a la especialización de plantilla ara::core::Future<void, E> [SWS_CORE_06229]. A diferencia de std::future_status, en el tipo de enumeración FutureStatus no existe ninguna entrada para deferred [SWS_CORE_00361].

La función miembro wait_until bloquea el hilo llamante hasta que se alcanza el instante temporal absoluto especificado deadline o bien el ara::core::Future proporciona un resultado o un error [SWS_CORE_00330]. El comportamiento se basa en la función correspondiente de std::future [SWS_CORE_00330].

Como valor de retorno, la función proporciona un FutureStatus [SWS_CORE_00330]. Este tipo enum señala a través del estado kReady que el estado compartido está listo (valor o error disponible), o a través de kTimeout que el plazo ha expirado sin resultado [SWS_CORE_00361]. En FutureStatus no existe un estado análogo a std::future_status::deferred [SWS_CORE_00361].

En cuanto al tratamiento de errores y la seguridad frente a excepciones, la función está especificada como segura ante excepciones (exception safe) y noexcept [SWS_CORE_00330]. Sin embargo, si la función se llama sobre una instancia no válida (valid == FALSE), se produce una infracción en forma de FutureInvalidViolation [SWS_CORE_00330].

Respecto a la concurrencia, wait_until está clasificado como no seguro frente a hilos (not thread-safe) [SWS_CORE_00330]. Por tanto, los accesos paralelos al mismo objeto ara::core::Future deben sincronizarse externamente. La misma semántica y firma se aplican a la especialización ara::core::Future<void, E> [SWS_CORE_06230].