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

A função-membro get da especialização ara::core::Future<void, E> serve para aguardar o resultado de uma operação assíncrona sem valor de retorno ([SWS_CORE_06226]). Ela se comporta como a função correspondente de std::future e bloqueia o chamador até que o resultado ou um erro esteja disponível ([SWS_CORE_06226], [SWS_CORE_00336]). Após a chamada, a instância de future perde sua validade, de modo que se aplica valid() == false ([SWS_CORE_06226]).

A função está declarada como não segura contra exceções (not exception safe) ([SWS_CORE_06226]). Se um erro tiver sido registrado no Promise associado, uma exceção correspondente será lançada ([SWS_CORE_06226]). Se o estado compartilhado tiver sido abandonado prematuramente, ocorrerá o código de erro kBrokenPromise de acordo com [SWS_CORE_00400] ([SWS_CORE_06226]). Se get for executado em uma instância já inválida, a função lançará um FutureException com o código de erro kNoState ([SWS_CORE_06226]).

Em relação à simultaneidade, o método não é seguro para threads (not thread-safe) ([SWS_CORE_06226]). Portanto, acessos paralelos ao mesmo objeto exigem sincronização externa. Além disso, a função não participa da resolução de sobrecarga se as exceções de C++ estiverem desativadas na toolchain do compilador ([SWS_CORE_06226]).

Na interação com funções relacionadas, [SWS_CORE_00332] (is_ready) garante que get comprovadamente não bloqueie, caso a operação já tenha sido concluída. Para contextos sem exceções, o AUTOSAR oferece como alternativa [SWS_CORE_00336] (GetResult), que reporta erros por meio de um tipo de resultado em vez de lançar exceções.

usar

O método then registra uma operação subsequente (continuation func) em uma instância de ara::core::Future<void, E> [SWS_CORE_06231]. O objeto invocável recebe o resultado da operação como uma expressão rvalue do tipo Result<void, E>, disponibilizada internamente via GetResult [SWS_CORE_06231]. A chamada de func pode ocorrer sincronicamente no contexto de then ou assincronicamente no contexto de Promise::set_value(), Promise::SetError() ou em outro local [SWS_CORE_06231].

Imediatamente após o retorno de then, o future original torna-se inválido (valid() == false) [SWS_CORE_06231]. O tipo de retorno adapta-se ao tipo de retorno U da continuation:

• Se func retornar um Future<T2, E2>, ocorrerá um desempacotamento implícito e then retornará Future<T2, E2> [SWS_CORE_06231].
• Se func retornar um Result<T2, E2>, este também será desempacotado implicitamente para Future<T2, E2> [SWS_CORE_06231].
• Em todos os restantes casos, o tipo de retorno é Future<U, E> [SWS_CORE_06231].

Tratamento de erros e condições de contorno

Códigos de erro padronizados não são especificados para esta função [SWS_CORE_06231]. O método é declarado como noexcept, mas define duas violações (violations):

• FutureInvalidViolation: Ocorre quando o método é chamado em um future inválido (caso valid() retorne false) [SWS_CORE_06231].
• FutureContinuationHasThrownViolation: Ocorre quando a continuation lança uma exceção que não implementa uma violação [SWS_CORE_06231]. Em vez disso, erros na continuation devem ser retornados empacotados em um Result ou Future [SWS_CORE_06231].

Concorrência e interação

O método não é seguro para threads (not thread-safe) [SWS_CORE_06231]. Após o retorno do destrutor do future retornado, nenhuma continuation registrada será mais executada; no entanto, uma execução já em andamento será concluída, de modo que o destrutor pode bloquear [SWS_CORE_06231]. Enquanto [SWS_CORE_06231] se aplica a Future<void, E>, [SWS_CORE_00331] descreve a variante para futures tipados Future<T, E> e [SWS_CORE_06237] descreve a sobrecarga com executor explícito.

A função then registra um objeto de continuação chamável (continuation) func em uma instância de ara::core::Future<void, E> para execução no contexto de execução especificado executor [SWS_CORE_06237]. Imediatamente após o retorno de then, a instância de Future chamadora perde sua validade, de modo que valid() == false é [SWS_CORE_06237]. A continuação recebe o resultado da instância de Future original como Result<void, E> passado sob a forma de uma expressão rvalue [SWS_CORE_06237]. Como valor de retorno, a chamada fornece uma nova instância de Future, em que tipos de retorno da continuação do tipo Future<T2, E2> ou Result<T2, E2> são desempacotados implicitamente para Future<T2, E2>; caso contrário, um Future<U, E> é retornado [SWS_CORE_06237].

Com relação à concorrência e ao ciclo de vida, a função está especificada como não segura para threads (not thread-safe) [SWS_CORE_06237]. A continuação é registrada no novo Future retornado. Após o retorno do destrutor desse novo Future, nenhuma continuação adicional pode ser executada; no entanto, uma continuação que já esteja em execução é concluída por inteiro, motivo pelo qual o destrutor do Future pode bloquear [SWS_CORE_06237].

A função não declara códigos de erro padronizados e está definida como noexcept [SWS_CORE_06237]. Se ela for chamada em uma instância de Future inválida, ocorre a violação FutureInvalidViolation [SWS_CORE_06237]. Caso a continuação lance uma exceção, isso leva à violação FutureContinuationHasThrownViolation [SWS_CORE_06237]. As exceções não podem sair da continuação; em vez disso, devem ser traduzidas, se necessário, em valores de erro e retornadas dentro de um Result ou Future [SWS_CORE_06237]. A função complementa a variante sem executor [SWS_CORE_06231] e constitui a contraparte das sobrecargas com valores [SWS_CORE_00331] e [SWS_CORE_00337].

A função valid() verifica de forma síncrona se a instância de ara::core::Future<void, E> possui um estado compartilhado (shared state) e, portanto, está utilizável [SWS_CORE_06227]. De acordo com a especificação, ela se comporta de forma análoga à função correspondente de std::future [SWS_CORE_06227]. Como valor de retorno, ela fornece true se o future puder ser utilizado e false se não puder ser utilizado [SWS_CORE_06227].

Em relação à concorrência e ao tratamento de erros, o método é declarado como noexcept, seguro contra exceções (exception safe) e expressamente especificado como thread-safe [SWS_CORE_06227]. Ele pode, portanto, ser chamado com segurança a partir de contextos concorrentes.

Na interação com outras operações, valid() serve para a proteção do ciclo de vida:

• Se uma operação como wait() [SWS_CORE_06228] ou is_ready() [SWS_CORE_00332] for chamada em um objeto future inválido (valid() == false), isso dispara a violação FutureInvalidViolation.
• Operações consumidoras invalidam o objeto: após uma chamada de get(), o future deixa de ser válido, de modo que verificações subsequentes com valid() resultam no valor false [SWS_CORE_06226].
• Da mesma forma, encaminhamentos por meio de then() [SWS_CORE_00331] ou chamadas de GetResult() [SWS_CORE_00336] fazem com que o objeto future original seja invalidado imediatamente.

A função-membro wait da especialização ara::core::Future<void, E> bloqueia a thread chamadora sincronicamente até que o resultado da operação assíncrona esteja disponível na forma de um valor ou de um erro [SWS_CORE_06228]. A função não aceita parâmetros, não retorna valor (void) e se comporta, de acordo com a especificação, como a função correspondente de std::future [SWS_CORE_06228].

Em relação ao tratamento de erros e condições de contorno, aplicam-se os seguintes requisitos:

• Segurança contra exceções e tratamento de erros: A operação é declarada com noexcept e especificada como segura contra exceções (exception safe) [SWS_CORE_06228]. Se valid() retornar false para a instância de future, ocorrerá a violação FutureInvalidViolation [SWS_CORE_06228]. A consequência concreta dessa violação deve ser implementada como um tratamento de erros específico do sistema no ambiente de execução do AUTOSAR. Pergunta Q-469e9abc947b9869 (aberta)
• Simultaneidade: A função é classificada como não segura para threads (not thread-safe) [SWS_CORE_06228]. Portanto, o acesso concorrente ao mesmo objeto future sem sincronização externa é inadmissível.

Na interação com as demais funções do módulo core, existem as seguintes possibilidades:

• Com o método seguro para threads is_ready, é possível consultar previamente se a operação foi concluída; ao retornar true, wait comprovadamente não bloqueará mais [SWS_CORE_06232].
• Para evitar o bloqueio infinito, estão disponíveis as funções com limite de tempo wait_for com uma duração relativa [SWS_CORE_06229], bem como wait_until com um instante absoluto [SWS_CORE_06230].
• Para a classe primária de template ara::core::Future, aplicam-se os mesmos requisitos de espera síncrona e restrições [SWS_CORE_00328].

O método wait_for da especialização ara::core::Future<void, E> bloqueia a thread chamadora de forma síncrona por um intervalo de tempo máximo timeoutDuration ou até que o resultado esteja disponível [SWS_CORE_06229]. Ele se comporta semanticamente como a função padrão correspondente std::future::wait_for [SWS_CORE_06229].

Como valor de retorno, a função fornece o status FutureStatus [SWS_CORE_06229]. Este sinaliza com FutureStatus::kReady que um valor ou um erro está disponível, ou com FutureStatus::kTimeout que o prazo expirou sem resultado [SWS_CORE_00361]. Um estado equivalente a std::future_status::deferred não está previsto [SWS_CORE_00361]. O comportamento corresponde à interface geral de Future [SWS_CORE_00329].

Para a chamada, aplicam-se as seguintes condições referentes a concorrência e tratamento de erros:

• Concorrência: a função está especificada como não segura para threads (not thread-safe) [SWS_CORE_06229]. Chamadas simultâneas na mesma instância devem ser protegidas pelo lado chamador.
• Casos de erro e segurança de exceções: a operação está declarada como segura contra exceções (exception safe) e noexcept [SWS_CORE_06229]. Se o objeto Future for inválido (valid() retorna false), ocorre uma FutureInvalidViolation [SWS_CORE_06229]. Devido à declaração noexcept, presume-se que essa violação provavelmente leve ao encerramento imediato do programa. Pergunta Q-4f01aa6e7fbfb12d (aberta)

A função-membro wait_until da especialização ara::core::Future<void, E> bloqueia a thread chamadora até que o instante absoluto deadline especificado seja atingido ou até que um valor ou erro esteja disponível [SWS_CORE_06230]. A função apresenta o mesmo comportamento que a função padrão C++ correspondente std::future::wait_until [SWS_CORE_06230] e possui a mesma semântica que a sobrecarga genérica para ara::core::Future [SWS_CORE_00330].

O valor de retorno do tipo FutureStatus sinaliza se o prazo foi atingido ou se um valor está disponível [SWS_CORE_06230]. Aqui, o estado kReady indica que o estado compartilhado está pronto, enquanto kTimeout significa que o estado compartilhado não ficou pronto antes de o prazo expirar [SWS_CORE_00361]. Um estado análogo a std::future_status::deferred não existe em FutureStatus [SWS_CORE_00361].

No que se refere à execução e às condições de contorno, estão definidas as seguintes diretrizes:

• Contexto de chamada e comportamento com exceções: a função está disponível por meio do arquivo de cabeçalho #include "ara/core/future.h", declarada como noexcept e especificada como segura contra exceções (exception safe) [SWS_CORE_06230].
• Estados de erro: se o Future for inválido, ou seja, quando valid() retornar o valor false, ocorre a violação FutureInvalidViolation [SWS_CORE_06230].
• Concorrência: a operação está classificada como não segura para threads (not thread-safe) [SWS_CORE_06230].