class ara::fw::FwException

The class ara::fw::FwException represents the specialized C++ exception type for the Firewall API of the AUTOSAR Adaptive Platform and derives from ara::core::Exception. It serves to encapsulate and transport an ara::core::ErrorCode in order to transmit severe error conditions to calling components [AP_SWS_Fw_83005]. Instantiation takes place via header ara/fw/fw_error_domain.h by means of an explicit constructor declared as noexcept [AP_SWS_Fw_83005]. As a central boundary condition, the class ensures thread-safe construction so that errors can also be reliably signaled in concurrent execution contexts.

more ›

Context

The class ara::fw::FwException represents the dedicated C++ exception type for the Firewall interface (Firewall API) of the AUTOSAR Adaptive Platform. According to its interface definition, it publicly inherits from the base class ara::core::Exception. Within the architecture of module fw, it serves to encapsulate error situations occurring during execution in the form of an exception and to propagate them across call boundaries to higher-level functional layers. The class and its constructor are declared via header ara/fw/fw_error_domain.h [AP_SWS_Fw_83005]. The type ara::core::ErrorCode acts as the central interaction partner, mapping the specific error context and the error domain of the Firewall.

Lifecycle

The lifecycle of an instance of ara::fw::FwException begins with explicit initialization by passing a ara::core::ErrorCode object to the constructor [AP_SWS_Fw_83005]. Because the constructor is declared as explicit, implicit type conversions from error codes are prevented [AP_SWS_Fw_83005]. Through the designation with noexcept, it is guaranteed that the creation of the exception object itself never fails or triggers secondary exceptions at any time [AP_SWS_Fw_83005]. In addition, the standard explicitly specifies the construction as thread-safe (thread-safe) [AP_SWS_Fw_83005], whereby exception instances may also be created in concurrent execution contexts of the Adaptive application without additional synchronization. Destruction of the object occurs automatically at the end of the respective handling block after catching the exception according to standard C++ rules.

Usage Path

A typical usage path describes detecting an internal error within the Firewall API, encapsulating the cause, and subsequently handling it at application level. Because Adaptive AUTOSAR primarily relies on value-based error handling via result objects, ara::fw::FwException is presumably thrown above all when a severe exceptional case is present or APIs are invoked on an exception basis. Question Q-4a8d1c1d5359c469 (open)

Sequence diagram: Typical sequence of error handling and exception handling with FwException. Sources: [AP_SWS_Fw_83005] AP_SWS_Fw_83005

The typical sequence proceeds in the following steps:

• Detection of the error: A service of the Firewall API identifies an invalid operation and creates a corresponding ara::core::ErrorCode object.
• Creation of the exception: Via constructor [AP_SWS_Fw_83005], a new instance of ara::fw::FwException is thread-safely instantiated with this error code.
• Triggering the exception: The exception is signaled into the execution context using throw.
• Catching and evaluation: The calling application catches ara::fw::FwException and reads out the contained error code for error analysis or recovery.

Error Scenarios

Error scenarios when using ara::fw::FwException primarily concern the logical validity of the passed error data and the absence of proper exception handling. Because the construction of the exception class is specified as noexcept, no internal error sources exist during the instantiation itself [AP_SWS_Fw_83005]. As a precondition, the calling site must ensure that a semantically accurate ara::core::ErrorCode is passed that adequately describes the occurred Firewall error cause [AP_SWS_Fw_83005]. If a thrown ara::fw::FwException is not caught by any matching handler further down the call stack, this inevitably leads to a call to std::terminate and thus to process termination according to standard C++ semantics.