template <typename T, typename E = ErrorCode> class Result final {...};
This class is a type that contains either a value or an error. The implementation shall flag the condition E != ara::core::ErrorCode as a compile error.
Encapsula um valor de sucesso ou um valor de erro para a transmissão síncrona de resultados sem exceções.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: 33e53dcae988ProcedênciaPerguntas em aberto (1)
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
Encapsula um valor de sucesso ou um valor de erro para a transmissão síncrona de resultados sem exceções.
A classe representa um contentor com segurança de tipos que recebe um valor útil ou um código de erro para transmitir resultados de cálculo de forma síncrona e sem exceções de C++ [SWS_CORE_00751]. Os chamadores criam instâncias através de construtores dedicados ou funções de fábrica e, em seguida, avaliam o resultado em função do estado, através de funções de verificação e de acesso, tais como o acesso ao valor ou ao erro. Como condição de contorno essencial, o tipo de erro subjacente tem de corresponder obrigatoriamente ao código de erro padrão, uma vez que atribuições de tipos divergentes são rejeitadas em tempo de compilação. Além disso, funções para lançamento de exceções pressupõem um ambiente de compilador com exceções de C++ ativadas [SWS_CORE_00766].
Contexto
A classe ara::core::Result é a construção central da AUTOSAR Adaptive Platform para o retorno síncrono e tipificado de resultados de operações sem utilização obrigatória de exceções de C++. Representa uma união disjunta (Tagged Union) que, em qualquer momento, contém ou um valor útil do tipo value_type (T) ou um erro do tipo error_type (E) [SWS_CORE_00711][SWS_CORE_00712]. Por padrão, ara::core::ErrorCode atua como tipo para E; definições de erro divergentes são impedidas pelas implementações logo em tempo de compilação através de um erro de compilação.
Na arquitetura da aplicação, ara::core::Result faz a mediação entre serviços chamados e consumidores. Os serviços instanciam o objeto para retornar o estado, enquanto os consumidores despoletam o processamento posterior através de testes de estado como [SWS_CORE_00751] ou encadeamentos funcionais como [SWS_CORE_00768]. Além disso, o estado pode ser convertido para ara::core::Optional através de [SWS_CORE_00770] (Ok) e [SWS_CORE_00772] (Err).
ara::core::Result detém o dado contido em exclusivo e gere o seu ciclo de vida. Suporta semântica de valor completa através de construtores por cópia e por movimentação ([SWS_CORE_00725], [SWS_CORE_00726]), bem como operadores de atribuição correspondentes ([SWS_CORE_00741], [SWS_CORE_00742]). Uma alteração de conteúdo de instâncias existentes é possível mediante Swap[SWS_CORE_00745] ou por sobrescrita in-place via EmplaceValue[SWS_CORE_00743] ou EmplaceError[SWS_CORE_00744].
O destrutor liberta o elemento ativo e é considerado trivialmente destrutível se tanto T como E forem trivialmente destrutíveis [SWS_CORE_00727]. No que diz respeito à concorrência, acessos puramente de leitura são seguros para threads, enquanto operações modificadoras como EmplaceValue, EmplaceError, atribuições por movimentação ou Swap não são seguras para threads e requerem sincronização externa.
Verificação de estado: O chamador verifica se existe um valor presente mediante HasValue()[SWS_CORE_00751] ou o operador de conversão explícito operator bool()[SWS_CORE_00752]. Este último está desativado quando T é ele próprio do tipo bool.
Transformação funcional: Em alternativa, Bind()[SWS_CORE_00768] permite um processamento monádico: o invocável (callable) passado só é executado se estiver contido um valor útil; um erro existente é propagado inalterado para a nova instância Result. Alternativas de contingência (fallbacks) podem ser mapeadas com Resolve()[SWS_CORE_00767].
O acesso a estados não ativos viola as pré-condições da classe:
A chamada de Value(), operator* ou operator-> sem valor contido desencadeia a violação de sistema documentada ResultWithNoValueViolation ([SWS_CORE_00755], [SWS_CORE_00753], [SWS_CORE_00754]).
A chamada de Error() na presença de um valor útil conduz à violação ResultWithNoErrorViolation ([SWS_CORE_00757], [SWS_CORE_00776]).
Interpretação: O desencadeamento de tal violação de pré-condição deverá tipicamente resultar na interrupção imediata do processo em ambientes de execução, uma vez que a norma classifica estes estados como erros graves de programação. Para evitar interrupções abruptas, podem ser utilizados métodos defensivos: ValueOr() ([SWS_CORE_00761], [SWS_CORE_00762]) e ErrorOr() ([SWS_CORE_00763], [SWS_CORE_00764]) devolvem um valor predefinido especificado na ausência do elemento. Variantes opcionais como Ok() ([SWS_CORE_00770], [SWS_CORE_00771]) e Err() ([SWS_CORE_00772], [SWS_CORE_00773]) encapsulam o acesso sem recurso a exceções. Pergunta Q-15376f67084c4be6 (aberta)
Se for desejado o tratamento de exceções, ValueOrThrow() ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]) lança em caso de erro a exceção de C++ associada ao erro. Se as exceções de C++ estiverem desativadas no compilador, ValueOrThrow() é removido da resolução de sobrecargas [SWS_CORE_00766]; do mesmo modo, a sobrecarga de lvalue não constante de operator* fica desativada nesse caso [SWS_CORE_00774].
Este guia foi gerado por um assistente de curadoria de IA com base nos requisitos de especificação da AUTOSAR Adaptive R25-11.
Return the contained value or the given default value. If *this contains a value, it is returned. Otherwise, the specified default value is returned, static_cast’d to T
Return the contained error or the given default error. If *this contains an error, it is returned. Otherwise, the specified default error is returned, static_cast’d to E
Apply the given Callable to the value of this instance, and return a new ara::core:: Result with the result of the call.
The Callable is expected to be compatible to one of these two interfaces: • Result<XXX, E> f(const T&); • <ARTechTerm{XXX f(const T&);}> • <ARNewline{}> • <ARNewline{}> • <ARTechTerm{Callable}> • Result<XXX> or a XXX directly, where XXX can be any type that is suitable for use by ara::core::Result.
The return type of this function is decltype(f(Value())) for a template argument F that returns a ara::core::Result type, and it is Result<decltype(f(Value())), E> for a template argument F that does not return a ara::core::Result type.
If this instance does not contain a value, a new Result<XXX, E> is still created and returned, with the original error contents of this instance being copied into the new instance.}>}
Return the contained error or the given default error. If *this contains an error, it is returned. Otherwise, the specified default error is returned, static_cast’d to E
Return the contained error or the given default error. If *this contains an error, it is std:: move’d into the return value. Otherwise, the specified default error is returned, static_cast’d to E
Build a new ara::core::Result from an error that is constructed in-place from the given arguments. This function shall not participate in overload resolution unless: • std::is_constructible<E, Args&&...>::value == true and • the first type of the expanded parameter pack is not E and • the first type of the expanded parameter pack is not a specialization of ara::core::Result
Build a new ara::core::Result from a value that is constructed in-place from the given arguments. This function shall not participate in overload resolution unless: • std::is_constructible<T, Args&&...>::value == true and • the first type of the expanded parameter pack is not T and • the first type of the expanded parameter pack is not a specialization of ara::core::Result
Return the contained value or return the result of a function call.
If *this contains a value, it is returned. Otherwise, the specified callable is invoked and its return value which is to be compatible to type T is returned from this function.
The Callable is expected to be compatible to this interface: T f(const E&);
Return the contained value or the given default value. If *this contains a value, it is returned. Otherwise, the specified default value is returned, static_cast’d to T
Return the contained value or the given default value. If *this contains a value, it is returned. Otherwise, the specified default value is returned, static_cast’d to T
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: 38c9cb36d652ProcedênciaPerguntas em aberto (1)
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
Uso e chamada
A função-membro síncrona ValueOrThrow da classe ara::core::Result ([SWS_CORE_00766]) é incluída através do cabeçalho ara/core/result.h ([SWS_CORE_00766]). É chamada sem parâmetros numa instância lvalue constante e devolve uma referência constante (const T &) para o valor armazenado no objeto ([SWS_CORE_00766]).
Tratamento de erros e comportamento de exceções
Se a instância Result não contiver um valor, mas sim um estado de erro, a função lança a exceção C++ associada ao erro ([SWS_CORE_00766]). A especificação classifica a função como não segura quanto a exceções (not exception safe) ([SWS_CORE_00766]); Interpretação: esta classificação deverá dever-se ao facto de, em caso de erro, ser lançada uma exceção conforme previsto. Pergunta Q-0f4ebba70af6e48c (aberta)
Simultaneidade e restrições
A operação está especificada como segura para threads (thread-safe) ([SWS_CORE_00766]). Como condição de contorno essencial: se as exceções C++ estiverem desativadas na toolchain do compilador, esta função não participa na resolução de sobrecargas (overload resolution) ([SWS_CORE_00766]).
Interação no framework de Result
A função complementa sobrecargas e especializações relacionadas dentro de ara::core::Result:
Para lvalues modificáveis, existe a variante com retorno de T & ([SWS_CORE_00778]).
Para instâncias rvalue, está disponível a sobrecarga de movimento com retorno de T && ([SWS_CORE_00769]).
Para resultados void, existe a especialização ara::core::Result<void, E> sem valor de retorno ([SWS_CORE_00866]).
Para tipos de referência ara::core::Result<T &, E>, estão disponíveis sobrecargas correspondentes de referência constante e não constante ([SWS_CORE_00938], [SWS_CORE_00949]).
Esta nota de utilização foi gerada automaticamente e serve como orientação. Apenas as especificações da AUTOSAR são vinculativas.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: bf00696cade5Procedência
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
A função-membro ValueOrThrow() && é disponibilizada através do cabeçalho #include "ara/core/result.h" e serve para o acesso síncrono ao valor encapsulado numa instância de ara::core::Result ([SWS_CORE_00769]). Através da qualificação rvalue (&&), a função é chamada em objetos rvalue e devolve uma referência rvalue (T &&) para o valor contido [SWS_CORE_00769].
Tratamento de erros e condições de contorno
Se o objeto Result contiver um valor de erro, o método lança o tipo de exceção associado ao erro ([SWS_CORE_00769]). A especificação classifica a execução como não segura contra exceções (not exception safe), mas define-a expressamente como segura para threads (thread-safe) [SWS_CORE_00769]. Uma diretriz vinculativa diz respeito à toolchain: se as exceções C++ estiverem desativadas no compilador, a função não pode de modo algum participar na resolução de sobrecarga [SWS_CORE_00769].
Interação no conjunto de sobrecargas
O método [SWS_CORE_00769] faz parte de um conjunto coordenado de sobrecargas para ValueOrThrow dentro de ara::core::Result:
Para lvalues, estão disponíveis a sobrecarga constante [SWS_CORE_00766] (retorno: const T &) e a variante não constante [SWS_CORE_00778] (retorno: T &).
Para resultados void, a especialização ara::core::Result<void, E> oferece a função [SWS_CORE_00866] sem valor de retorno.
Para tipos de referência, ara::core::Result<T &, E> cobre os retornos de referência correspondentes com [SWS_CORE_00938] (constante) e [SWS_CORE_00949] (não constante).
Esta nota de utilização foi gerada de forma automatizada com base na especificação AUTOSAR Adaptive R25-11.
Return a reference to the contained value or throw an exception.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: ddfa99362222ProcedênciaPerguntas em aberto (1)
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
usar
A função-membro ValueOrThrow[SWS_CORE_00778] da classe ara::core::Result (cabeçalho #include "ara/core/result.h") permite o acesso síncrono ao valor contido. Dado que a assinatura da função está provida do qualificador de referência &, esta só pode ser chamada em instâncias lvalue não constantes. Não espera parâmetros de entrada e devolve uma referência modificável (T&) para o valor encapsulado.
Tratamento de erros e condições de contorno
Se o objeto não contiver um valor, mas sim um erro, ValueOrThrow lança sincronamente a exceção associada ao erro (noexcept(false)) [SWS_CORE_00778]. A função está especificada como not exception safe[SWS_CORE_00778]; Interpretação: Isto deverá significar que, mediante a ocorrência de um erro, o fluxo de controlo é interrompido pelo lançamento da exceção e não são concedidas quaisquer garantias adicionais de recuperação ou de rollback. Pergunta Q-11aed84264f3411f (aberta) Caso as exceções C++ estejam desativadas na toolchain do compilador, a função não participa obrigatoriamente na resolução de sobrecarga [SWS_CORE_00778]. No que diz respeito à concorrência, a execução está identificada como thread-safe [SWS_CORE_00778].
Interação
A função faz parte de uma família de sobrecargas para o acesso a valores em ara::core::Result:
Para instâncias constantes, está disponível a sobrecarga com retorno de const T&[SWS_CORE_00766].
Para objetos rvalue, existe uma variante com semântica de movimentação que fornece T&&[SWS_CORE_00769].
Para especializações com tipos de referência (Result<T&, E>), estão disponíveis sobrecargas correspondentes para referências modificáveis [SWS_CORE_00949] bem como referências constantes [SWS_CORE_00938].
Em instâncias sem valor (Result<void, E>), o método apenas verifica a existência de um erro e lança a exceção se aplicável [SWS_CORE_00866].
Este texto foi gerado por um sistema de IA e baseia-se na especificação AUTOSAR Adaptive Release R25-11.
gemini-3.8-flash-low· 2026-10-13 · Original em alemão