class ara::core::Optional< T & >

The member access operator operator-> of template class ara::core::Optional<T &> serves for synchronous access to members of the referenced object [SWS_CORE_01167]. The function is defined in header #include "ara/core/optional.h", belongs to the scope of ara::core::Optional<T &>, and expects no parameters [SWS_CORE_01167]. The return value provided is a pointer of type T const *, enabling direct read access to the underlying target object [SWS_CORE_01167]. The return type thus corresponds to a pointer to constant data, which prevents modifying accesses via this operator.

Regarding error handling, the method is declared as noexcept and classified as exception safe [SWS_CORE_01167]. However, if the instance does not contain a value (If *this does not contain a value), the specification documents a IsoStdBadOptionalAccessViolation as a violation [SWS_CORE_01167]. Consequently, before dereferencing, the using software must ensure that the optional reference is validly engaged in order to reliably avoid error states at runtime.

For concurrency and calling context, the specification mentions no special protection mechanisms; presumably, the const operation provides no internal synchronization against concurrent modifications [SWS_CORE_01167]. Question Q-0ebf3ed1284fc0c1 (open) The general behavior follows the corresponding usage of the C++ standard for optional types (As per corresponding usage in [optional]) [SWS_CORE_01167].

The overload operator operator-> of specialization ara::core::Optional<T &> enables synchronous member access to the encapsulated reference ([SWS_CORE_01168]). The function is provided via header file ara/core/optional.h and requires no invocation parameters. When called, it returns a pointer of type T * to the referenced target object, allowing members of the instance to be addressed directly ([SWS_CORE_01168]). The semantics correspond to the use of [optional] in the C++ standard ([SWS_CORE_01168]).

With respect to exception safety, the operator is declared as noexcept and classified as exception-safe (\u201cexception safe\u201d) ([SWS_CORE_01168]). If the instance contains no value (*this does not contain a value), this constitutes an access violation of category IsoStdBadOptionalAccessViolation ([SWS_CORE_01168]). Interpretation: Because the signature is declared with noexcept, this invalid state is presumably not handled by throwing a regular C++ exception, but rather leads to standardized error handling or program termination. Question Q-c3ef91b84a00cae8 (open)

As a call condition, the developer must ensure prior to execution that the Optional object actually contains a value. Unchecked access without prior inspection of the occupancy status violates the precondition of the operator ([SWS_CORE_01168]).

The template member function emplace of specialization ara::core::Optional<T&> serves to assign or set a reference in an optional container ([SWS_CORE_01164]). The function is defined via the header file #include "ara/core/optional.h" ([SWS_CORE_01164]).

Usage and Semantics

The call is synchronous and accepts a forwarding reference u of type U&& (defaulting to U = T) as a parameter ([SWS_CORE_01164]). Interpretation: The argument u is likely rebound to the reference held in Optional without constructing a new object. Question Q-55c9eca385e9e496 (open) As a return value, emplace returns an lvalue reference to the instance of Optional itself (Optional &), which enables operation chaining ([SWS_CORE_01164]). Due to declaration as constexpr, the call can also be evaluated in constant expressions at compile time ([SWS_CORE_01164]).

Error Handling and Exception Safety

The operation is declared as noexcept and has the classification exception safe ([SWS_CORE_01164]). Specific error codes, DET or DEM notifications are not provided in the specification excerpt; failure due to C++ exceptions is excluded ([SWS_CORE_01164]).

Interaction and Distinction

In contrast to the primary template variants of ara::core::Optional<T> for value types, which construct the contained object in-place, return a reference T&, and are only conditionally exception-safe (conditionally exception safe) or conditionally noexcept ([SWS_CORE_01119], [SWS_CORE_01120]), this overload for Optional<T&> guarantees strict exception freedom ([SWS_CORE_01164]). Other containers in the module such as ara::core::Vector ([SWS_CORE_01366]), ara::core::Map ([SWS_CORE_01458]), or ara::core::Variant ([SWS_CORE_01661]) also provide emplace methods, but have independent semantics and differing safety levels.

The member function reset of specialization ara::core::Optional<T&> serves according to [SWS_CORE_01165] to reset an optional reference object. It is declared via header #include "ara/core/optional.h", takes no parameters, and has no return value (void). As a constexpr function, it can also be used in compile-time evaluations; its execution occurs synchronously. Interpretation: According to the general reference to usage in [optional], the call presumably sets the instance into a state without a bound reference (disengaged), so that the object thereafter contains no value. Question Q-edf521c7744139d2 (open)

Regarding error handling, according to [SWS_CORE_01165] the function is provided with the identifier noexcept and classified as exception-safe ("exception safe"). A call thus throws no exceptions and reports no error codes; specific DET or DEM messages are not provided in the payload for this function.

In the module context, this implementation differs from the general template class ara::core::Optional according to [SWS_CORE_01136], whose reset method is not declared as constexpr. Other reset functions in the module exist for ara::core::Bitset, where reset() according to [SWS_CORE_01727] returns a reference to the object or with position specification according to [SWS_CORE_01728] returns a ara::core::Result and throws IsoStdOutOfRangeViolation for an invalid index.

The member function value_or of the specialization ara::core::Optional<T&> is provided via the header file #include "ara/core/optional.h" [SWS_CORE_01175]. As a template function, it takes a parameter U&& u as a fallback value and synchronously returns a result value of type T. Interpretation: According to the specification statement "As per corresponding usage in [optional]", the function is likely to return the value held by the reference if the object is engaged, and otherwise the fallback value u. Question Q-c050380198abf06b (open)

For error handling, the specification guarantees complete exception safety (exception safe) and declares the method as noexcept [SWS_CORE_01175]. Neither error codes nor notifications to error or diagnostic monitors are provided for this operation. Since the member function is additionally qualified as constexpr as well as const, it can also be evaluated in constant expressions at compile time without modifying the object [SWS_CORE_01175].

In the context of module core, the function is closely related to the general overloads for non-reference types. While [SWS_CORE_01175] is declared as exception safe for ara::core::Optional<T&>, the specification classifies the corresponding variants of the primary template ara::core::Optional—both the const lvalue overload [SWS_CORE_01134] and the rvalue overload [SWS_CORE_01135]—as not exception safe in each case.