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 o bien un valor de éxito o bien un valor de error para la transmisión síncrona de resultados sin excepciones.
GENERADO POR IAno revisadoModelo: gemini-3.8-flash-medium · Esfuerzo: medium · Temperatura: no controlable · Prompt: 33e53dcae988ProcedenciaPreguntas abiertas (1)
traducido de la guía alemanagemini-3.8-flash-low · 2026-10-13 · Original en alemán
Encapsula o bien un valor de éxito o bien un valor de error para la transmisión síncrona de resultados sin excepciones.
La clase representa un contenedor con seguridad de tipos que aloja o bien un valor útil o bien un código de error, con el fin de transmitir resultados de cálculo de forma síncrona y sin excepciones de C++ [SWS_CORE_00751]. Los llamadores crean instancias mediante constructores dedicados o funciones factoría y, a continuación, evalúan el resultado en función del estado mediante funciones de comprobación y acceso, tales como el acceso al valor o al error. Como restricción fundamental, el tipo de error subyacente debe corresponder obligatoriamente al código de error estándar, ya que las asignaciones de tipos discrepantes se rechazan en tiempo de compilación. Además, las funciones para el desencadenamiento de excepciones requieren un entorno de compilador con excepciones de C++ habilitadas [SWS_CORE_00766].
Contexto
La clase ara::core::Result es la construcción central de AUTOSAR Adaptive Platform para la devolución síncrona y tipificada de resultados de operaciones sin el uso obligatorio de excepciones de C++. Representa una unión etiquetada (Tagged Union) que en cualquier momento contiene o bien un valor útil del tipo value_type (T) o bien un error del tipo error_type (E) [SWS_CORE_00711][SWS_CORE_00712]. Por defecto, ara::core::ErrorCode actúa como tipo para E; las implementaciones impiden definiciones de error discrepantes ya en tiempo de compilación mediante un error de compilación.
En la arquitectura de la aplicación, ara::core::Result media entre los servicios invocados y los consumidores. Los servicios instancian el objeto para devolver el estado, mientras que los consumidores inician un procesamiento posterior mediante pruebas de estado como [SWS_CORE_00751] o encadenamientos funcionales como [SWS_CORE_00768]. Además, el estado se puede transferir a ara::core::Optional mediante [SWS_CORE_00770] (Ok) y [SWS_CORE_00772] (Err).
ara::core::Result posee el dato contenido de forma exclusiva y gestiona su vida útil. Soporta semántica de valor completa mediante constructores de copia y movimiento ([SWS_CORE_00725], [SWS_CORE_00726]), así como los correspondientes operadores de asignación ([SWS_CORE_00741], [SWS_CORE_00742]). Un cambio de contenido de instancias existentes es posible mediante Swap[SWS_CORE_00745] o por sobrescritura in-place a través de EmplaceValue[SWS_CORE_00743] o bien EmplaceError[SWS_CORE_00744].
El destructor libera el elemento activo y se considera trivialmente destructible si tanto T como E son trivialmente destructibles [SWS_CORE_00727]. En cuanto a la concurrencia, los accesos puramente de lectura son seguros para hilos, mientras que las operaciones modificadoras como EmplaceValue, EmplaceError, asignaciones por movimiento o Swap no son seguras para hilos y requieren sincronización externa.
Comprobación de estado: el llamador comprueba mediante HasValue()[SWS_CORE_00751] o el operador de conversión explícito operator bool()[SWS_CORE_00752] si hay un valor presente. Este último está deshabilitado si T es en sí mismo del tipo bool.
Transformación funcional: como alternativa, Bind()[SWS_CORE_00768] permite un procesamiento posterior monádico: el invocable pasado solo se ejecuta si se contiene un valor útil; un error existente se propaga sin cambios a la nueva instancia de Result. Las alternativas de contingencia se pueden implementar con Resolve()[SWS_CORE_00767].
El acceso a estados no activos viola las precondiciones de la clase:
La llamada a Value(), operator* o operator-> sin un valor contenido desencadena la violación del sistema documentada ResultWithNoValueViolation ([SWS_CORE_00755], [SWS_CORE_00753], [SWS_CORE_00754]).
La llamada a Error() en presencia de un valor útil provoca la violación ResultWithNoErrorViolation ([SWS_CORE_00757], [SWS_CORE_00776]).
Interpretación: es probable que el desencadenamiento de tal violación de precondición dé lugar típicamente a la terminación inmediata del proceso en entornos de ejecución, ya que el estándar clasifica estos estados como errores graves de programación. Pregunta Q-15376f67084c4be6 (abierta) Para evitar terminaciones abruptas, se pueden utilizar métodos defensivos: ValueOr() ([SWS_CORE_00761], [SWS_CORE_00762]) y ErrorOr() ([SWS_CORE_00763], [SWS_CORE_00764]) devuelven un valor predeterminado especificado en caso de ausencia de elemento. Variantes opcionales como Ok() ([SWS_CORE_00770], [SWS_CORE_00771]) y Err() ([SWS_CORE_00772], [SWS_CORE_00773]) encapsulan el acceso sin excepciones.
Si se desea gestión de excepciones, ValueOrThrow() ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]) lanza en caso de error la excepción de C++ asignada al error. Si las excepciones de C++ están deshabilitadas en el compilador, ValueOrThrow() se elimina de la resolución de sobrecarga [SWS_CORE_00766]; del mismo modo, la sobrecarga lvalue no constante de operator* está deshabilitada en este caso [SWS_CORE_00774].
Esta guía fue generada por un asistente de curación por IA basándose en los requisitos de especificación de 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
GENERADO POR IAno revisadoModelo: gemini-3.8-flash-medium · Esfuerzo: medium · Temperatura: no controlable · Prompt: 38c9cb36d652ProcedenciaPreguntas abiertas (1)
traducido de la guía alemanagemini-3.8-flash-low · 2026-10-13 · Original en alemán
Uso y llamada
La función miembro síncrona ValueOrThrow de la clase ara::core::Result ([SWS_CORE_00766]) se incluye mediante la cabecera ara/core/result.h ([SWS_CORE_00766]). Se invoca sin parámetros sobre una instancia lvalue constante y devuelve una referencia constante (const T &) al valor almacenado en el objeto ([SWS_CORE_00766]).
Tratamiento de errores y comportamiento ante excepciones
Si la instancia de Result no contiene un valor, sino un estado de error, la función lanza la excepción de C++ asignada al error ([SWS_CORE_00766]). La especificación clasifica la función como no segura ante excepciones (not exception safe) ([SWS_CORE_00766]); Interpretación: Es probable que esta clasificación se deba a que, en caso de error, se desencadena una excepción conforme a lo previsto. Pregunta Q-0f4ebba70af6e48c (abierta)
Concurrencia y restricciones
La operación está especificada como segura para hilos (thread-safe) ([SWS_CORE_00766]). Como condición marco esencial se aplica: si las excepciones de C++ están desactivadas en la cadena de herramientas del compilador, esta función no participa en la resolución de sobrecargas (overload resolution) ([SWS_CORE_00766]).
Interacción en el framework Result
La función complementa sobrecargas y especializaciones afines dentro de ara::core::Result:
Para lvalues modificables existe la variante con retorno de T & ([SWS_CORE_00778]).
Para instancias rvalue está disponible la sobrecarga de movimiento con retorno de T && ([SWS_CORE_00769]).
Para resultados de void existe la especialización ara::core::Result<void, E> sin valor de retorno ([SWS_CORE_00866]).
Para tipos de referencia ara::core::Result<T &, E> se encuentran disponibles las correspondientes sobrecargas de referencia constantes y no constantes ([SWS_CORE_00938], [SWS_CORE_00949]).
Esta nota de uso se ha generado de forma automatizada y sirve como guía orientativa. Tienen carácter vinculante exclusivamente las especificaciones de AUTOSAR.
GENERADO POR IAno revisadoModelo: gemini-3.8-flash-medium · Esfuerzo: medium · Temperatura: no controlable · Prompt: bf00696cade5Procedencia
traducido de la guía alemanagemini-3.8-flash-low · 2026-10-13 · Original en alemán
La función miembro ValueOrThrow() && se proporciona a través de la cabecera #include "ara/core/result.h" y sirve para el acceso síncrono al valor encapsulado en una instancia de ara::core::Result ([SWS_CORE_00769]). Mediante la calificación rvalue (&&), la función se invoca sobre objetos rvalue y devuelve una referencia rvalue (T &&) al valor contenido [SWS_CORE_00769].
Tratamiento de errores y condiciones límite
Si el objeto Result contiene un valor de error, el método lanza el tipo de excepción asignado al error ([SWS_CORE_00769]). La especificación clasifica la ejecución como no segura ante excepciones (not exception safe), pero la define expresamente como segura para subprocesos (thread-safe) [SWS_CORE_00769]. Una directriz vinculante concierne a la cadena de herramientas: si las excepciones de C++ están desactivadas en el compilador, la función no debe participar en ningún caso en la resolución de sobrecargas [SWS_CORE_00769].
Interacción en el conjunto de sobrecargas
El método [SWS_CORE_00769] forma parte de un conjunto coordinado de sobrecargas para ValueOrThrow dentro de ara::core::Result:
Para lvalues están disponibles la sobrecarga constante [SWS_CORE_00766] (retorno: const T &) y la variante no constante [SWS_CORE_00778] (retorno: T &).
Para resultados void, la especialización ara::core::Result<void, E> ofrece la función [SWS_CORE_00866] sin valor de retorno.
Para tipos de referencia, ara::core::Result<T &, E> cubre retornos de referencia correspondientes con [SWS_CORE_00938] (constante) y [SWS_CORE_00949] (no constante).
Esta nota de uso se ha generado de forma automatizada sobre la base de la especificación AUTOSAR Adaptive R25-11.
Return a reference to the contained value or throw an exception.
GENERADO POR IAno revisadoModelo: gemini-3.8-flash-medium · Esfuerzo: medium · Temperatura: no controlable · Prompt: ddfa99362222ProcedenciaPreguntas abiertas (1)
traducido de la guía alemanagemini-3.8-flash-low · 2026-10-13 · Original en alemán
usar
La función miembro ValueOrThrow[SWS_CORE_00778] de la clase ara::core::Result (cabecera #include "ara/core/result.h") permite el acceso síncrono al valor contenido. Dado que la firma de la función cuenta con el calificador de referencia &, solo se puede invocar en instancias lvalue no constantes. No espera parámetros de entrada y devuelve una referencia modificable (T&) al valor encapsulado.
Tratamiento de errores y condiciones límite
Si el objeto no contiene un valor, sino un error, ValueOrThrow lanza de forma síncrona la excepción asociada al error (noexcept(false)) [SWS_CORE_00778]. La función está especificada como not exception safe[SWS_CORE_00778]; interpretación: esto indicaría presumiblemente que, al ocurrir un error, el flujo de control se interrumpe por el lanzamiento de la excepción y no se otorgan garantías adicionales de recuperación o reversión. Pregunta Q-11aed84264f3411f (abierta) Si las excepciones de C++ están desactivadas en la cadena de herramientas del compilador, la función obligatoriamente no participa en la resolución de sobrecargas [SWS_CORE_00778]. En cuanto a la concurrencia, la ejecución se indica como thread-safe [SWS_CORE_00778].
Interacción
La función forma parte de una familia de sobrecargas para el acceso al valor en ara::core::Result:
Para instancias constantes, se encuentra disponible la sobrecarga con retorno de const T&[SWS_CORE_00766].
Para objetos rvalue, existe una variante con semántica de movimiento que proporciona T&&[SWS_CORE_00769].
Para especializaciones con tipos de referencia (Result<T&, E>), están disponibles sobrecargas correspondientes para referencias modificables [SWS_CORE_00949], así como referencias constantes [SWS_CORE_00938].
En instancias sin valor (Result<void, E>), el método comprueba únicamente la presencia de un error y, en su caso, lanza la excepción [SWS_CORE_00866].
Este texto ha sido generado por un sistema de IA y se basa en la especificación AUTOSAR Adaptive Release R25-11.
gemini-3.8-flash-low· 2026-10-13 · Original en alemán