class ara::exec::FunctionGroup

The class serves as an implementation-specific runtime representation of a function group defined in the AUTOSAR metamodel. Its instantiation takes place exclusively via an instance specifier of the function group port [SWS_EM_02586], to whose path the object remains permanently bound throughout its entire lifetime. To avoid problems during resource allocation, the class is not copyable, but supports exception-safe move semantics [SWS_EM_02328]. Comparison operators can be used to determine whether two instances represent the same metamodel element.

more ›

Context

Class ara::exec::FunctionGroup acts in the Adaptive Platform module exec (Execution Management) as a representation of a function group defined in the AUTOSAR metamodel (ARXML). An instance of this class provides an implementation-specific abstraction of the information stored in the metamodel. According to the specification, the internal value of an object, once created based on the ARXML path, remains permanently bound to this metamodel element throughout its entire lifetime.

The using software component (State Client), the instance specifier (ara::core::InstanceSpecifier), and the underlying metamodel appear as key interaction partners. The link to the system configuration is established specifically via a InstanceSpecifier, which references the RPortPrototype of a StateClientInterface [SWS_EM_02586]. The class thus enables processes and control instances to reference function groups in a typed manner and to check them for identity without having to deal directly with unstructured paths or model descriptions.

Context diagram: Integration of class ara::exec::FunctionGroup between port specification and metamodel. Sources: [SWS_EM_02586].

Lifecycle

The creation and management of ara::exec::FunctionGroup objects follow strict rules regarding resource management and memory integrity. A parameterless default constructor is explicitly deleted (= delete) [SWS_EM_02321]. Instead, an instance is mandatorily instantiated via the regular constructor by passing a constant reference to an ara::core::InstanceSpecifier [SWS_EM_02586]. This constructor is declared as exception-safe (noexcept) and thread-safe.

With respect to ownership and the copy operation, the class is designed as a move-only data type. Both the copy constructor [SWS_EM_02322] and the copy assignment operator [SWS_EM_02327] are deleted to preclude potential conflicts and runtime issues during the allocation of internal resources throughout copy operations from the outset. Passing on or reorganizing instances is possible exclusively via move operations: The move constructor [SWS_EM_02328] and the move assignment operator [SWS_EM_02329] enable an efficient transfer of ownership to a new or existing object. Interpretation: In a move operation, the target object presumably assumes the binding to the metamodel element seamlessly, while the source instance is placed into a valid, but unspecified state. Question Q-99b40860db69ffe6 (open)

Destruction takes place deterministically via destructor [SWS_EM_02266], which is likewise defined as exception-safe (noexcept). While construction via an InstanceSpecifier [SWS_EM_02586] is thread-safe, the move operations [SWS_EM_02328], [SWS_EM_02329] and destructor [SWS_EM_02266] are specified as not thread-safe (not thread-safe). If multiple threads of execution access the same instance concurrently, synchronization on the application side is therefore required.

Usage Path

The regular usage of ara::exec::FunctionGroup typically comprises the following sequence of steps:

1. Provision of the port identifier: The application identifies the desired state interface port based on its model path in the form of an ara::core::InstanceSpecifier.
2. Instantiation: Via the parameterized constructor, the FunctionGroup instance is created and permanently bound to the metamodel element of the target port [SWS_EM_02586].
3. Identity check and comparison: In the context of state queries or validations, two instances can be compared via relational operators operator== [SWS_EM_02267] and operator!= [SWS_EM_02268], respectively. A comparison yields true (for the equality operator) if and only if both instances represent exactly the same element in the ARXML metamodel. Both operators are thread-safe and exception-safe.
4. Relocation or cleanup: If the object is to be transferred into container structures or passed between modules, this is done via move semantics [SWS_EM_02328], [SWS_EM_02329]. When the object leaves its scope, destructor [SWS_EM_02266] releases all assigned bindings.

Error Scenarios

In terms of error scenarios, the interface is characterized by a rigid, error-preventing design:

• Disallowed copy operations: Attempts to duplicate instances via copy constructor [SWS_EM_02322] or copy assignment operator [SWS_EM_02327] immediately result in a compile-time error.
• Missing instance identifier: An incomplete initialization without metamodel reference is prevented because the parameterless constructor is deleted [SWS_EM_02321].
• Exception safety: All declared methods of the class—namely construction via an instance specifier [SWS_EM_02586], move operations [SWS_EM_02328], [SWS_EM_02329], comparison operators [SWS_EM_02267], [SWS_EM_02268], and destructor [SWS_EM_02266]—are declared as noexcept and throw no C++ exceptions.
• Invalid concurrency: Since move operations and the destructor are not thread-safe, uncoordinated parallel accesses lead to undefined behavior (race conditions), which must be prevented at caller level by synchronization mechanisms.