class ara::core::Optional

use

The constructor function [SWS_CORE_01109] of class ara::core::Optional is provided via header #include "ara/core/optional.h". As a template constructor with signature template <typename U = T> constexpr Optional(U&&), it serves to directly initialize an optional value while forwarding the argument of type U&& to the contained value type T ([SWS_CORE_01102]). The semantics follow the definition in [optional], but deviate through an explicit condition for exception freedom: The function is specified as noexcept if and only if std::is_nothrow_constructible<T, U>::value is satisfied ([SWS_CORE_01109]).

Error Handling and Exception Safety

With respect to exception safety, the call is classified as conditionally exception safe ([SWS_CORE_01109]). Specific AUTOSAR error codes and reporting channels via DET or DEM do not exist for this constructor; if construction of the target type T fails, the corresponding exception of the type is forwarded.

Interaction and Concurrency

The function stands alongside the default constructor [SWS_CORE_01103] and the null constructor [SWS_CORE_01104], which create empty instances, as well as the copy and move constructors [SWS_CORE_01105] and [SWS_CORE_01106]. Furthermore, ara::core::Optional serves as a carrier for optional return values in the error handling of ara::core::Result, for example when retrieving values via Ok() ([SWS_CORE_00770]) or errors via Err() ([SWS_CORE_00772]). Interpretation: In the absence of explicit thread-safety commitments in [SWS_CORE_01109], concurrent invocation of the constructor is likely safe only if the source object U is protected against simultaneous modifications. Question Q-edf541fe968f3afe (open)

use

The converting copy constructor of ara::core::Optional is available via header file #include "ara/core/optional.h" [SWS_CORE_01110]. It serves to synchronously create a Optional<T> from an existing instance const Optional<U>&. The specification tag {<cond-explicit-2>} likely indicates that the constructor is declared as explicit provided that T cannot be constructed implicitly from const U&. Question Q-4a4adc2b59d1fa53 (open)

Error Handling and Exception Safety

No specific error codes, DET, or DEM notifications exist for this constructor. The function is classified as conditionally exception-safe (conditionally exception safe) [SWS_CORE_01110]. The noexcept guarantee takes effect via noexcept(std::is_nothrow_constructible<T, const U&>::value) exclusively when the target type T is constructible without exceptions from const U& [SWS_CORE_01110]. If creation of the target value fails, exceptions propagate unchanged.

Concurrency and Limitations

In contrast to other functions such as Ok() [SWS_CORE_00770], the specification does not identify thread safety for this constructor. While it is likely reentrant, concurrent read or write access to the source object Optional<U> requires external synchronization. Question Q-a0534498f685f575 (open)

Interaction

The constructor complements the other initialization functions of ara::core::Optional, including default, null, and copy constructors ([SWS_CORE_01103], [SWS_CORE_01104], [SWS_CORE_01105], [SWS_CORE_01106]) as well as the swap operation [SWS_CORE_01096]. In addition, the type interacts closely with ara::core::Result, whose methods Ok() and Err() expose values or errors as Optional ([SWS_CORE_00770], [SWS_CORE_00772]).

The template function [SWS_CORE_01111] provides the converting move constructor of class ara::core::Optional from header file #include "ara/core/optional.h". It accepts an rvalue reference Optional<U>&& to initialize an instance of Optional<T> and follows the behavior of [optional] with the documented deviation of a conditional noexcept specification [SWS_CORE_01111]. Specification clause {<cond-explicit-3>}, as an interpretation, is likely to control whether the conversion occurs implicitly or explicitly depending on the properties of types T and U. Question Q-0b21a6eafb9414d8 (open)

With respect to error handling and exception handling, the constructor is classified as conditionally exception-safe (conditionally exception safe) [SWS_CORE_01111]. Execution is noexcept if and only if std::is_nothrow_constructible<T, U>::value is satisfied [SWS_CORE_01111]. Otherwise, exceptions may occur during construction of the contained value and be propagated to the caller.

Within ara::core::Optional, this function complements the regular move constructor [SWS_CORE_01106], the copy constructor [SWS_CORE_01105], and the default constructor [SWS_CORE_01103]. In addition, the element interacts closely with ara::core::Result, whose methods Ok() and Err() return contained values or errors as ara::core::Optional (as in [SWS_CORE_00770], [SWS_CORE_00771], and [SWS_CORE_00772]), as well as with the helper function swap [SWS_CORE_01096].

The member function emplace of class ara::core::Optional serves to construct the contained value of type T directly in the memory of the optional object [SWS_CORE_01119]. The call is performed synchronously via the header file ara/core/optional.h. As a parameter, the function takes a variadic argument pack Args&&... and forwards it to the constructor of type T; an lvalue reference to the newly constructed value (T&) is returned [SWS_CORE_01119].

Regarding exception handling, the function is classified as conditionally exception safe (conditionally exception safe) and has a conditional noexcept specification based on std::is_nothrow_constructible<T, Args&&...>::value [SWS_CORE_01119]. If the construction of T throws an exception, the exception safety of the underlying type applies; a noexcept guarantee holds exclusively if the construction is guaranteed not to throw exceptions. Specific error codes, DEM events, or DET notifications are not provided in the specification [SWS_CORE_01119].

Regarding concurrency, the specification is silent; Interpretation: Simultaneous write access by multiple threads to the same instance of ara::core::Optional is likely not thread-safe without external synchronization. Question Q-c11efb3f95001493 (open) In addition, any previously existing value is likely destroyed upon re-initialization.

In the interaction within ara::core::Optional, alternative overloads exist: For initializer lists, a variant with std::initializer_list is available [SWS_CORE_01120], while a dedicated overload is defined for reference types ara::core::Optional<T&> [SWS_CORE_01164]. Similar emplace mechanisms for in-place construction also exist in module core for containers such as ara::core::Vector [SWS_CORE_01366], ara::core::Map [SWS_CORE_01458], and ara::core::Variant [SWS_CORE_01661], [SWS_CORE_01662], [SWS_CORE_01663], [SWS_CORE_01664].

The member function emplace from [SWS_CORE_01120] serves to initialize the contained value of an object of type ara::core::Optional directly in place. It accepts an std::initializer_list<U> as well as optional arguments Args&&... and returns a reference T& to the newly created value.

Regarding error handling and exception safety, the function is specified as conditionally exception safe (conditionally exception safe). According to [SWS_CORE_01120], the noexcept condition depends exactly on whether the target type T can be constructed without exceptions using the std::initializer_list<U>& and the forwarding arguments (std::is_nothrow_constructible). This represents an explicit deviation from the behavior in standard [optional].

In conjunction with the core components, this overload complements the generic in-place construction without an initializer list from [SWS_CORE_01119]. For reference specializations, assignment via [SWS_CORE_01164] also exists. Interpretation: As is customary with the standard counterpart in [optional], if a prior value is present, it is likely destroyed prior to the new construction. Question Q-b8a9274e43f0a0a9 (open)

The member function reset of class ara::core::Optional is provided via the header #include "ara/core/optional.h" and serves to reset an instance [SWS_CORE_01136]. The function has the signature void reset () noexcept;, takes no parameters, and provides no return value [SWS_CORE_01136]. Its behavior follows the corresponding usage in [optional] [SWS_CORE_01136]; Interpretation: Based on this reference, the call is likely to destroy any state value present and transition the instance into a disengaged state. Question Q-c819444ae1a7df1f (open)

Regarding error handling and exception safety, reset is declared as exception-safe (exception safe) and with the identifier noexcept [SWS_CORE_01136]. Neither exceptions are thrown nor error codes are returned [SWS_CORE_01136].

In interaction with other components of the Core library, the following relations are relevant:

• For optional references ara::core::Optional<T&>, an overload of reset specified as constexpr is available, which is also noexcept and exception-safe [SWS_CORE_01165].
• In distinction to Optional, the type ara::core::Bitset in header ara/core/bitset.h also offers reset functions: a parameterless variant that references the modified bitset [SWS_CORE_01727], as well as a position-based overload with Result return and check for IsoStdOutOfRangeViolation [SWS_CORE_01728].

use

The template member function value_or of class ara::core::Optional according to [SWS_CORE_01134] serves to synchronously retrieve the contained value or a provided fallback value. It is included via the header #include "ara/core/optional.h" and is declared with the signature template <typename U> constexpr T value_or (U &&) const &; as a const lvalue reference method. The behavior complies with the corresponding definition of std::optional ("As per corresponding usage in [optional]"), whereby the value T is returned if content is set, and the passed default value is returned otherwise.

Error Handling and Exception Safety

Regarding error handling, the function according to [SWS_CORE_01134] is explicitly specified as not exception-safe ("not exception safe"). Error codes, DET, or DEM messages are not provided for this call. Exceptions thrown during conversion or copy operations can thus propagate to the outside.

Interaction

Within ara::core::Optional, complementary overloads of value_or exist:

• [SWS_CORE_01135] provides the rvalue overload template <typename U> constexpr T value_or (U &&) &&;, which is likewise declared as not exception-safe ("not exception safe") and enables optimized moving for temporary objects.
• [SWS_CORE_01175] specifies the overload for the specialization ara::core::Optional<T&> with the signature template <typename U> constexpr T value_or (U &&u) const noexcept;, which, in contrast to [SWS_CORE_01134], is marked as exception-safe ("exception safe").

use

The rvalue-qualified member function value_or of the template class ara::core::Optional is provided via the header file ara/core/optional.h [SWS_CORE_01135]. According to the reference to [optional], it serves to query the contained value synchronously or to return a passed replacement value. Since this call is bound to rvalue references, the contained value is presumably transferred via move semantics if a value is present; otherwise, the passed argument is evaluated and converted. Question Q-e20f155d58dd0d72 (open)

Interplay and overloads

The function complements the const lvalue overload [SWS_CORE_01134], which provides the same fallback mechanism for long-lived or non-temporary instances. For specializations on references ara::core::Optional<T &>, a signature declared as noexcept exists deviatingly [SWS_CORE_01175], whereas the general overload is intended for rvalues of value types.

Error Handling and Exception Safety

The method is explicitly declared as not exception safe [SWS_CORE_01135]. Specific error codes, DET, or DEM messages do not exist. Interpretation: Potential exceptions are likely to originate primarily from move constructors or conversion operators of the involved types T and U, provided that errors occur during the creation of the return value. Question (open)