class ara::core::Variant

The member function emplace constructs an alternative value of type T directly in an existing instance of ara::core::Variant [SWS_CORE_01661]. The function is provided via the header file #include "ara/core/variant.h" and executed synchronously [SWS_CORE_01661]. As parameters, it takes forwarding references args... that are passed to the constructor of the target type T, and returns a reference to the newly created object [SWS_CORE_01661].

Regarding error handling, the operation is declared as conditionally exception safe (\"conditionally exception safe\") [SWS_CORE_01661]. It follows the standard behavior of variant, but deviates via a conditional noexcept specification: An exception is excluded if and only if std::is_nothrow_constructible<T, Args...>::value is satisfied [SWS_CORE_01661]. Specific AUTOSAR error codes or notifications to DET or DEM are not defined for this basic function.

Regarding concurrency and calling context, the specification does not state any deviating guarantees. Interpretation: Concurrent write access by multiple threads to the same Variant instance via emplace is likely not thread-safe without external synchronization, as AUTOSAR references the standard semantics of variant. Question Q-4d9d118b9916a3dc (open)

In interaction within ara::core::Variant, further overloads exist for initializer lists [SWS_CORE_01662] as well as index-based in-place constructions [SWS_CORE_01663], [SWS_CORE_01664]. Analogous emplace operations are also specified in the Core module for ara::core::Optional ([SWS_CORE_01119], [SWS_CORE_01120], [SWS_CORE_01164]) and containers such as ara::core::Vector [SWS_CORE_01366] and ara::core::Map [SWS_CORE_01458].

Member function emplace of ara::core::Variant from header ara/core/variant.h serves to synchronously create an alternative of type T directly in the storage of the existing instance [SWS_CORE_01662]. Here, an std::initializer_list<U> and forwarded arguments Args&&... args are passed to the constructor of the type. As return value, the function returns an lvalue reference T& to the newly initialized object [SWS_CORE_01662].

Regarding error handling and exception handling, the function deviates from the standard definition in [variant]: it is classified as conditionally exception safe (conditionally exception safe) and features a conditional noexcept specification [SWS_CORE_01662]. A call guarantees freedom from exceptions provided that std::is_nothrow_constructible<T, std::initializer_list<U>&, Args&&...>::value evaluates to true [SWS_CORE_01662]. Specific AUTOSAR error codes or reporting channels to DET and DEM do not exist for this element.

Regarding concurrency and constraints: since emplace modifies the state of the variant instance, a concurrent call without external synchronization is unlikely to be thread-safe. Interpretation: A previously contained value is destroyed prior to the construction of the new object, corresponding to the general behavior of [variant]. Question Q-548c84cc1d327030 (open)

In interplay with related interfaces, the function forms the type-based counterpart to the overload without initializer list [SWS_CORE_01661] as well as to index-based alternatives [SWS_CORE_01663] and [SWS_CORE_01664]. Similar interface concepts are found in ara::core::Optional [SWS_CORE_01120] as well as in containers such as ara::core::Vector [SWS_CORE_01366] or ara::core::Map [SWS_CORE_01458], with container emplace operations being not exception safe, in contrast to this.

use

Member function emplace of class ara::core::Variant ([SWS_CORE_01663]) from header file ara/core/variant.h serves for direct construction of the alternative determined by template index I in the existing storage of the object. Arguments Args&&... args are passed as parameters. The call is synchronous and returns a reference to the newly created value of type variant_alternative_t<I, Variant<Types...>> ([SWS_CORE_01663]). The behavior follows the definition in [variant] ([SWS_CORE_01663]).

Error Handling and Exception Safety

The specification defines a conditional noexcept({<cond-noexcept-11>}) clause as well as property conditionally exception safe ([SWS_CORE_01663]) as deviations from the C++ standard. The throwing of exceptions presumably depends on whether the constructor of the target alternative is exception safe for the forwarded types Args.... Question Q-189fe417e9ef4980 (open) Specific error codes, return values in case of error, or notifications to DET or DEM are not specified for this function.

Interaction and Alternatives

Within module core and type ara::core::Variant, the function is embedded in a system of further overloads:

• Index-based initialization with an std::initializer_list under [SWS_CORE_01664].
• Type-based creation of an alternative via type name T using [SWS_CORE_01661] or in combination with std::initializer_list via [SWS_CORE_01662].
• Corresponding in-place mechanisms are also found across containers in ara::core::Optional ([SWS_CORE_01119], [SWS_CORE_01120], [SWS_CORE_01164]), ara::core::Vector ([SWS_CORE_01366]), and ara::core::Map ([SWS_CORE_01458]).

Member function emplace from ara/core/variant.h synchronously constructs a new alternative value directly in place within an existing instance of ara::core::Variant [SWS_CORE_01664]. The type to be addressed is fixed via template index I. The call accepts an initializer list il of type std::initializer_list<U> as well as optional arguments args and returns a reference to the newly created value of type variant_alternative_t<I, Variant<Types...>>& [SWS_CORE_01664].

For error handling, the operation is classified as conditionally exception safe (conditionally exception safe) and provided with a conditional noexcept [SWS_CORE_01664]. The evaluation of condition {<cond-noexcept-12>} is presumably expected to depend on whether the constructor of the target type with il and args throws no exceptions. Question Q-87f90253fc61c883 (open) Specific error codes as well as reports to DET or DEM are not defined in the specification; except for the noexcept declaration, the behavior on exceptions follows the standard behavior of [variant] [SWS_CORE_01664].

Within ara::core::Variant, the function complements the index-based creation without initializer list [SWS_CORE_01663] as well as the two type-based variants [SWS_CORE_01661] and [SWS_CORE_01662]. Analogous emplace functions for direct in-place construction exist in module core also for ara::core::Optional ([SWS_CORE_01119], [SWS_CORE_01120], [SWS_CORE_01164]) as well as for containers such as ara::core::Vector ([SWS_CORE_01366]) and ara::core::Map ([SWS_CORE_01458]).

The member function index of class ara::core::Variant serves to synchronously query the zero-based index of the currently held type according to specification [SWS_CORE_01665]. It behaves analogously to the corresponding usage in the standard C++ type std::variant (\u201cAs per corresponding usage in [variant]\u201d), takes no parameters, and returns the current index as std::size_t. It is declared in header ara/core/variant.h and qualified as constexpr and noexcept.

Regarding error handling and exception safety, the method is specified as exception safe [SWS_CORE_01665]. Because it is declared as noexcept, it throws no exceptions itself and triggers no error conditions. Callers can evaluate the returned index to ensure which type is active in the ara::core::Variant prior to accessing alternative values.

In the interplay with the typed access functions ara::core::get, index plays a central role: The overloads of get for lvalues and rvalues explicitly check condition variant.index() != I according to [SWS_CORE_01613], [SWS_CORE_01614], [SWS_CORE_01615], and [SWS_CORE_01616]. If the index does not match the requested positional index I, violation IsoStdBadVariantAccessViolation is triggered in deviation from std::bad_variant_access. A prior check using index() prevents this erroneous access at runtime.

Regarding concurrency, the method as a const operation is safe for concurrent read access to the same variant as long as no concurrent modifications take place; internal synchronization against parallel write accesses is likely not present. Question Q-12e0dad0a6b8c5d0 (open)

use

The member function valueless_by_exception of class ara::core::Variant is provided in module core via header file #include "ara/core/variant.h" ([SWS_CORE_01666]). In accordance with its signature constexpr bool valueless_by_exception () const noexcept;, it requires no invocation parameters and synchronously returns a boolean value ([SWS_CORE_01666]). The functional meaning is governed by the usual semantics of [variant] (\u201cAs per corresponding usage in [variant]\u201d) ([SWS_CORE_01666]). Interpretation: The returned status true presumably signals to the caller that a previous value assignment or type change was aborted by the occurrence of an exception and the Variant object therefore temporarily does not represent a valid state. Question Q-af7c00c7eb4ef5a1 (open)

Error Handling and Exception Safety

Regarding error behavior, the method is declared as noexcept and formally classified as exception safe ([SWS_CORE_01666]). A dedicated error case does not exist during the query; the function does not throw C++ exceptions ([SWS_CORE_01666]). Specific error codes, feedback descriptions, or notifications to diagnostic and error monitoring instances such as DET or DEM are not defined for this element ([SWS_CORE_01666]).

Concurrency and Limitations

Since valueless_by_exception is specified as a const and constexpr method, no modifying accesses to the internal state of the object occur during execution ([SWS_CORE_01666]). Interpretation: Concurrent read queries to the same instance from multiple threads are likely safely executable without special synchronization, as long as concurrent write operations remain excluded. Question Q-5c28f8cef1c1f097 (open)