class ara::core::Result< void, E >

Usage and Call Context

The member function Bind of specialization ara::core::Result<void, E> from ara/core/result.h performs a follow-up computation on a successful instance without a result value [SWS_CORE_00870]. If a value is present, the passed callable f is called synchronously and without parameters. The callable must satisfy either interface Result<XXX, E> f() or XXX f(), where XXX must be an admissible type for Result [SWS_CORE_00870]. If the callable yields a Result, the return type corresponds to decltype(f()); if it returns XXX directly, the result is wrapped as Result<decltype(f()), E> [SWS_CORE_00870].

Error Handling and Concurrency

If the instance contains no value, a new Result<XXX, E> is returned into which the original error is copied [SWS_CORE_00870]. Interpretation: In this case, execution of the callable f is likely omitted. Question Q-6288a7106d2730c3 (open) With respect to execution safety, the function is considered not exception safe [SWS_CORE_00870]. Thread safety is conditional (conditional) and depends entirely on the thread safety of the passed callable f [SWS_CORE_00870].

Interaction with Related Requirements

In contrast to the primary Result<T, E> functions from [SWS_CORE_00768] and [SWS_CORE_00941], in which the callable accepts the value of the instance via f(const T&), the present overload [SWS_CORE_00870] binds operations to void results and therefore expects a parameterless callable.

The member function EmplaceError of specialization ara::core::Result<void, E> synchronously constructs a new error value directly in-place within the existing instance from the passed arguments args [SWS_CORE_00844]. The template function provided via header file ara/core/result.h has no return value and initializes the error object of type E directly in place [SWS_CORE_00844].

With respect to error handling and exception safety, the operation is classified as conditionally exception-safe (conditionally exception safe) [SWS_CORE_00844]. Exception freedom is guaranteed via the specifier noexcept(std::is_nothrow_constructible<E, Args...>::value), provided that type E can be constructed with types Args... without an exception [SWS_CORE_00844].

With respect to concurrency and constraints, the member function is defined as not thread-safe (not thread-safe) [SWS_CORE_00844]. If multiple threads access the same Result instance concurrently, an external synchronization mechanism is presumably required to prevent uncoordinated state changes. Question Q-ffcb8ced860f6080 (open)

In the overall context of module core, [SWS_CORE_00844] directly corresponds to the other variants of the same function: For the primary template ara::core::Result, the identical behavior is specified under [SWS_CORE_00744], whereas for reference types ara::core::Result<T&, E>, requirement [SWS_CORE_00916] specifies the same signature and semantics.

Usage and Call Context

The template member function EmplaceValue belongs to module core and is defined via header file #include "ara/core/result.h" for the specialization ara::core::Result<void, E> [SWS_CORE_00843]. Its purpose is to directly create or set a new value in the existing instance based on the passed arguments args [SWS_CORE_00843]. Execution is synchronous and yields no return value (void) [SWS_CORE_00843]. Since the value type of the specialization is void, the call transitions the instance into a success state; as an interpretation, accepting args is likely primarily intended for generic signature compatibility with the primary template class. Question Q-b53ca5908f2517fb (open)

Error Handling and Exception Safety

The function is declared as noexcept and has the specification exception safe [SWS_CORE_00843]. It returns no error codes and throws no exceptions. If the Result object was previously in an error state, this is overwritten by setting the value.

Concurrency and Limitations

The operation is designated as not thread-safe (not thread-safe) [SWS_CORE_00843]. In the case of potentially concurrent read or write accesses to the same instance of ara::core::Result, external synchronization by the caller is mandatory.

Interaction with related specifications

In comparison to the general implementation of EmplaceValue for ara::core::Result<T, E> in [SWS_CORE_00743], which is only conditionally exception-safe and whose noexcept property depends on std::is_nothrow_constructible<T, Args...>::value, the void specialization according to [SWS_CORE_00843] offers an unrestricted noexcept and exception-safety guarantee.

The member function Err() const & of class specialization ara::core::Result<void, E> allows synchronously querying a potentially contained error state ([SWS_CORE_00868]). It is declared via header file ara/core/result.h and requires no parameters when called ([SWS_CORE_00868]). As return value, the function provides an ara::core::Optional<E> containing the concrete error value if the object represents an error ([SWS_CORE_00868]).

Regarding concurrency and constraints, the operation is explicitly specified as thread-safe ([SWS_CORE_00868]). Regarding exception safety, the method is considered conditionally exception safe (conditionally exception safe) ([SWS_CORE_00868]). The noexcept guarantee holds if and only if std::is_nothrow_constructible<Optional<E>, const E&>::value is satisfied ([SWS_CORE_00868]).

In the set of interfaces, the rvalue overload Err() && ([SWS_CORE_00869]) complements this function within ara::core::Result<void, E>. Comparable pairs of lvalue and rvalue overloads are also available for the primary template ara::core::Result<T, E> ([SWS_CORE_00772], [SWS_CORE_00773]) and for the reference specialization ara::core::Result<T&, E> ([SWS_CORE_00931], [SWS_CORE_00932]).

The member function Err() && of specialization ara::core::Result< void, E > extracts an error, if present, and returns it as ara::core::Optional< E > [SWS_CORE_00869]. It is included via header file ara/core/result.h [SWS_CORE_00869].

Regarding usage and semantics, the following properties apply:

• Call context and parameters: The function takes no parameters and, as an rvalue-qualified method, binds exclusively to rvalue instances of ara::core::Result< void, E > [SWS_CORE_00869]. Interpretation: Due to rvalue semantics (&&), the error object is presumably moved into the returned Optional upon invocation. Question Q-b5a0098f77686ca6 (open)
• Return value: The resulting ara::core::Optional< E > contains the error value if such a value is present in the object [SWS_CORE_00869].
• Exception safety and concurrency: The operation is classified as conditionally exception safe (conditionally exception safe) and throws no exceptions if std::is_nothrow_constructible< Optional< E >, E && >::value is satisfied [SWS_CORE_00869]. Additionally, the function is specified as thread-safe (thread-safe) [SWS_CORE_00869].

In interaction among the interfaces, this rvalue variant complements the corresponding lvalue overload Err() const & of the same specialization [SWS_CORE_00868]. Analogous pairs of lvalue and rvalue methods exist for the primary template ara::core::Result [SWS_CORE_00772], [SWS_CORE_00773] as well as for the reference specialization ara::core::Result< T &, E > [SWS_CORE_00931], [SWS_CORE_00932].

The template member function ErrorOr of specialization ara::core::Result<void, E> serves to synchronously retrieve the contained error or an alternative default error according to [SWS_CORE_00863]. If the instance already contains an error value of type E, it is returned unchanged; otherwise, the passed parameter defaultError is converted into the error type E via static_cast and returned [SWS_CORE_00863].

Regarding error handling and concurrency, the following properties apply:

• Exception safety: The call is conditionally exception safe (conditionally exception safe) and declared as noexcept, provided that both the copy construction of E and the construction of E from the universal reference type G&& are non-throwing (std::is_nothrow_copy_constructible<E>::value && std::is_nothrow_constructible<E, G&&>::value) [SWS_CORE_00863].
• Thread safety: The operation is specified as thread-safe (thread-safe) [SWS_CORE_00863]. Since it is a const lvalue reference overload (const &), concurrent read accesses to the same instance should presumably be safe. Question Q-f95402c2e79ef590 (open)
• Header: The function is provided via header file #include "ara/core/result.h" [SWS_CORE_00863].

In interaction within ara::core::Result, [SWS_CORE_00863] constitutes the const lvalue counterpart to the rvalue overload [SWS_CORE_00864] for void results, in which the error is transferred via std::move. Equivalent overloads exist for the primary class template Result<T, E> via [SWS_CORE_00763] and [SWS_CORE_00764], as well as for reference types Result<T &, E> via [SWS_CORE_00935] and [SWS_CORE_00936].

Usage and Semantics

The member function ErrorOr of specialization ara::core::Result<void, E> serves to synchronously read an error from an rvalue instance ([SWS_CORE_00864]). When the method is called and the Result object contains an error, it is moved into the return value of type E via std::move. If, on the other hand, a successful result is present, the passed argument defaultError is converted to E via static_cast and returned ([SWS_CORE_00864]).

Error Handling and Exception Safety

The function itself does not trigger classic AUTOSAR error reports like DET or DEM. Regarding exception handling, ErrorOr is conditionally exception safe (conditionally exception safe). It is guarded by a noexcept expression, provided that both the error type E is non-throwingly movable (std::is_nothrow_move_constructible<E>::value) and E can be constructed exception-free from the universal reference type G&& of the default error ([SWS_CORE_00864]).

Concurrency and Interaction

The method is specified as thread-safe ([SWS_CORE_00864]). Due to the rvalue ref-qualifier &&, calling it requires the Result object to be passed as an rvalue.

In module core, this rvalue variant exists alongside other manifestations:

• For ara::core::Result<void, E>, the const & overload [SWS_CORE_00863] exists as the lvalue counterpart, which copies the error instead of moving it.
• For value and reference results, specializations ara::core::Result<T, E> ([SWS_CORE_00763], [SWS_CORE_00764]) as well as ara::core::Result<T&, E> ([SWS_CORE_00935], [SWS_CORE_00936]) provide the same dual signature structure for copy and move semantics.

use

The static function FromError is part of the template specialization ara::core::Result<void, E> and is included via the header file ara/core/result.h [SWS_CORE_00834]. It serves as a synchronous factory method to construct a new Result from an already existing error object [SWS_CORE_00834].

• Parameters: The input parameter e takes the error as a const lvalue reference (const E &) [SWS_CORE_00834].
• Return value: Returns an instance of Result that contains the passed error e [SWS_CORE_00834].

Error Handling and Exception Safety

The specification defines no specific error codes and does not foresee any reports to DET or DEM [SWS_CORE_00834]. The function is conditionally exception safe (conditionally exception safe): It is guaranteed as noexcept if and only if the error type E is non-throwing copyable (std::is_nothrow_copy_constructible<E>::value) [SWS_CORE_00834].

Concurrency

The call is classified as thread-safe [SWS_CORE_00834]. Interpretation: The thread safety is likely to concern the internal execution of the object creation, but presupposes that the referenced source object e is not modified by other threads during the copy operation. Question Q-639cbb5cf8a64a0c (open)

Interaction

Within the specialization ara::core::Result<void, E>, overloads for rvalue references (E&&) [SWS_CORE_00835] as well as for in-place construction via parameter pack [SWS_CORE_00836] complement this function; deviating from this, both are declared as not thread-safe. Corresponding overloads also exist for the incompletely specialized type ara::core::Result ([SWS_CORE_00734], [SWS_CORE_00735], [SWS_CORE_00736]) and reference specializations ([SWS_CORE_00905], [SWS_CORE_00906], [SWS_CORE_00907]).

use

The static function FromError synchronously creates a new instance of ara::core::Result<void, E> from an error object passed as an rvalue e [SWS_CORE_00835]. The function is defined in header ara/core/result.h and returns a ara::core::Result containing the error value [SWS_CORE_00835].

Error Handling and Concurrency

The operation offers conditional exception safety (conditionally exception safe): It guarantees freedom from exceptions via noexcept, provided that the error type E has a non-throwing move constructor (std::is_nothrow_move_constructible<E>::value) [SWS_CORE_00835]. The function is classified as not thread-safe (not thread-safe) [SWS_CORE_00835]. Interpretation: This is likely to mean that the rvalue object to be moved must be protected against concurrent accesses from other threads. Question Q-be29e8c3a7412b7a (open)

Interaction

Within the specialization ara::core::Result<void, E>, this overload represents the move counterpart to the lvalue copy function [SWS_CORE_00834] and to the in-place construction via parameter packs [SWS_CORE_00836]. Comparable rvalue overloads also exist in module core for value types [SWS_CORE_00735] and references [SWS_CORE_00906], complemented by respective lvalue ([SWS_CORE_00734], [SWS_CORE_00905]) and in-place variants ([SWS_CORE_00736], [SWS_CORE_00907]).

The static template function FromError according to [SWS_CORE_00836] serves to create an erroneous Result object within the specialization ara::core::Result<void, E> whose error instance of type E is constructed directly in place from the passed arguments args. The function only participates in overload resolution if std::is_constructible<E, Args&&...>::value is true, the first type of the unpacked parameter pack does not correspond to E, and is also not a specialization of Result [SWS_CORE_00836].

Regarding exception safety, the function is specified as conditionally exception safe: It is declared with noexcept(std::is_nothrow_constructible<E, Args...>::value) [SWS_CORE_00836]. Regarding concurrency, the call is considered not thread-safe [SWS_CORE_00836].

In interaction with other functions of the class, this method complements the overloads for creation from already existing lvalue ([SWS_CORE_00834]) or rvalue error objects ([SWS_CORE_00835]). Interpretation: The SFINAE constraints regarding E and Result are likely to ensure that when already created errors or Result instances are passed, the respective copy or move operators are preferentially selected and ambiguities are avoided. Question Q-2796f954bcaececa (open) Analogous in-place factory functions exist for the generic type Result ([SWS_CORE_00736]) as well as for reference types in Result<T&, E> ([SWS_CORE_00907]).

use

The static member function FromValue() serves to create a successful ara::core::Result object for the template specialization ara::core::Result<void, E> [SWS_CORE_00831]. Because the result type void does not carry payload data, the function does not accept any input parameters. The call is synchronous and returns a Result representing a void value [SWS_CORE_00831]. It is declared in header ara/core/result.h [SWS_CORE_00831].

Error Handling and Exception Safety

The function is provided with the specification noexcept and classified as fully exception-safe (exception safe) [SWS_CORE_00831]. Because FromValue() by definition represents a successful operation, it produces no error states and returns no error codes. Specific error notifications via DET or DEM are not defined for this call.

Concurrency

According to the specification, the function is classified as thread-safe (thread-safe) [SWS_CORE_00831]. It can be called concurrently from multiple threads without additional synchronization measures.

Interaction

The parameterless signature is intended exclusively for Result<void, E> [SWS_CORE_00831]. It is distinguished from the value-creating overloads:

• For value types Result<T, E>, variants exist for lvalues [SWS_CORE_00731], rvalues [SWS_CORE_00732], as well as in-place constructions [SWS_CORE_00733].
• For reference types Result<T&, E>, FromValue binds to an lvalue reference [SWS_CORE_00904].

The member function Resolve of the template class ara::core::Result<void, E> serves for error handling within the scope of generic programming [SWS_CORE_00867]. If the instance of Result contains a regular value, the call performs no operation [SWS_CORE_00867]. If the instance contains an error instead, the callable f passed as a parameter is called [SWS_CORE_00867].

The passed callable f must be compatible with the function signature void f(const E&), where E represents the error type [SWS_CORE_00867]. The function Resolve itself yields no return value (void) [SWS_CORE_00867]. With respect to execution safety, the function is specified as not exception-safe (\u201cnot exception safe\u201d) [SWS_CORE_00867]. Its thread safety is conditional and directly depends on the thread safety of the passed callable f [SWS_CORE_00867].

In the overall system, this specialization differs from the regular Resolve functions for value types in ara::core::Result<T, E> [SWS_CORE_00767] and reference types in ara::core::Result<T&, E> [SWS_CORE_00939], [SWS_CORE_00940]: While those variants return the contained value or the result of the callable invocation, the void overload without a return value exists exclusively as a generic building block for standardizing interface calls [SWS_CORE_00867].

The member function Swap synchronously swaps the content of the current instance with the passed reference other [SWS_CORE_00845]. It belongs to the scope of specialization ara::core::Result<void, E> from header file ara/core/result.h and has no return value [SWS_CORE_00845].

With respect to error handling, the operation is classified as conditionally exception-safe (conditionally exception safe) [SWS_CORE_00845]. The assurance noexcept takes effect if and only if the error type E is both nothrow move-constructible (std::is_nothrow_move_constructible<E>::value) and nothrow move-assignable (std::is_nothrow_move_assignable<E>::value) [SWS_CORE_00845]. Specific error codes or notifications to DET or DEM are not provided for this call [SWS_CORE_00845].

Regarding concurrency, Swap is explicitly specified as not thread-safe (not thread-safe) [SWS_CORE_00845]. Concurrent access to the same instances without external synchronization is therefore likely to lead to data races. Question Q-a8d4f130648765df (open)

In the interplay within ara::core, the method forms the foundation for the non-member template function ara::core::swap, whose noexcept condition is directly coupled to the member function [SWS_CORE_00796]. Comparable swap operations exist for the generic type ara::core::Result<T, E> [SWS_CORE_00745], the reference specialization ara::core::Result<T&, E> [SWS_CORE_00917], as well as for promise objects [SWS_CORE_00352] [SWS_CORE_06352].

The member function ValueOr of specialization ara::core::Result<void, E> primarily serves to facilitate generic programming patterns and performs no operations upon execution ([SWS_CORE_00861]). Provided via header ara/core/result.h, the method synchronously accepts a parameter defaultValue of forwarding type U&& and yields no return value (void) ([SWS_CORE_00861]).

Regarding concurrency and exception behavior, the member function is specified as thread-safe and declared with the specifier syntax noexcept, which guarantees full exception safety ([SWS_CORE_00861]). Because no check of the error state and no actions take place, neither error codes nor notifications to DET or DEM exist.

In interplay with the remaining variants of Result, this function complements the value-based ([SWS_CORE_00761], [SWS_CORE_00762]) and reference-based ([SWS_CORE_00933], [SWS_CORE_00934]) overloads of ValueOr. While those functions return the value if set or otherwise deliver the passed replacement value converted, this variant represents a neutral counterpart for operations without value return ([SWS_CORE_00861]). Interpretation: The passed value defaultValue is likely discarded unused in the implementation. Question Q-6097af779219e859 (open) This allows developers to write generic template algorithms without special branching for Result<void, E>.

The member function ValueOrThrow of template specialization ara::core::Result<void, E> is used for synchronous checking of the operation result [SWS_CORE_00866]. Since the value type is void, the function takes no parameters and returns no value [SWS_CORE_00866]. The declaration is provided via header ara/core/result.h [SWS_CORE_00866].

In case of success, the method returns regularly; if, on the other hand, an error condition is present, it throws an exception of the exception type associated with the contained error (noexcept(false)) [SWS_CORE_00866]. Regarding exception safety, the operation is specified as not exception safe [SWS_CORE_00866].

The following constraints apply to calling context and concurrency:

• The function is classified as thread-safe [SWS_CORE_00866].
• If C++ exceptions are disabled in the compiler toolchain, this function does not participate in overload resolution [SWS_CORE_00866].

In interaction with the core module, this void specialization complements the generic overloads of ara::core::Result<T, E>, which return references to contained values ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]), as well as the specializations for reference types ara::core::Result<T&, E> ([SWS_CORE_00938], [SWS_CORE_00949]).

The template member function CheckError of specialization ara::core::Result<void, E> synchronously checks whether the current instance contains a specific error [SWS_CORE_00865]. For this purpose, the passed argument error is converted via static_cast into the error type E and compared with the return value of the internal error state Error() [SWS_CORE_00865]. The call is made via header #include "ara/core/result.h" [SWS_CORE_00865].

The following properties apply to usage and call context:

• Parameters and return value: The universal reference parameter error of type G&& accepts the error to be checked [SWS_CORE_00865]. The function returns true if the instance contains an error equivalent to error, otherwise false [SWS_CORE_00865].
• Concurrency and exception safety: The operation is declared as const noexcept, is considered exception-safe (exception safe), and can be called in an unrestricted thread-safe (thread-safe) manner [SWS_CORE_00865].

In the interplay with module core, analogous overloads of CheckError exist: The primary template class ara::core::Result also provides the same signature thread-safely and exception-safely with noexcept [SWS_CORE_00765]. In contrast, while the reference specialization ara::core::Result<T&, E> possesses the same comparison mechanism and is thread-safe, it is explicitly specified without noexcept as not exception-safe (not exception safe) [SWS_CORE_00937].