class ara::core::FutureErrorDomain

The default constructor FutureErrorDomain() initializes an instance of the error domain ara::core::FutureErrorDomain synchronously and without input parameters [SWS_CORE_00441]. Since the function is declared as constexpr and noexcept, it provides complete exception safety and can already be evaluated at compile time [SWS_CORE_00441].

Regarding execution and error handling, the following conditions apply:

• The initialization is thread-safe and throws no exceptions [SWS_CORE_00441]. No specific error codes or notifications to diagnostic or error managers are provided.
• The resulting instance provides elementary methods of the domain, namely Name() for the domain name [SWS_CORE_00442], Message() for translating error codes into readable text [SWS_CORE_00443], as well as ThrowAsException() for throwing associated exceptions [SWS_CORE_00444]. Within the class scope, the type aliases Errc [SWS_CORE_00431] and Exception [SWS_CORE_00432] also exist.

In the interface structure, function GetFutureErrorDomain() provides a reference to the central global singleton instance [SWS_CORE_00480]. Direct manual instantiation via constructor [SWS_CORE_00441] in application scenarios is therefore likely to serve primarily for internal provisioning of this instance or special test purposes. Question Q-4b2f868ccb8a5487 (open) Specific error codes for this domain are created via MakeErrorCode() using enumeration FutureErrc [SWS_CORE_00490].

use

The member function Message of class ara::core::FutureErrorDomain serves to synchronously translate a numeric error code into a descriptive text message [SWS_CORE_00443]. The function is provided via the header file #include "ara/core/future_error_domain.h". As an input parameter, it takes errorCode of type ErrorDomain::CodeType. The return value is a pointer to a null-terminated character string (const char *) with the text message, which according to the specification is never nullptr [SWS_CORE_00443].

Concurrency and Limitations

The function is qualified as noexcept and specified as thread-safe and exception safe [SWS_CORE_00443]. It can therefore be safely called from concurrent threads without external synchronization. According to the requirements of the base class ara::core::ErrorDomain, the returned pointer permanently remains in the ownership of the respective subclass and must under no circumstances be released manually by the caller [SWS_CORE_00153].

Error Handling and Interaction

Message overrides the pure virtual base method Message of the abstract base class ara::core::ErrorDomain [SWS_CORE_00153], analogously to the implementation in other error domains such as ara::core::CoreErrorDomain [SWS_CORE_05243]. If the passed code does not originate from this domain, this constitutes a violation according to the base interface (WrongDomainOfAnErrorCodeViolation) [SWS_CORE_00153]. In typical usage scenarios, developers are likely to rarely call this method directly on the domain, since error messages are usually retrieved via the method Message of the object ara::core::ErrorCode [SWS_CORE_00518]. Question Q-a083e0ab17abf079 (open)

The synchronous member function Name() of class ara::core::FutureErrorDomain is included via the header ara/core/future_error_domain.h [SWS_CORE_00442]. It takes no parameters and returns the name of the error domain as a pointer to a constant character string (const char *) [SWS_CORE_00442].

Regarding error handling and execution safety, the method is declared as noexcept and specified as exception safe [SWS_CORE_00442]. Neither are C++ exceptions thrown, nor are error conditions reported to DET or DEM.

Regarding concurrency, the function is unconditionally thread-safe and may be called concurrently from multiple contexts [SWS_CORE_00442]. Since it overrides the pure virtual interface ara::core::ErrorDomain::Name() [SWS_CORE_00152], its lifetime and ownership rules apply: The returned pointer remains the property of the error domain and must under no circumstances be deallocated by the caller [SWS_CORE_00152]. The returned string is null-terminated and guaranteed never to be nullptr [SWS_CORE_00152].

In interaction with the overall system, the method acts as a domain-specific manifestation of the general error domain interface [SWS_CORE_00152], comparable to the implementation in other domains such as ara::core::CoreErrorDomain [SWS_CORE_05242]. Interpretation: Since the caller must not manage the memory, the pointer presumably points to a static string literal whose validity spans the entire program execution time. Question Q-e1867dfe78e89540 (open)

The member function ara::core::FutureErrorDomain::ThrowAsException converts a passed instance of ErrorCode synchronously into an exception and throws it as FutureException [SWS_CORE_00444]. The thrown exception encapsulates the passed error code [SWS_CORE_00444]. The class thus implements the pure virtual interface ThrowAsException of the base class ara::core::ErrorDomain [SWS_CORE_00154].

With regard to execution and constraints, the following specifications apply:

• Invocation and parameters: The function expects as an input parameter a reference to a ErrorCode object (errorCode) and has no return value, as it terminates the control flow by throwing the exception [SWS_CORE_00444].
• Error behavior and exception safety: The function is declared with noexcept(false) and classified as not exception safe [SWS_CORE_00444]. When called, the specified FutureException is always thrown [SWS_CORE_00444].
• Concurrency: The implementation is classified as thread-safe and can thus be safely called from parallel execution contexts [SWS_CORE_00444].
• Compiler restriction: If C++ exceptions are disabled in the compiler toolchain, this function must not participate in overload resolution [SWS_CORE_00444].

In interaction with the error system of Adaptive AUTOSAR, this function corresponds directly to ara::core::ErrorCode::ThrowAsException, whose behavior is defined as forwarding to the associated domain (this->Domain().ThrowAsException(*this)) [SWS_CORE_00519]. It thus corresponds to the domain-specific implementations in other domains such as ara::core::CoreErrorDomain::ThrowAsException, which throws a CoreException instead [SWS_CORE_05244].