class <SI-Namespace>::proxy::fields::<Field>

use

In the proxy scope <SI-Namespace>::proxy::fields::<Field>, the method Get serves for asynchronously retrieving the current field value ([SWS_CM_00112]; see also AUTOSAR_AP_EXP_ARAComAPI §6 “FieldGet”). The function is provided via the proxy header <SiNamespaceDerivedDirectoryPath>/<SiShortname>_proxy.h and exists only if Field.hasGetter == TRUE is modeled for the field ([SWS_CM_00112]). It accepts no parameters and returns a ara::core::Future<FieldType>, which contains the current value after successful transmission ([SWS_CM_00112]).

Error Handling and Boundary Conditions

The interface is defined as noexcept and exception-safe ([SWS_CM_00112]). If the operation fails, the returned ara::core::Future contains an error code with rollback semantics ([SWS_CM_00112]):

• ComErrc::kCommunicationFailure: The network binding reports a recoverable communication error or the failure of secured communication ([SWS_CM_00112]).
• ComErrc::kMinimumSendIntervalViolationError: A send request occurred faster than permitted by the minimum send interval configured for the element (minimumSendInterval) ([SWS_CM_00112]).
• InsufficientPermissionsViolation: Execution is rejected by grant enforcement ([SWS_CM_00112]).

Application errors do not exist for the getter ([SWS_CM_00113]).

Interaction

On the skeleton side, processing the getter request requires a callback registered via RegisterGetHandler ([SWS_CM_00114]). Each call to Get() performs an End-to-End (E2E) check; the resulting state status can be queried synchronously on the proxy side via GetE2EStateMachineStateGetter ([SWS_CM_00145]).

Usage and Call Context

The function Set is provided in the namespace <SI-Namespace>::proxy::fields::<Field> and is exclusively available if Field.hasSetter == TRUE is configured for the field [SWS_CM_00113]. Before use, the service instance must have been offered on the server side (OfferService()) and found as well as connected on the client side ARAComAPI §4.2 “Means of Communication”. The call is asynchronous: it passes the new field value via parameter value and returns a ara::core::Future<FieldType> [SWS_CM_00113]. The method is specified as noexcept and considered exception-safe [SWS_CM_00113].

Error handling

If the transmission fails, the corresponding error is provided via the returned ara::core::Future [SWS_CM_00113]:

• ComErrc::kCommunicationFailure: Reports a recoverable communication error or a disruption of secure transmission; in case of a timeout, an undefined state without rollback semantics may exist on the server side [SWS_CM_00113].
• ComErrc::kMinimumSendIntervalViolationError: Occurs when a send request was issued faster than the configured minimum send interval (minimumSendInterval) (likewise without rollback semantics) [SWS_CM_00113].
• Missing access rights lead to a denial by grant enforcement (InsufficientPermissionsViolation) [SWS_CM_00113].
• Application errors are not conveyed via exceptions, but by returning a value differing from the request parameter upon success of the future [SWS_CM_00113].

Interaction and Concurrency

On the server side, the call corresponds to a callback on the skeleton instance that must previously be registered via RegisterSetHandler [SWS_CM_00116] ARAComAPI §4.2 “Means of Communication”. To monitor E2E transmission protection on the client side, the status of the E2E state machine of the latest Set() call can be queried via GetE2EStateMachineStateSetter() [SWS_CM_00146].

Usage and Call Context

The function SetReceiveHandler is provided on the proxy side in namespace <SI-Namespace>::proxy::fields::<Field> via header file <SiNamespaceDerivedDirectoryPath>/<SiShortname>_proxy.h ([SWS_CM_11605]). On the client side, it registers a callback for notifications upon value changes of a field ([SWS_CM_11605]). This mechanism follows the notification procedure of events, whereby Communication Management informs the client upon updates (EXP_ARAComAPI §4.2 “Means of Communication”).

A ara::com::FieldReceiveHandler, representing a parameterless function, is passed as a parameter ([SWS_CM_11605]). The function returns no return value (void) and is specified as exception safe (noexcept) ([SWS_CM_11605]).

Error Handling and Concurrency

If the passed callable object does not exist or is null, the function reports violation InvalidHandlerViolation ([SWS_CM_11605]). If execution of the handler is to take place in a defined execution context, the template variant with ExecutorT is available ([SWS_CM_11611]).

Interaction

The behavior corresponds to handler registrations for events ([SWS_CM_00181]) and triggers ([SWS_CM_00250]). Following the interface pattern of the proxy class, deregistration is likely to take place via UnsetReceiveHandler() (EXP_ARAComAPI §5.3.1 “Proxy Class API’s”). Question Q-74cd83b99aadec16 (open)

Usage and Call Context

The template function SetReceiveHandler is part of the proxy class class <SI-Namespace>::proxy::fields::<Field> ([SWS_CM_11611]; header #include "<SiNamespaceDerivedDirectoryPath>/<SiShortname>_proxy.h"). It is used to register a receive handler on the client side for notifications upon value changes of a field (AUTOSAR_AP_EXP_ARAComAPI §4.2 “Means of Communication”, [SWS_CM_11605]). A callable object handler of type ara::com::FieldReceiveHandler and an execution context executor as a universal reference ExecutorT&& are passed via the parameters ([SWS_CM_11611]). The function has no return value (void).

Error Handling and Exception Safety

The method is declared as noexcept and specified as exception safe (exception safe) ([SWS_CM_11611]). If the passed callable handler does not exist or is null, a InvalidHandlerViolation occurs ([SWS_CM_11611]). Callers must therefore ensure that a valid function or function object is provided before the call.

Concurrency and Interaction

In contrast to the standard registration without an executor ([SWS_CM_11605]), when a field notification arrives, the callback is processed in the execution context provided by executor ([SWS_CM_11611]). Interpretation: This is likely to bring about a decoupling, so that application-specific data processing does not take place in the execution contexts of internal middleware threads. Question Q-cbe1af19bea15a88 (open) The method belongs to the proxy class APIs (AUTOSAR_AP_EXP_ARAComAPI §5.3.1 “Proxy Class API’s”) and follows the same pattern as the executor variants for events ([SWS_CM_11356] based on [SWS_CM_00181]) as well as triggers ([SWS_CM_00352] based on [SWS_CM_00250]).

The function SetSubscriptionStateChangeHandler registers a user-defined callback on a proxy field (scope <SI-Namespace>::proxy::fields::<Field>), which is called by Communication Management as soon as the subscription state (ara::com::SubscriptionState) of the field changes ([SWS_CM_11607], [SWS_CM_00333]). The call is synchronous and returns no value ([SWS_CM_11607]). It belongs to the central proxy interfaces for managing event and field subscriptions (AUTOSAR_AP_EXP_ARAComAPI §5.3.1 “Proxy Class API’s”).

Regarding error handling, the registration function is specified as exception safe and declared with noexcept ([SWS_CM_11607]). If the passed callable object handler does not exist or is null, a specification violation in the form of a InvalidHandlerViolation occurs ([SWS_CM_11607]).

In interaction with connection establishment, it must be noted that Subscribe() must fundamentally be considered an asynchronous operation ([SWS_CM_12006]). Applications may therefore only assume a successful subscription even after an error-free return of Subscribe() once the registered handler has signaled the state kSubscribed ([SWS_CM_12006]). In addition, Communication Management calls the handler with kSubscriptionPending if the actual binding cannot be completed immediately or if the server instance fails, for example due to a restart or network error ([SWS_CM_00313]). If the handler is to be executed in a specific execution context, the overloaded template variant with an ExecutorT is available for this purpose ([SWS_CM_11608]).

The template function SetSubscriptionStateChangeHandler in namespace <SI-Namespace>::proxy::fields::<Field> serves to register a callback function for monitoring state changes of the subscription of a field ([SWS_CM_11608]). It extends the basic behavior from [SWS_CM_11607] in that the registered handler is executed in an explicitly passed execution context (executor) ([SWS_CM_11608]).

The method accepts two parameters ([SWS_CM_11608]):

• handler: The callback of type ara::com::SubscriptionStateChangeHandler ([SWS_CM_11354]) to be invoked, which is triggered as soon as the ara::com::SubscriptionState changes ([SWS_CM_00333]).
• executor: A forwarding reference of type ExecutorT&& ([SWS_CM_11360]) that provides the context for executing the handler ([SWS_CM_11608]).

The function returns no value (void) and is declared as noexcept ([SWS_CM_11608]). It is specified as exception safe ([SWS_CM_11608]). InvalidHandlerViolation is defined as a violation if the passed callable does not exist or is null ([SWS_CM_11608]).

Interpretation: By passing executor, the execution of the handler is likely shifted from the internal context of Communication Management to the thread or task context of the application. Question Q-647f618545799c4e (open) In the interaction of the proxy APIs, the call takes its place alongside methods such as Subscribe(), Unsubscribe(), and UnsetSubscriptionStateChangeHandler() (AUTOSAR_AP_EXP_ARAComAPI §5.3.1 “Proxy Class API’s”). Analogous overloaded variants with an execution context exist for proxy events ([SWS_CM_11354]) as well as proxy triggers ([SWS_CM_01106]).

Usage and Call Context

The member function SetTransportFaultConditionHandler serves to register an error handler for the notifier of a proxy field in namespace <SI-Namespace>::proxy::fields::<Field> [SWS_CM_00109]. A callable object of type ara::com::e2e::TransportFaultConditionHandler is passed as a parameter. The function returns no value and binds the callback to the notifiers of individual service instances to receive transmission errors of the communication backend AUTOSAR_AP_SWS_CommunicationManagement §7.4 “End-to-end communication protection” p. 235.

Error Handling and Exception Safety

The method is declared as noexcept and specified as exception-safe [SWS_CM_00109]. If the passed callable is invalid or null, a precondition violation in the form of a InvalidHandlerViolation is present [SWS_CM_00109]. Interpretation: Since the function must not throw exceptions, such a violation in AUTOSAR Adaptive typically leads to immediate program termination. Question Q-74df6934d4ae3c93 (open)

Concurrency and Interaction

While this basic form registers the handler directly, [SWS_CM_00110] provides an overloaded template variant that additionally accepts an executor (ExecutorT&& executor) to define the asynchronous execution context. The function fits into the end-to-end error handling: While notifiers ([SWS_CM_00109], [SWS_CM_00110]), events ([SWS_CM_00099]), and triggers ([SWS_CM_00106]) report transmission errors asynchronously via such handlers, transport errors in method as well as getter and setter requests are reported back instead via ComErrc::kCommunicationFailure in the resulting ara::core::Future [SWS_CM_00090].

use

The template member function SetTransportFaultConditionHandler is used within the scope of a proxy field class (<SI-Namespace>::proxy::fields::<Field>) to register a handler for the notifier of the respective field [SWS_CM_00110]. It accepts two input parameters:

• handler: the callable to be registered of type ara::com::e2e::TransportFaultConditionHandler [SWS_CM_00110].
• executor: an rvalue reference to an executor object (ExecutorT&&) in whose execution context any asynchronously initiated calculations are started [SWS_CM_00110].

The function returns no value (void) and is declared as noexcept [SWS_CM_00110].

Error Handling and Execution Safety

The interface is specified as exception-safe (exception safe) [SWS_CM_00110]. If a non-existent or null callable is passed as handler, this results in a InvalidHandlerViolation [SWS_CM_00110]. Specific transport error conditions are reported via this handler, whereas methods as well as field getters and setters signal any transport errors via ComErrc::kCommunicationFailure on their respective return futures [SWS_CM_00090].

Concurrency and Interaction

The method forms the execution context overload of the parameter-poorer base function [SWS_CM_00109]. Through the passed executor object, the implementation decouples the handler execution from the internal receive context of the communication management [SWS_CM_00110]. Similar overloads are available for proxy events [SWS_CM_00100], proxy triggers [SWS_CM_00107], as well as for skeleton methods [SWS_CM_00094] and skeleton fields [SWS_CM_00097]. Interpretation: The call should reasonably occur before the arrival of notifier messages or the subscription to the notifier to ensure gapless error monitoring. Question Q-bc5c62dd39c09029 (open)

The method Subscribe serves to subscribe to notifications for a field of a service proxy instance in scope proxy::fields::<Field> ([SWS_CM_11601]). Via the parameter maxSampleCount, the application specifies the maximum number of data samples it wishes to hold simultaneously, thereby setting up the local reception cache ([SWS_CM_11601], EXP ARAComAPI §5.3 “Proxy Class API’s”). The call is asynchronous: The returned ara::core::Result<void> merely signals the acceptance of the subscription by Communication Management (EXP ARAComAPI §5.3.5.2 “Monitoring Event Subscription”).

With regard to state behavior and error handling, the following rules apply:

• Idempotence: If the field is already in state kSubscribed or kSubscriptionPending and the passed maxSampleCount matches the value of the current subscription, the method returns without effect ([SWS_CM_11601]).
• Error codes: If the requested cache cannot be provided, the operation fails with the error ComErrc::kMaxSampleCountNotRealizable ([SWS_CM_11601], [SWS_CM_10432]).
• Permission check: If the required permissions are missing, the call is rejected by grant enforcement with a InsufficientPermissionsViolation ([SWS_CM_11601]).

The method is declared as noexcept and specified as exception-safe ([SWS_CM_11601]). Semantically, it follows the behavior of event subscription ([SWS_CM_00141]); the configured cache forms the basis for subsequent sample reception via methods such as GetNewSamples ([SWS_CM_00701]).

The function UnsetReceiveHandler() serves at proxy level to deregister a previously registered reception handler for field notifications ([SWS_CM_11606]). It belongs to the proxy class APIs of ara::com (AUTOSAR_AP_EXP_ARAComAPI §5.3.1 “Proxy Class API’s”) and is located in namespace <SI-Namespace>::proxy::fields::<Field> ([SWS_CM_11606]).

Regarding call context and semantics, the method takes no parameters and returns no value ([SWS_CM_11606]). By calling it, an application can switch at any time from an event-driven notification model to query-based polling operation by withdrawing the user-specific callback (AUTOSAR_AP_EXP_ARAComAPI §5.3.2 “RadarService Proxy Class Example”).

For error handling, the function is specified as noexcept as well as exception safe ([SWS_CM_11606]); specific error codes do not exist according to the specification. The call is synchronous; after successful withdrawal of the handler, Communication Management no longer triggers any callback calls upon newly incoming data (interpretation: running or already scheduled executions are likely still completed or processed in a serialized manner before the withdrawal, since callback calls by Communication Management must be serialized; cf. AUTOSAR_AP_EXP_ARAComAPI §5.3.2 “RadarService Proxy Class Example”). Question Q-fbc65e80b8d8be38 (open)

In interaction, the method corresponds to disabling triggers for service events ([SWS_CM_00183]; AUTOSAR_AP_EXP_ARAComAPI §10) and triggers ([SWS_CM_11614]). In the DDS binding, the behavior is mapped via the mapping of UnsetReceiveHandler() to the respective DataReader ([SWS_CM_11141]).

use

The method UnsetSubscriptionStateChangeHandler serves within the framework of the AUTOSAR Adaptive Platform to remove a previously registered callback for subscription state changes (ara::com::SubscriptionState) of a field [SWS_CM_11609]. It is called synchronously on instances of fields of a service proxy in namespace <SI-Namespace>::proxy::fields::<Field> and requires the inclusion of the generated header #include "<SiNamespaceDerivedDirectoryPath>/<SiShortname>_proxy.h" AUTOSAR_AP_SWS_CommunicationManagement §8.3.3.2.4.5 “UnsetSubscriptionStateChangeHandler”. The call takes no parameters and returns no value.

Error Handling and Concurrency

The interface is declared as noexcept and, according to the specification, fulfills the property exception safe [SWS_CM_11609]. The occurrence of errors or exceptions is thus ruled out. Since deregistration takes effect immediately, it can be assumed (interpretation) that after completion of the method no new notifications will be passed to the former handler. Question Q-30238329b76b64f4 (open)

Interaction

The function belongs to the fundamental proxy class APIs for managing subscriptions in ara::com AUTOSAR_AP_EXP_ARAComAPI §5.3.1 “Proxy Class API’s”. Similar methods for deactivating state change handlers exist for proxy events [SWS_CM_00334] and triggers [SWS_CM_01108], as well as mirrored on the skeleton side for events [SWS_CM_12010] and triggers [SWS_CM_01112].

use

The function UnsetTransportFaultConditionHandler serves to deregister a previously registered ara::com::e2e::TransportFaultConditionHandler for the notifier of a specific proxy field [SWS_CM_00126]. It is defined within scope <SI-Namespace>::proxy::fields::<Field> and included via header file <SiNamespaceDerivedDirectoryPath>/<SiShortname>_proxy.h AUTOSAR_AP_SWS_CommunicationManagement §8.3.3.2.1.4 “UnsetTransportFaultConditionHandler”. The call is parameterless and returns no value (void).

Error handling

The method is declared as noexcept and has the exception guarantee exception safe [SWS_CM_00126]. No error codes are returned and no exceptions are thrown. If no handler was previously registered, a repeated call presumably has no effect. Question Q-85da9a7b00678748 (open)

Concurrency and Limitations

The specification defines no separate concurrency or thread safety requirements. Since the interface operates synchronously and uses no asynchronous types, revoking the error handler is expected to take effect synchronously and immediately. Question Q-ed4cc712bb55aee5 (open) Callers should coordinate the call in the application lifecycle such that notifier messages of individual service instances are not processed uncontrolled without a handler AUTOSAR_AP_SWS_CommunicationManagement §7.4.1 “End-to-end communication protection for SOMEIP”.

Interaction

Deregistering follows a consistent naming and function pattern in AUTOSAR Adaptive:

• At the proxy level, equivalent functions are available for events ([SWS_CM_00105]) and for triggers ([SWS_CM_00108]).
• At the skeleton level, corresponding counterparts exist for field getters and setters ([SWS_CM_00098]) as well as across all methods of the skeleton interface ([SWS_CM_00095]).