[SWS_TS_01000]Upstream: RS_TS_00030 wording not yet imported
class SynchronizedTimeBaseConsumer final {...};
Class SynchronizedTimeBaseConsumer is the access to the synchronized timebase referenced by the InstanceSpecifier. It allows to get the current time_point, the rate deviation, the current status and the received user data
Enables applications to query synchronized time values in a thread-safe manner and to register status notifiers.
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 254e46109c20ProvenanceOpen questions (2)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
Enables applications to query synchronized time values in a thread-safe manner and to register status notifiers.
Class ara::tsync::SynchronizedTimeBaseConsumer enables time applications to access a synchronized time base referenced via a ara::core::InstanceSpecifier ([SWS_TS_01001]). Via thread-safe methods, applications can query current snapshots of time values and status flags as well as clock rate deviation ([SWS_TS_01009]). In addition, notifiers can be registered for status changes, time leaps, validation data, and precision measurements, with at most one registration active per event type. Copy operations are prohibited, so instances can only be moved or released via their destructor.
Context
For time applications on the Adaptive Platform, class ara::tsync::SynchronizedTimeBaseConsumer forms the interface to a synchronized time base identified via a ara::core::InstanceSpecifier ([SWS_TS_01001]). Its core task is to provide applications with the current query point in time, clock rate deviation ([SWS_TS_01008]), as well as consistent status flags and received user data ([SWS_TS_01009]). Essential interaction partners are the calling application software (Time Consumer Application), the consumer instance itself, and the Tsync subsystem, which acquires synchronization data and initiates notification events ([SWS_TS_01016], [SWS_TS_01018]).
Lifecycle
Instantiation is performed via the explicit constructor by specifying a ara::core::InstanceSpecifier ([SWS_TS_01001]). This constructor is classified as thread-safe and exception-safe. To manage resources, the class implements strict move semantics: the move constructor ([SWS_TS_01003]) and move assignment operator ([SWS_TS_01004]) permit transfer of ownership, whereas the copy constructor ([SWS_TS_01005]) and copy assignment operator ([SWS_TS_01006]) are explicitly deleted (=delete). This prevents inadvertent duplication of access to the same time base resource.
The destructor releases the instance ([SWS_TS_01002]). Concurrency follows a clear separation: while the constructor ([SWS_TS_01001]) and the query methods GetRateDeviation ([SWS_TS_01008]) and GetTimeWithStatus ([SWS_TS_01009]) are implemented as thread-safe, all registration and deregistration functions, the move operations, and the destructor are specified as not thread-safe (non_threadsafe).
Usage Path
A regular usage sequence comprises the phases initialization, registration of relevant notifiers, cyclic or event-driven queries, and final cleanup:
Initialization: The application creates the object with the appropriate port instance specification ([SWS_TS_01001]).
Notifier registration: The application registers callback functions or notifier objects for specific events:
General status flag changes via RegisterStatusChangeNotifier ([SWS_TS_01010]),
Synchronization state changes via RegisterSynchronizationStateChangeNotifier ([SWS_TS_01012]),
Occurrence of a time leap via RegisterTimeLeapNotifier ([SWS_TS_01014]),
Reception of validation data blocks via RegisterTimeValidationNotification ([SWS_TS_01016]),
Availability of time precision measurements via RegisterTimePrecisionMeasurementNotifier ([SWS_TS_01018]).
At most one registration can be active per notifier type; each subsequent registration overwrites the previous one ([SWS_TS_01010], [SWS_TS_01018]).
Querying during operation: Via GetTimeWithStatus(), the application retrieves a coherent snapshot (SynchronizedTimeBaseStatus) with status flags, clock configuration, and both local and synchronized time values ([SWS_TS_01009]). The current clock rate deviation is determined by means of GetRateDeviation() ([SWS_TS_01008]).
Cleanup: Before tearing down the consumer, notifiers are deregistered as needed via the corresponding calls such as UnregisterStatusChangeNotifier ([SWS_TS_01011]), UnregisterSynchronizationStateChangeNotifier ([SWS_TS_01013]), UnregisterTimeLeapNotifier ([SWS_TS_01015]), UnregisterTimeValidationNotification ([SWS_TS_01017]), or UnregisterTimePrecisionMeasurementNotifier ([SWS_TS_01019]) before the object is destroyed ([SWS_TS_01002]).
All interface methods of the class are declared with noexcept and specified as exception-safe (exception safe). Therefore, errors are not reported via C++ exceptions. The following boundary conditions and configuration violations must be observed:
Port mapping configuration errors: A PortPrototype referenced via an TimeSyncPortPrototypeToTimeBaseMapping must mandatory be typed via a SynchronizedTimeBaseConsumerInterface; otherwise a PortInterfaceMappingViolation is present ([SWS_TS_01001]).
Lack of queuing for precision measurements: The Tsync subsystem does not perform queuing for time precision measurement data ([SWS_TS_01018]). If the notifier cannot process the data in time, subsequent measurements are presumably lost unless the application provides its own buffering in the notifier. Question Q-dd82872d44124973 (open)
Risk of data races with notifier methods: Because notifier registrations and deregistrations are designated as not thread-safe, a concurrent call from different execution contexts without external protection mechanisms is likely to lead to inconsistent states (interpretation). Question Q-626c00c2b1849655 (open)
This guide was generated by an AI model based on specification data from AUTOSAR R25-11.
Method to obtain a snapshot of the current state of the clock. This includes status flags, clock configuration and the actual time value (local and synchronized) of the created status object.
Register a notifier function which is called if a StatusFlag is changed (i.e. synchronization state, time leap or userdata). A maximum of one notifier can be registered. Every further registration overwrites the current registration.
Register a notifier function which is called if a synchronization state is changed. A maximum of one notifier can be registered. Every further registration overwrites the current registration.
Register a notifier function which is called if a time leap happened. A maximum of one notifier can be registered. Every further registration overwrites the current registration.
Register a notifier function which is called if a new time precision snapshot is available. A maximum of one notifier can be registered. Every further registration overwrites the current registration. The Tsync will not do any queuing. If needed it has to be done within the notifier.
Method that can be used by time consumer applications to receive time sync parameters. A maximum of one notifier can be registered. Every further registration overwrites the current registration.
Method to obtain a snapshot of the current state of the clock. This includes status flags, clock configuration and the actual time value (local and synchronized) of the created status object.
Register a notifier function which is called if a StatusFlag is changed (i.e. synchronization state, time leap or userdata). A maximum of one notifier can be registered. Every further registration overwrites the current registration.
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 9ef36a5b086fProvenance
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
The method RegisterStatusChangeNotifier of class ara::tsync::SynchronizedTimeBaseConsumer is used to register a callback function for notification of status changes on a synchronized time base [SWS_TS_01010]. notifier of type SynchronizedTimeBaseNotifier is passed as the only parameter. The registered notifier function is called as soon as a StatusFlag of the time base changes, such as the synchronization state, a time leap, or user-defined data (userdata) [SWS_TS_01010].
At any time, a maximum of one notifier function can be registered [SWS_TS_01010]. Any further call of the method completely overwrites an existing registration, so that only the most recently passed function remains active [SWS_TS_01010].
The following specific constraints apply to integration and call context:
Error handling: The function has no return value (void), is declared as noexcept, and is specified as exception safe[SWS_TS_01010]. Error codes or error messages are not provided.
Concurrency: The method is classified as non_threadsafe[SWS_TS_01010]. Concurrent accesses to the same instance must be synchronized by the caller.
Header file: The declaration is available via the header file #include "ara/tsync/synchronized_time_base_consumer.h"[SWS_TS_01010].
This usage note was created automatically and is based exclusively on the specification data of AUTOSAR R25-11.
Register a notifier function which is called if a synchronization state is changed. A maximum of one notifier can be registered. Every further registration overwrites the current registration.
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: e95264d7432eProvenanceOpen questions (1)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
The method RegisterSynchronizationStateChangeNotifier of class ara::tsync::SynchronizedTimeBaseConsumer (defined in header ara/tsync/synchronized_time_base_consumer.h) is used to register a callback function of type Synchronization Notifier. This is called as soon as the synchronization state changes [SWS_TS_01012].
When using it, the following functional requirements and constraints must be observed:
Registration behavior: At most one notifier can be registered at the same time. Any new call to the method completely overwrites an already existing registration [SWS_TS_01012].
Return and error safety: The function returns no value (return type void) and throws no exceptions; it is declared with noexcept and specified as exception-safe (exception safe) [SWS_TS_01012]. Specific error codes do not exist.
Concurrency: The operation is classified as not thread-safe (non_threadsafe) [SWS_TS_01012]. Parallel calls on the same instance of SynchronizedTimeBaseConsumer must be synchronized by the caller.
Interpretation: The parameter description “The function to unregister” specified in the specification table for notifier is likely an editorial oversight in the specification, since both the name and the description of RegisterSynchronizationStateChangeNotifier clearly define registering and replacing the callback [SWS_TS_01012]. Question Q-65eac6c0d06d6c4f (open)
Automatically generated usage note based on specification AUTOSAR Adaptive R25-11.
Register a notifier function which is called if a time leap happened. A maximum of one notifier can be registered. Every further registration overwrites the current registration.
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: bdea44f8d9c4Provenance
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
use
The function RegisterTimeLeapNotifier registers a callback function that is called as soon as a time leap (Time Leap) has occurred [SWS_TS_01014]. It belongs to class ara::tsync::SynchronizedTimeBaseConsumer and is provided via the header #include "ara/tsync/synchronized_time_base_consumer.h"[SWS_TS_01014].
notifier of type SynchronizedTimeBaseNotifier is passed as a parameter [SWS_TS_01014]. At most one notifier function can be registered at the same time; each subsequent call to RegisterTimeLeapNotifier overwrites the previously registered function [SWS_TS_01014]. The function yields no return value [SWS_TS_01014].
Error Handling and Exception Safety
The operation is declared as noexcept and classified as exception-safe [SWS_TS_01014]. Specific error codes or error responses are not defined in the specification element [SWS_TS_01014].
Concurrency and Limitations
Regarding thread safety, RegisterTimeLeapNotifier is explicitly specified as non_threadsafe[SWS_TS_01014]. Calls from concurrent contexts on the same instance must therefore be synchronized externally.
This text was created automatically by an AI and serves as guidance. The referenced AUTOSAR specifications are authoritative.
Register a notifier function which is called if a new time precision snapshot is available. A maximum of one notifier can be registered. Every further registration overwrites the current registration. The Tsync will not do any queuing. If needed it has to be done within the notifier.
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 120c3f93924eProvenanceOpen questions (1)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
The function RegisterTimePrecisionMeasurementNotifier serves to register a callback function that is called as soon as a new snapshot for time precision measurement is available [SWS_TS_01018]. It is defined as a method of class ara::tsync::SynchronizedTimeBaseConsumer via the header ara/tsync/synchronized_time_base_consumer.h[SWS_TS_01018].
Regarding registration behavior and call semantics, the following requirements apply:
Registration limit: At most one notifier can be registered at the same time. Each subsequent call to RegisterTimePrecisionMeasurementNotifier overwrites the existing registration [SWS_TS_01018].
No queue: The Time Synchronization module (Tsync) does not perform queuing of notifications or data. If buffering or temporary storage of measurement values is required, it must be implemented within the passed notifier function [SWS_TS_01018].
Return value and exception handling: The function returns no value (void) and is specified with noexcept as exception-safe (exception safe) [SWS_TS_01018].
Regarding concurrency, the function is specified as non_threadsafe[SWS_TS_01018]. This means that calls to RegisterTimePrecisionMeasurementNotifier upon accesses from multiple threads must be synchronized externally to prevent data races. Presumably, registration should preferably take place in a deterministic initialization phase of the instance. Question Q-acd77cb313138b63 (open)
This usage note was created automatically based on the AUTOSAR R25-11 specification status.
Method that can be used by time consumer applications to receive time sync parameters. A maximum of one notifier can be registered. Every further registration overwrites the current registration.
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 06dbce09e1bfProvenance
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
The method RegisterTimeValidationNotification allows time-consumer applications to register a notification object for time synchronization parameters [SWS_TS_01016]. It is part of the class ara::tsync::SynchronizedTimeBaseConsumer and is included via the header ara/tsync/synchronized_time_base_consumer.h[SWS_TS_01016].
Usage and Parameters:
Parameters: A reference ConsumerTimeBaseValidationNotification& timeBaseValidationNotification is passed as an input parameter [SWS_TS_01016]. This notification object is informed as soon as a newly recorded data block is available for the time base [SWS_TS_01016].
Return value: The function has no return value (void) [SWS_TS_01016].
Cardinality: At most one notifier can be registered at the same time; any re-registration overwrites the existing one [SWS_TS_01016].
Error Handling and Exception Safety:
The function is declared as noexcept and specified as exception-safe (exception safe) [SWS_TS_01016]. No specific error codes are returned.
Concurrency and Interaction:
The method is classified as non-thread-safe (non_threadsafe) [SWS_TS_01016]. Therefore, concurrent accesses must be synchronized externally by the using application. While this element applies to consumer instances, [SWS_TS_01114] represents the functional counterpart for provider applications (ara::tsync::SynchronizedTimeBaseProvider) with a ProviderTimeBaseValidationNotification object.
This text was generated by an AI based on the AUTOSAR Adaptive R25-11 specification.
PortInterfaceMap- A PortPrototype that is referenced by a pingViolation TimeSyncPortPrototypeToTimeBaseMapping needs to be typed by a SynchronizedTimeBaseConsumerInterface.
Parameter (in)
Parameter
Beschreibung
specifier
InstanceSpecifier to a PortPrototype typed by a SynchronizedTime BaseConsumerInterface
Request a governed re-review of this record. The record is not changed immediately.
🚫Requirement entfallen: Dieses Element ist im gewählten Release nicht mehr enthalten.
Requirement Text as-of this release:
Curation Decisions:
Reachable Artifacts & Dependents:
Date
Actor
Transition
Reason / Rationale
Campaign
2026-08-13
tool
none → valid/unmigrated
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
2026-08-13-status-backfill
function UnregisterStatusChangeNotifier [SWS_TS_01011]Upstream: RS_TS_00034 wording not yet imported
void UnregisterStatusChangeNotifier () noexcept;
Unregister a notifier function which is called if a StatusFlag is changed (i.e. synchronization state, time leap or userdata). .
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 30af6349fa1bProvenanceOpen questions (1)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
The method UnregisterStatusChangeNotifier of class ara::tsync::SynchronizedTimeBaseConsumer (defined in header #include "ara/tsync/synchronized_time_base_consumer.h") is used to unregister a previously registered notifier function [SWS_TS_01011]. This notifier is called as soon as a StatusFlag changes, for example regarding the synchronization state, a time leap (time leap), or user data (userdata) [SWS_TS_01011].
Usage and signature
The function has the signature void UnregisterStatusChangeNotifier () noexcept;, takes no parameters, and returns no value [SWS_TS_01011]. After successful unregistration, the caller receives no further notifications about status changes on the corresponding time base.
Error Handling and Exception Behavior
The function is declared as exception safe and noexcept[SWS_TS_01011]. In case of an error, it does not throw any C++ exceptions and does not return any error codes. If no notifier function is registered at the time of the call, the call is likely to have no effect according to the specification. Question Q-6c7ff4cfdcf4dba8 (open)
Concurrency and Limitations
Regarding the call context, UnregisterStatusChangeNotifier is classified as non_threadsafe[SWS_TS_01011]. Parallel calls on the same instance of ara::tsync::SynchronizedTimeBaseConsumer must therefore be protected by external synchronization mechanisms to avoid race conditions.
This text was automatically generated based on AUTOSAR Release R25-11.
Unregister a notifier function which is called if a synchronization state is changed. .
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 00f5416be2a3ProvenanceOpen questions (1)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
use
The method UnregisterSynchronizationStateChangeNotifier belongs to class ara::tsync::SynchronizedTimeBaseConsumer and serves to deregister a previously registered callback function that is called upon changes of the synchronization state [SWS_TS_01013]. It is defined in header ara/tsync/synchronized_time_base_consumer.h, expects no parameters, and returns no value [SWS_TS_01013].
Error Handling and Exception Safety
The function is provided with the specifier noexcept and declared as exception-safe (exception safe) [SWS_TS_01013]. Consequently, it throws no exceptions, and because the return type is void, no error codes are returned either [SWS_TS_01013].
Concurrency and Limitations
For the method, the property non_threadsafe is defined [SWS_TS_01013]. Concurrent invocations on the same instance of SynchronizedTimeBaseConsumer must therefore be coordinated by external synchronization mechanisms of the application. Deregistration is likely to occur synchronously; presumably, immediately after completion of the function, no further state changes are signaled to the deregistered notifier (interpretation). Question Q-cc4b55c56144f0f0 (open)
This usage note is based on the AUTOSAR Adaptive R25-11 specification.
🚫Requirement entfallen: Dieses Element ist im gewählten Release nicht mehr enthalten.
Requirement Text as-of this release:
Curation Decisions:
Reachable Artifacts & Dependents:
Date
Actor
Transition
Reason / Rationale
Campaign
2026-08-13
tool
none → valid/unmigrated
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
2026-08-13-status-backfill
function UnregisterTimeLeapNotifier [SWS_TS_01015]Upstream: RS_TS_00034 wording not yet imported
void UnregisterTimeLeapNotifier () noexcept;
Unregister a notifier function which is called if a time leap happened. .
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: 4e9c88a1a616ProvenanceOpen questions (1)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
The method UnregisterTimeLeapNotifier belongs to class ara::tsync::SynchronizedTimeBaseConsumer and is declared via the header file ara/tsync/synchronized_time_base_consumer.h[SWS_TS_01015]. It serves to deregister a previously registered notification function (notifier) that is called upon occurrence of a time leap (time leap) [SWS_TS_01015].
For the invocation and the interface semantics, the following properties apply:
Invocation context and parameters: The function is parameterless and has no return value (void) [SWS_TS_01015]. The invocation is performed synchronously on an existing instance of SynchronizedTimeBaseConsumer.
Error handling: The operation is declared as noexcept and specified as exception-safe (exception safe) [SWS_TS_01015]. Because no error codes or exceptions are provided, the execution does not fail from an interface perspective. Interpretation: An invocation without a previously registered notifier is likely to remain silently without effect due to the lack of an error channel. Question Q-431f60b308590f3c (open)
Concurrency: The method is classified as not thread-safe (non_threadsafe) [SWS_TS_01015]. In case of concurrent access to the same consumer instance from multiple threads, the application must use external synchronization mechanisms to avoid data races.
In the interplay within the Time Synchronization module (ts), deregistration ensures that the consumer instance no longer forwards subsequent time leaps of the synchronized time base to the previously registered callback function [SWS_TS_01015].
This usage note was generated automatically based on specification R25-11.
Unregister a notifier function which is called if a new time precision snapshot is available. .
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: f62627da6e3fProvenanceOpen questions (1)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
According to [SWS_TS_01019], the function UnregisterTimePrecisionMeasurementNotifier serves to unregister a previously registered notification function that is called as soon as a new time precision snapshot (time precision snapshot) is available.
Call and Semantics
The method is declared as a member function of class ara::tsync::SynchronizedTimeBaseConsumer in header ara/tsync/synchronized_time_base_consumer.h ([SWS_TS_01019]). The call is parameterless with the signature void UnregisterTimePrecisionMeasurementNotifier() noexcept, returns no value, and throws no exceptions (exception safe according to [SWS_TS_01019]).
Concurrency and Limitations
Regarding thread safety, the function is explicitly specified as non_threadsafe ([SWS_TS_01019]). Callers must therefore ensure that calls on the same instance of SynchronizedTimeBaseConsumer are protected against parallel accesses. The call is likely to occur synchronously, so after the return of the function no further notifications for snapshots should be triggered via the previously registered notifier. Question Q-f6eb9ea26348b348 (open)
This text was created by an AI based on AUTOSAR specifications.
Method that can be used by time consumer applications to receive time sync parameters. .
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: b157fc991529ProvenanceOpen questions (1)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
Usage and signature
The method UnregisterTimeValidationNotification is part of class ara::tsync::SynchronizedTimeBaseConsumer and is included via the header ara/tsync/synchronized_time_base_consumer.h[SWS_TS_01017]. Its signature is void UnregisterTimeValidationNotification () noexcept;[SWS_TS_01017]. It takes no parameters and has no return value. According to the specification, it serves consumer applications in the context of time synchronization parameters [SWS_TS_01017]. Interpretation: According to the identifier, the call presumably serves to unregister previously registered notifications for time validation. Question Q-0b75b8b0d60da378 (open)
Error Handling and Exception Safety
The operation is specified as exception safe and declared with noexcept[SWS_TS_01017]. It throws no exceptions and reports no specific error codes [SWS_TS_01017].
Concurrency
The specification designates the method as non_threadsafe[SWS_TS_01017]. The concurrent call of multiple operations on the same instance of SynchronizedTimeBaseConsumer must therefore be synchronized on the application side.
Interaction
While [SWS_TS_01017] defines the interface for time consumers, [SWS_TS_01115] represents an analogous provider method in class ara::tsync::SynchronizedTimeBaseProvider (header ara/tsync/synchronized_time_base_provider.h) with the same properties regarding signature, thread safety, and exception safety.
This usage note was generated automatically based on the AUTOSAR specification.
gemini-3.8-flash-low· 2026-10-13 · German original