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

La especialización ara::core::Promise< void, E > sirve como extremo productor asíncrono para señalizar la finalización de una operación sin valor de retorno o para transmitir un error ([SWS_CORE_06341]). Tras la instanciación, se recupera exactamente una vez a través de get_future() el Future asociado para el consumidor ([SWS_CORE_06344]). La provisión se realiza de forma segura para hilos mediante set_value(), SetError() o SetResult(), con lo cual el estado compartido se marca como listo. Dado que la clase posee semántica de solo movimiento, el establecimiento múltiple o la ausencia de estados compartidos provocan violaciones especificadas.

más ›

Contexto

La clase ara::core::Promise< void, E > representa una especialización de plantilla para flujos asíncronos sin valor de datos útiles (tipo de retorno void). Constituye el lado productor (Producer) de un canal de comunicación y sincroniza cálculos u operaciones asíncronas con el lado consumidor (Consumer). A través de un estado interno compartido (Shared State), permite señalizar tanto la ejecución exitosa de una operación como la aparición de un error del tipo E. El objeto receptor correspondiente se proporciona en forma de ara::core::Future< void, E > ([SWS_CORE_06344]). Según las prescripciones de AUTOSAR Adaptive Platform, la implementación requiere que el tipo de error E sea compatible con ara::core::ErrorCode; cualquier discrepancia provoca un error en tiempo de compilación.

Ciclo de vida

La creación de una instancia se realiza a través del constructor por defecto sin parámetros [SWS_CORE_06341], el cual crea un nuevo estado compartido y se comporta de forma análoga a la función estándar de C++ std::promise. La clase modela una propiedad exclusiva e implementa una estricta semántica de movimiento: tanto el constructor de copia ([SWS_CORE_06350]) como el operador de asignación por copia ([SWS_CORE_06351]) están eliminados (delete).

Un estado existente se puede transferir a otras instancias mediante el constructor de movimiento ([SWS_CORE_06342]) o el operador de asignación por movimiento ([SWS_CORE_06343]). En la asignación por movimiento, se renuncia a un Shared State mantenido hasta ese momento y el estado se transfiere como mediante Promise(std::move(other)).swap(*this) ([SWS_CORE_06343]). Además, la función swap ([SWS_CORE_06352]) permite el intercambio directo de dos estados.

El destructor [SWS_CORE_06349] libera un Shared State que aún se mantenga eventualmente. Interpretación: el abandono prematuro del Shared State al destruirse un promise aún insatisfecho probablemente conduzca a un estado huérfano en el future vinculado. Pregunta Q-e89b32fa3e5994e2 (abierta) En cuanto a la concurrencia, la creación estándar ([SWS_CORE_06341]) y el establecimiento del resultado ([SWS_CORE_06345], [SWS_CORE_06353], [SWS_CORE_06354], [SWS_CORE_06355], [SWS_CORE_06356]) son seguros para hilos. En cambio, las operaciones de movimiento, swap, la obtención del future ([SWS_CORE_06344]) y la destrucción no son seguras para hilos y requieren una coordinación externa en caso de acceso compartido.

Ruta de uso

El uso típico de ara::core::Promise< void, E > abarca la preparación de la ejecución asíncrona, la transferencia del canal de recepción y la subsiguiente notificación del resultado:

1. Inicialización: el productor instancia el objeto promise ([SWS_CORE_06341]).
2. Obtención del future: a través de get_future() se crea exactamente una vez el ara::core::Future< void, E > vinculado ([SWS_CORE_06344]) y se transfiere al lado consumidor.
3. Establecimiento del resultado: tras la finalización de la operación asíncrona, el productor pone el estado compartido en el estado listo (ready):
   • En caso de éxito, mediante la llamada a set_value() sin argumentos ([SWS_CORE_06345]).
   • En caso de error, almacenando un error mediante SetError, ya sea por movimiento ([SWS_CORE_06353]) o por copia ([SWS_CORE_06354]).
   • Alternativamente, transfiriendo un Result< void, E > completo mediante SetResult por copia ([SWS_CORE_06355]) o movimiento ([SWS_CORE_06356]).
4. Resolución: tan pronto como el estado está listo, el consumidor puede consumir el resultado a través del future; el objeto promise se libera al final de su ámbito ([SWS_CORE_06349]).

Diagrama de secuencia: flujo típico de la sincronización asíncrona desde la creación hasta la provisión del resultado. Fuentes: [SWS_CORE_06341], [SWS_CORE_06344], [SWS_CORE_06345], [SWS_CORE_06349]

Escenarios de error

Las violaciones de las precondiciones conllevan situaciones de error definidas (Violations):

• IsoStdFutureErrcFutureAlreadyRetrievedViolation: se desencadena en caso de que get_future() se invoque múltiples veces para el mismo estado compartido ([SWS_CORE_06344]).
• IsoStdFutureErrcNoStateViolation: se produce cuando se invoca get_future() sin que el promise disponga de un estado compartido ([SWS_CORE_06344]), por ejemplo tras una operación de movimiento ([SWS_CORE_06342]).
• IsoStdFutureErrcPromiseAlreadySatisfiedViolation: tiene lugar si se invoca set_value() ([SWS_CORE_06345]), SetError() ([SWS_CORE_06353], [SWS_CORE_06354]) o SetResult() ([SWS_CORE_06355], [SWS_CORE_06356]) a pesar de que ya se haya depositado un valor o error en el Shared State.
• PromiseNoSharedStateToSetViolation: señaliza que set_value() ([SWS_CORE_06345]), SetError() ([SWS_CORE_06353], [SWS_CORE_06354]) o SetResult() ([SWS_CORE_06355], [SWS_CORE_06356]) se han invocado sin un estado compartido existente.

En lo relativo a la seguridad frente a excepciones, los métodos SetError y SetResult son condicionalmente seguros frente a excepciones (conditionally exception safe): garantizan noexcept solo si el tipo E está clasificado como construible por movimiento sin excepciones o construible por copia sin excepciones ([SWS_CORE_06353], [SWS_CORE_06354], [SWS_CORE_06355], [SWS_CORE_06356]).