class <RoutineInterface-Namespace>::<RoutineInterface>

The constructor function [SWS_DM_00589] serves to instantiate a routine interface (DiagnosticRoutine) via an instance identifier. The declaration is specified as noexcept and is considered exception-safe (exception safe) as well as thread-safe (thread-safe) SWS Diagnostics §8.30.2.2.1.8 “{<routine-interface-name-1>}”.

Parameters and Call

• instanceSpec (ara::core::InstanceSpecifier): Identifier of the specific service instance bound to a matching model port.
• concurrencyType (ara::diag::ConcurrencyType): Specifies whether the interface is executed concurrently or thread-safely (kConcurrent) or is not thread-safe (kNotConcurrent).

Runtime and Model Checks

During construction, the framework checks the model and process configuration. In the case of faulty assignments or multiple uses, specific violations (Violations) are triggered [SWS_DM_00589]:

• InstanceSpecifierMappingIntegrityViolation: The InstanceSpecifier cannot be resolved in the context of the executable or does not reference an PortPrototype.
• PortInterfaceMappingViolation: A PortPrototype typed by DiagnosticRoutineInterface is not referenced by a DiagnosticServiceGenericMapping.
• ProcessMappingViolation: No matching modeled process exists at runtime for the existing instance reference.
• InstanceSpecifierAlreadyInUseViolation: The specified InstanceSpecifier is already used by an existing instance within the current process.

Usage and Semantics

The Offer method enables Diagnostic Management (DM) to forward incoming diagnostic requests to the associated routine handler [SWS_DM_00594]. The call is synchronous and parameterless via the typed interface of the routine and does not throw exceptions (noexcept) [SWS_DM_00594]. ara::core::Result<void> serves as the return type, thereby either signaling successful completion or returning an error code in case of an error [SWS_DM_00594].

Error handling

If Offer is called for a routine instance that has already been actively provided to the DM, registration fails. In this case, the method returns the error code DiagOfferErrc::kAlreadyOffered with rollback semantics [SWS_DM_00594] (defined with the value 101 in the general context of the diagnostic error domain [SWS_DM_00514]).

Concurrency and Limitations

Although the function is specified as exception-safe (exception safe), it is explicitly declared as not thread-safe (not thread-safe) [SWS_DM_00594]. Multiple calls on the same instance must not be executed concurrently without protection. Since the specification does not foresee concurrent usage, registration is typically expected to occur synchronously during the initialization phase of the processing application. Question Q-6a0f15497f03ac09 (open)

Interplay in the Diagnostic Module

The offer pattern via Offer is standardized across different interface types in AUTOSAR Diagnostic Management, for example for generic routines [SWS_DM_00557], data elements [SWS_DM_00597], data identifiers [SWS_DM_00599], and generic UDS services [SWS_DM_00619]. Although the nomenclature is based on ara::com, this is diagnostic-specific functionality that must not be confused with general service brokering AUTOSAR_AP_SWS_Diagnostics §7.3.4.1.2 “Monitors”.

use

The interface method RequestResult serves to provide the RoutineControl functionality for querying routine results within a typed diagnostic interface [SWS_DM_00593]. When called to process the UDS subfunction requestRoutineResults (service 0x31, cf. [SWS_DM_00575]), the ordered input arguments of the associated ArgumentDataPrototype, meta-information via metaInfo, and a cancellationHandler are passed AUTOSAR_AP_SWS_Diagnostics §8.30.2.2.1.2 “RequestResult”.

Via object cancellationHandler, the implementation can actively check via IsCanceled whether the ongoing diagnostic conversation was cancelled, or register a notification function via SetNotifier that is called upon cancellation [SWS_DM_00593]. Execution is asynchronous and returns a ara::core::Future, which on success contains the result object according to [SWS_DM_00583] [SWS_DM_00593].

Error handling

If an error occurs during processing, the ara::core::Future is resolved with a corresponding error. This includes negative response codes (NRCs according to ISO 14229-1) via ara::diag::DiagUdsNrcErrc or application-specific errors via Ap ApplicationError [SWS_DM_00593].

Concurrency and Limitations

The method is declared as noexcept and considered exception-safe (exception safe), but is explicitly not thread-safe (not thread-safe) AUTOSAR_AP_SWS_Diagnostics §8.30.2.2.1.2 “RequestResult”. Based on this classification, the calling component is likely responsible for suitable synchronization for parallel calls on the same instance. Question Q-aa5788303ddff2bc (open)

The pure virtual function Start in class scope <RoutineInterface-Namespace>::<RoutineInterface> serves to provide a RoutineControl operation in the Start role for model-specific diagnostic routines ([SWS_DM_00591]). It is declared via the header <RoutineInterfaceDirectoryPath>/<RoutineInterfaceShortname>.h ([SWS_DM_00591]). The call passes the ordered input arguments of the respective routine, diagnostic context information via metaInfo, as well as the object cancellationHandler for controlling conversation cancellations ([SWS_DM_00591]).

Via the parameter cancellationHandler, the implementation can check with cancellationHandler.IsCanceled whether the associated conversation has been canceled, returning TRUE in the event of a cancellation and FALSE otherwise ([SWS_DM_00591]). In addition, a notification function that is triggered in the event of cancellation can be registered with cancellationHandler.SetNotifier ([SWS_DM_00591]). Asynchronous return occurs via a ara::core::Future, which in case of success provides the generated result object StartOutput according to [SWS_DM_00581] ([SWS_DM_00591]).

In case of an error, the ara::core::Future must be set with an appropriate Negative Response Code (NRC) from ara::diag::DiagUdsNrcErrc according to ISO 14229-1 or an application-specific ApplicationError ([SWS_DM_00591]). The method is specified as noexcept and exception safe, but is considered not thread-safe ([SWS_DM_00591]). Interpretation: From the classification as not thread-safe, it likely follows that concurrent calls to the same instance must be synchronized externally. Question Q-124d8076818ac2e1 (open) While this interface serves model-specifically generated routines, GenericRoutine::Start provides the functional counterpart for generically handled diagnostic routines ([SWS_DM_00554]).

Method Stop serves to provide the RoutineControl functionality for stopping a diagnostic routine within a typed routine interface ([SWS_DM_00592]). A call is typically likely to be triggered by the Diagnostic Management daemon upon receiving a corresponding UDS diagnostic request (subfunction 0x02), analogous to the generic counterpart [SWS_DM_00555]. Question Q-cd626f527c6dfe92 (open)

The call is asynchronous and returns a ara::core::Future ([SWS_DM_00592]):

• Parameters: In addition to the model-specific input arguments {<routine-interface-stop-in-arg-symbol-0toN>}, meta-information of the request (metaInfo) and a cancellationHandler are passed ([SWS_DM_00592]). Via cancellationHandler, the implementation can actively query a cancellation via IsCanceled or register a notification with SetNotifier in case the diagnostic conversation is canceled.
• Return value: Upon successful stopping, Future provides a typed StopOutput object ([SWS_DM_00582]).

Error handling: If stopping fails, the returned Future contains an applicable Negative Response Code (NRC) according to ISO 14229-1 via ara::diag::DiagUdsNrcErrc or a model-specific Ap ApplicationError ([SWS_DM_00592]).

Concurrency and limitations: The function is specified as exception safe, but explicitly as not thread-safe ([SWS_DM_00592]). Multiple or concurrent calls on the same interface instance must be coordinated by the caller, and the routine must release any resources or react to cancellation requests from the handler.

The method StopOffer in the scope of <RoutineInterface> serves to deactivate the forwarding of diagnostic request messages from Diagnostic Management (DM) to the routine implementation [SWS_DM_00595]. The function takes no input parameters and returns no value [SWS_DM_00595].

• Usage and call context: The call occurs synchronously to unregister the routine interface with the DM. Declaration is made in the header file <RoutineInterfaceDirectoryPath>/<RoutineInterfaceShortname>.h [SWS_DM_00595]. Although the naming is modeled after the service methods of ara::com, it is a diagnostics-specific API of the DM that must not be conflated with communication management (AUTOSAR_AP_SWS_Diagnostics §7.3.4.1.2 “Monitors”).
• Error handling: The operation is declared as noexcept and classified as exception-safe (exception safe) [SWS_DM_00595]. Specific error codes or error messages are not defined for this method.
• Concurrency and restrictions: The function is specified as not thread-safe (not thread-safe) [SWS_DM_00595]; calls on the same instance therefore require external synchronization. Interpretation: Callers will likely need to terminate running routine executions in an orderly fashion before the call, as the standard merely describes deactivating the forwarding mechanism. Question Q-b0f524c0f2d7af52 (open)
• Interaction: The offering and unregistering pattern corresponds to the standardized approach in Diagnostic Management, as specified analogously for generic routines [SWS_DM_00558], generic UDS services [SWS_DM_00620], and data identifiers [SWS_DM_00600].