class ara::core::Vector

Usage and Call Context

The template member function assign for ara::core::Vector replaces the current content of the vector with the elements of the range [first, last) according to the corresponding usage in std::vector [SWS_CORE_01328]. The function is defined in header file #include "ara/core/vector.h", takes two input iterators, and returns no value (void) [SWS_CORE_01328].

Error Handling and Exception Safety

The assignment function is classified as not exception safe (not exception safe) [SWS_CORE_01328]. If an exception occurs during element processing or during necessary internal memory allocations, the container may remain in an incomplete state without defined safety guarantees.

Concurrency and Constraints

For concurrent calls, external synchronization might be necessary when simultaneously using the same instance of ara::core::Vector, since the specification does not guarantee thread safety. Question Q-5ada879738b3856d (open) A prerequisite for error-free execution is also that first and last span a valid iterator range.

Interaction in module core

In addition to range assignment via iterators, overloads with count and reference value [SWS_CORE_01329] as well as for std::initializer_list<T> [SWS_CORE_01330] are available in ara::core::Vector, which are likewise declared as not exception safe. Comparable assignment patterns also exist in the module context of ara::core::BasicString [SWS_CORE_03091].

use

The function assign belongs to the container class ara::core::Vector and is provided via the header file #include "ara/core/vector.h" [SWS_CORE_01329]. With the signature void assign (size_type n, const T &u);, it completely replaces the current contents of the vector with n elements of value u. The call occurs synchronously and has no return value (void). According to the specification, the behavior follows the corresponding usage in the standard container [vector] [SWS_CORE_01329], which presumably refers to the semantics of std::vector::assign. Question Q-3630162224047ee0 (open)

Error handling

Regarding reliability, the function is explicitly classified as not exception safe [SWS_CORE_01329]. No AUTOSAR-specific error codes, error classes, or messages to DET or DEM are defined. If an exception occurs during memory allocation or when assigning elements, the function presumably offers no guarantees for restoring the original object state. Question Q-f4eb9afa74847bf7 (open)

Concurrency and Limitations

Since assign modifies the state and potentially the capacity of the container instance, the call is not reentrant on the same instance. In the absence of separate thread-safety commitments in the specification, concurrent read or write access to the same Vector object without external synchronization is likely not thread-safe. Question Q-1df95afd2340ec57 (open)

Interaction

Together with further overloads of class ara::core::Vector, the function forms the interface for reassigning vector contents:

• Iterator-based assignment over a range assign(InputIterator first, InputIterator last) according to [SWS_CORE_01328].
• Assignment via an initializer list assign(std::initializer_list<T>) according to [SWS_CORE_01330].

Both alternative overloads share with [SWS_CORE_01329] the property of being specified as not exception safe.

The member function assign of class ara::core::Vector replaces the entire previous contents of a vector instance synchronously with the elements of the provided initializer list std::initializer_list<T> ([SWS_CORE_01330]). The functional behavior follows the corresponding usage of the standard container in [vector] ([SWS_CORE_01330]). The function has no return value (void) and is declared via header ara/core/vector.h ([SWS_CORE_01330]).

For error handling, it is specified that the method is classified as not exception safe ([SWS_CORE_01330]). Interpretation: If an exception occurs during memory allocation or when copying or moving elements, the implementation presumably provides no strong exception safety; the vector is likely to remain in an altered or incomplete state. Question Q-ac196ecfba85d821 (open)

In interaction with other interfaces of ara::core::Vector, the function complements alternative assignment overloads such as initialization via iterator ranges ([SWS_CORE_01328]) and repeated assignment of a single value ([SWS_CORE_01329]). All these assign variants share the property of not being exception-safe. A comparable assignment semantics using std::initializer_list is also found within the core library in ara::core::BasicString ([SWS_CORE_03092]).

Usage and Semantics

The member function at provides synchronous read access to an element of container ara::core::Vector at the specified index n and returns a const_reference to the element [SWS_CORE_01354]. The declaration is available via header ara/core/vector.h [SWS_CORE_01354]. The semantics correspond to the standard std::vector::at function from the C++ standard, but differ in error handling [SWS_CORE_01354].

Error Handling and Boundary Conditions

If an index is requested that reaches or exceeds the container size (n >= size()), a IsoStdOutOfRangeViolation is raised instead of the standard exception std::out_of_range [SWS_CORE_01354]. The function is declared as not exception safe [SWS_CORE_01354]. Interpretation: Since no C++ exception is thrown, raising the violation will likely lead to an abort of program flow, which can potentially interact with handling mechanisms such as AddAbortHandler [SWS_CORE_00054]. Question Q-2182d648ff4a28b8 (open)

Interplay in the module

For modifying access, the non-const overload returning reference is available, which follows the same error path [SWS_CORE_01355]. The identical deviation behavior with IsoStdOutOfRangeViolation is also found in further Core data types such as ara::core::Array [SWS_CORE_01273] [SWS_CORE_01274] and ara::core::BasicString [SWS_CORE_03063].

The member function at of class ara::core::Vector ([SWS_CORE_01355]), provided via header #include "ara/core/vector.h", enables indexed read and write access to individual elements of a vector. The function accepts a position index n of type size_type and returns a modifiable reference (reference) to the element at the specified position. The semantics follow the corresponding implementation in [vector]. Interpretation: Since the interface is declared synchronously according to the C++ standard, execution is likely to take place blocking directly in the calling thread context. Question Q-81f43622c244ce91 (open)

In contrast to the ISO C++ standard vector, the function triggers violation IsoStdOutOfRangeViolation instead of the standard exception std::out_of_range in case of index out-of-bounds (n >= size()) ([SWS_CORE_01355]). In the specification, the function is classified as not exception safe (not exception safe) ([SWS_CORE_01355]). Interpretation: Since no synchronization mechanisms are specified for this vector access, unprotected concurrent access to the same instance is likely not thread-safe. Question Q-e65ae0c574610719 (open)

For constant read-only access, overload const_reference at(size_type n) const is available, which also reports IsoStdOutOfRangeViolation and is considered not exception safe ([SWS_CORE_01354]). The same violation semantics for erroneous access are also used by related containers and types of the core library, including ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), ara::core::StringView ([SWS_CORE_02133]), and ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).

Usage and Semantics

The method clear() of class ara::core::Vector serves to completely clear the vector according to [SWS_CORE_01375]. The function is declared in header ara/core/vector.h, can be called synchronously, takes no parameters, and returns no value (void). Its functional semantics follow the corresponding specification for [vector]. Interpretation: This is likely to mean that all elements present in the vector are destroyed and the element count drops to 0, whereas the allocated memory capacity is likely to remain unchanged. Question Q-ecde315e61455c32 (open)

Error Handling and Exception Safety

The designation noexcept and the classification as exception-safe (exception safe) according to [SWS_CORE_01375] apply to the call. Since the method is guaranteed not to throw exceptions, no specific error codes exist and neither DET nor DEM error messages are issued in the event of an error.

Interplay with related containers

The concept of an exception-safe clear() function is consistently transferred to further data structures in ara::core. For instance, ara::core::Map in header ara/core/map.h provides an identical clear() method according to [map] [SWS_CORE_01485]. Likewise, ara::core::BasicString in header ara/core/string.h offers an equivalent clear() operation according to [basic.string] [SWS_CORE_03057].

According to [SWS_CORE_01342], member function crbegin of ara::core::Vector provides a constant reverse iterator (const_reverse_iterator) to the last element of the sequence. The call is synchronous and parameterless via header ara/core/vector.h. The behavior corresponds to the specification of the underlying standard C++ library for [vector]. For an empty container, the returned iterator is expected to correspond to the value of crend() (interpretation based on [vector]). Question Q-a2badba87f86486c (open)

With regard to error handling, the interface is designated with identifier noexcept and declared as exception-safe (exception safe) ([SWS_CORE_01342]). Calls do not throw exceptions and do not report errors to runtime or diagnostic monitoring.

Regarding concurrency and constraints, the method is qualified as const. Concurrent read access to the same instance from multiple threads is expected to be reentrant and thread-safe as long as no concurrent write operations are performed on the vector (interpretation analogous to the C++ container model). Question Q-094ba5878c1adc74 (open)

In module core, the concept of constant reverse iteration is consistently implemented across various types. Similar interfaces can be found in ara::core::Array ([SWS_CORE_01260]), ara::core::Map ([SWS_CORE_01450]), ara::core::Span ([SWS_CORE_01978]), ara::core::StringView ([SWS_CORE_02126]), and ara::core::BasicString ([SWS_CORE_03049]).

Member function crend of class ara::core::Vector provides a constant reverse iterator pointing to the theoretical element preceding the first element of the vector [SWS_CORE_01343]. The semantics follow the corresponding usage in the C++ standard for std::vector ("As per corresponding usage in [vector]") [SWS_CORE_01343].

Usage and Behavior

• Call context and parameters: The method is parameterless and declared as const, so that it can be called synchronously on both constant and non-constant instances of ara::core::Vector [SWS_CORE_01343].
• Return value: A const_reverse_iterator is returned, marking the logical end of a reverse iteration [SWS_CORE_01343].

Error Handling and Exception Safety

The function is specified with noexcept and is considered exception safe ("exception safe") according to the specification [SWS_CORE_01343]. No specific error codes are returned, and no exceptions occur.

Interplay with related containers

The concept of a constant reverse iterator to the endpoint of a reverse iteration is provided uniformly across containers in ara::core. Similar interfaces with identical exception handling (noexcept) exist for ara::core::Array [SWS_CORE_01261], ara::core::Map [SWS_CORE_01451], ara::core::Span [SWS_CORE_01979], ara::core::StringView [SWS_CORE_02127], as well as ara::core::BasicString [SWS_CORE_03050], among others.

The function emplace inserts an element directly into a ara::core::Vector at the specified position by forwarding passed arguments [SWS_CORE_01366]. The declaration is located in header #include "ara/core/vector.h" and follows the corresponding usage in [vector] [SWS_CORE_01366].

use

The invocation of emplace is synchronous and takes as parameters a position iterator position of type const_iterator and a parameter pack args of type Args&&... [SWS_CORE_01366]. As a return value, the function provides a iterator to the newly constructed element [SWS_CORE_01366].

Error Handling and Concurrency

For emplace in ara::core::Vector, exception safety is explicitly specified as not exception safe [SWS_CORE_01366]. Specific error codes, DET, or DEM messages are not defined in the standard. Interpretation: In the absence of internal synchronization mechanisms, concurrent invocation of emplace on the same instance is likely not thread-safe without external protection. Question Q-d72278df37e86c8a (open)

Interaction

Within ara::core, exception safety for emplace varies depending on the type:

• In ara::core::Map, emplace is also defined as not exception safe, but returns std::pair<iterator, bool> [SWS_CORE_01458].
• In ara::core::Optional, the variants are conditionally exception safe ([SWS_CORE_01119], [SWS_CORE_01120]) or, for references, fully exception safe [SWS_CORE_01164].
• In ara::core::Variant, emplace is declared as conditionally exception safe with noexcept ([SWS_CORE_01661], [SWS_CORE_01662], [SWS_CORE_01663], [SWS_CORE_01664]).

use

The template method emplace_back of class ara::core::Vector serves according to [SWS_CORE_01362] to construct a new element directly at the end of the vector. The input parameters Args&&... args are directly forwarded to the constructor of the element type according to the semantics of [vector]. As a return value, the function returns a reference (reference) to the newly created element. Header #include "ara/core/vector.h" must be included for usage [SWS_CORE_01362].

Error Handling and Exception Safety

Regarding exception safety, the operation is explicitly declared as not exception safe in [SWS_CORE_01362]. Specific error codes, fallback values, or notifications to error services such as DET or DEM are not defined in the specification.

Restrictions and behavior

Due to the not exception safe property and the alignment with [vector], in the event of an error\u2014such as a failed memory allocation or construction\u2014there is likely no guarantee for the preservation of the previous container state (interpretation). Question Q-ca44b2f27d8ae1c8 (open) Callers must therefore ensure that potential error conditions are avoided in advance.

According to [SWS_CORE_01372], function erase of class ara::core::Vector serves to synchronously remove a single element at the position indicated by parameter position (const_iterator). As return value, it provides a iterator to the subsequent element or container end if the erased element was at the last position, in accordance with the referenced semantics in [vector]. The function is declared in header file #include "ara/core/vector.h".

Regarding error handling, the operation is explicitly designated in the specification as not exception safe ("not exception safe") [SWS_CORE_01372]. No specific error returns, DET, or DEM reports are defined; invalid or non-dereferenceable iterators are therefore expected to lead to undefined behavior. Question Q-efa4c40e48a6f98d (open) Due to the shifting of elements in the vector, it is to be assumed as an interpretation: that subsequent iterators and references are invalidated, corresponding to the standard semantics of [vector].

In interplay within ara::core::Vector, overload erase(first, last) for entire ranges according to [SWS_CORE_01373] exists alongside erasing at a single position. Analogous interfaces for removing entries can be found in further containers of the Adaptive Core library: ara::core::Map provides position- and key-based overloads ([SWS_CORE_01480], [SWS_CORE_01481], [SWS_CORE_01482], [SWS_CORE_01483]), while ara::core::BasicString comprises index- and iterator-based variants ([SWS_CORE_03102], [SWS_CORE_03103], [SWS_CORE_03104]).

Member function erase of class ara::core::Vector serves to remove a range of elements from the vector according to specification [SWS_CORE_01373]. The declaration is available via header ara/core/vector.h. The semantics follow the corresponding usage in the standard vector ("As per corresponding usage in [vector]"). Two iterators first and last delimiting the range to be erased are passed as parameters; a iterator to the subsequent element is returned.

Regarding error handling and exception safety, the operation is explicitly classified in the specification as "not exception safe" [SWS_CORE_01373]. Unlike other container operations, specific error codes or error violations are not defined for this function. If an error occurs during execution, it presumably leaves the container in an inconsistent state. Question (open)

Regarding concurrency and constraints, the specification is silent; however, modifying operations on ara::core::Vector are likely not reentrant and presumably require external synchronization in multithreaded operation. Question Q-07fc291a523a82f1 (open)

In interplay with other interfaces of the Core module, this function complements the overload for removing a single element at a specific position via iterator erase(const_iterator position) [SWS_CORE_01372]. Corresponding range erasures following the same pattern are also defined for associative containers such as ara::core::Map via [SWS_CORE_01483] as well as strings in ara::core::BasicString via [SWS_CORE_03104].

use

The member function insert of class ara::core::Vector serves to synchronously insert an element at a specified position [SWS_CORE_01367]. It is defined in header #include "ara/core/vector.h" [SWS_CORE_01367]. The function takes as parameters an iterator position of type const_iterator, which marks the target position, and a constant reference x to the object to be inserted of type const T & [SWS_CORE_01367]. The return value is a iterator pointing to the newly inserted element [SWS_CORE_01367]. The functional behavior is guided by the usage in the standard vector (“As per corresponding usage in [vector]”) [SWS_CORE_01367].

Error Handling and Restrictions

The specification explicitly classifies the function as not exception safe (“not exception safe”) [SWS_CORE_01367]. Specific error codes, return values for error cases, or messages to DET or DEM are not defined. Interpretation: If an internal memory allocation or copying of the element fails, there is presumably no guarantee for the preservation of the container state or the validity of iterators. Question Q-d2b5552bb124d16e (open)

Interaction

Within ara::core::Vector, several overloads of insert exist that allow alternative insert operations:

• Insertion of an element via rvalue reference T &&x [SWS_CORE_01368],
• Insertion of a specific number of identical elements with size_type n, const T &x [SWS_CORE_01369],
• Insertion of a sequence via an iterator range [first, last) [SWS_CORE_01370],
• Insertion via an initializer list std::initializer_list<T> [SWS_CORE_01371].

Analogous insert methods are also defined in module core by associative containers such as ara::core::Map [SWS_CORE_01460] as well as string classes such as ara::core::BasicString [SWS_CORE_03093].

use

The method insert according to [SWS_CORE_01368] is defined in header #include "ara/core/vector.h" as a member function of class ara::core::Vector. It serves to synchronously insert an element via an rvalue reference (T&& x) at the position before the iterator position. According to the reference to [vector], the function will likely transfer the content of x into the vector via move semantics and return an iterator to the newly inserted element. Question Q-97f2551da8fd303f (open)

Error Handling and Restrictions

The specification classifies the function in [SWS_CORE_01368] as not exception safe. Specific error codes, return values for error indication, or messages to DET or DEM are not defined. Interpretation: If internal memory allocation or moving of elements fails, exception safety will likely not be guaranteed, which may leave the container in an inconsistent state or lead to termination. Question Q-297ef8ff6f6eb76b (open) Furthermore, there is presumably no internal concurrency protection, which is why concurrent accesses must be synchronized externally.

Interaction

The rvalue variant [SWS_CORE_01368] forms a coherent interface with other insert overloads of ara::core::Vector:

• [SWS_CORE_01367]: Copy-inserting a value using an lvalue reference (const T& x).
• [SWS_CORE_01369]: Inserting n copies of a value (size_type n, const T& x).
• [SWS_CORE_01370]: Inserting a sequence over an iterator range (InputIterator first, InputIterator last).
• [SWS_CORE_01371]: Inserting a list using std::initializer_list<T>.

The member function insert from [SWS_CORE_01369] belongs to class ara::core::Vector and is provided via the header file #include "ara/core/vector.h". The synchronous operation serves to insert multiple identical elements. Interpretation: According to the specified reference "As per corresponding usage in [vector]", the call is likely to insert exactly n copies of the passed value x immediately before the iterator position position into the vector and return a iterator pointing to the first newly inserted element. Question Q-c92add148c490868 (open)

Regarding error handling and robustness, the function in [SWS_CORE_01369] is expressly classified as "not exception safe". Specific AUTOSAR error codes or messages to DET or DEM are not provided for this method call.

Regarding concurrency and call conditions, the specification contains no special guarantees. Presumably, modifying the container requires external synchronization as with standard vectors, since concurrent write or read accesses are likely not thread-safe. Question (open)

Within ara::core::Vector, in addition to this overload for repeated values, further variants of insert exist:

• Inserting a single value by copy ([SWS_CORE_01367]) or by move semantics ([SWS_CORE_01368]).
• Inserting a range of values via input iterators ([SWS_CORE_01370]) or via a std::initializer_list ([SWS_CORE_01371]).

The template member function insert of the sequence container ara::core::Vector ([SWS_CORE_01370]) from header #include "ara/core/vector.h" inserts a sequence of elements synchronously into the vector. The range to be inserted is determined via the input iterators first and last and placed immediately before the position designated by position (type const_iterator). The function returns an iterator pointing to the first inserted element. The functional semantics are described on the specification side as "As per corresponding usage in [vector]" ([SWS_CORE_01370]); interpretation: this is likely to correspond to the standardized range insertion behavior of std::vector. Question Q-c6cd06fb1964ead6 (open)

Regarding error handling and robustness, the function is explicitly specified as not exception safe ([SWS_CORE_01370]). Special error codes, exceptions, or messages to error and diagnostic monitors (such as DET or DEM) are not provided within the scope of the specification.

As part of the interface of ara::core::Vector, this range overload complements the other insertion methods:

• inserting a single value by copy ([SWS_CORE_01367]) or by move semantics ([SWS_CORE_01368]),
• inserting a specified number of identical values ([SWS_CORE_01369]),
• and inserting from an initializer list via std::initializer_list ([SWS_CORE_01371]).

All mentioned overloads within the vector share the constraint of not being exception safe ([SWS_CORE_01367], [SWS_CORE_01371]).

The synchronous member function insert of class ara::core::Vector inserts the elements of an initializer list into the container at a specified position [SWS_CORE_01371]. It is declared in header file ara/core/vector.h [SWS_CORE_01371]. As parameters, the function expects an iterator position of type const_iterator that marks the insertion point, as well as il of type std::initializer_list<T> [SWS_CORE_01371]. The return value is a iterator to the first inserted element, or to position if the list is empty [SWS_CORE_01371].

Regarding error handling and robustness, the specification explicitly classifies this operation as "not exception safe" [SWS_CORE_01371]. Specific AUTOSAR error codes or error messages (DET/DEM) are not provided. Interpretation: Due to the reference "As per corresponding usage in [vector]", runtime behavior—including possible reallocations and the resulting invalidation of existing iterators—likely corresponds to the semantics of std::vector::insert [SWS_CORE_01371]. Question Q-67ac8e3de4d4ce7a (open) Special synchronization mechanisms for concurrent accesses are not specified.

In module core, the function stands in the context of further insertion operations of ara::core::Vector:

• Inserting a single element by copying [SWS_CORE_01367] or move semantics [SWS_CORE_01368],
• Inserting n copies of a value [SWS_CORE_01369],
• Range-based insertion via two input iterators [SWS_CORE_01370].

All overloads in ara::core::Vector share the property of being not exception safe [SWS_CORE_01367], [SWS_CORE_01368], [SWS_CORE_01369], [SWS_CORE_01370].

Usage and Semantics

The member function pop_back of container ara::core::Vector serves to synchronously remove the last element [SWS_CORE_01365]. The function is declared in header file ara/core/vector.h and has the signature void pop_back () [SWS_CORE_01365]. For functional behavior, AUTOSAR explicitly refers to the corresponding usage in [vector], such that no parameters are passed and no return value exists [SWS_CORE_01365].

Error Handling and Exception Safety

Regarding error handling, the specification indicates the property not exception safe [SWS_CORE_01365]. Since no specific error codes, return values, or checking mechanisms are defined in the payload, no integrated error handling exists for invalid invocations [SWS_CORE_01365]. Interpretation: Before calling, the caller must ensure that the vector is not empty; a call on an empty instance is likely to lead to undefined behavior, analogously to [vector]. Question Q-add313a489db4726 (open)

Interaction and related requirements

A corresponding pattern is found in class ara::core::BasicString from ara/core/string.h, whose function pop_back removes the last character according to [basic.string] and is likewise specified as not exception safe [SWS_CORE_03105]. Both definitions unify the modification of sequential data structures in module core [SWS_CORE_01365], [SWS_CORE_03105].

use

The member function push_back in the scope of ara::core::Vector inserts a passed element at the end of the container by copying [SWS_CORE_01363]. It is defined via header #include "ara/core/vector.h", takes a reference to a constant value const T &x, and has no return value (void) [SWS_CORE_01363]. The call occurs synchronously in the caller's context.

Error Handling and Exception Safety

The specification deviates from [vector] in that the function is declared as conditionally noexcept: It is guaranteed to be non-throwing if and only if std::is_nothrow_copy_assignable<T>::value applies [SWS_CORE_01363]. Accordingly, exception safety is defined as “conditionally exception safe” [SWS_CORE_01363]. Specific error codes as well as error messages via DET or DEM are not defined for this function.

Interaction and related requirements

For movable objects, ara::core::Vector provides overload void push_back(T &&x), whose noexcept property is analogously coupled to std::is_nothrow_move_assignable<T>::value [SWS_CORE_01364]. In contrast, push_back in ara::core::BasicString has no noexcept guarantee and is classified as “not exception safe” [SWS_CORE_03083].

Interpretation: The internal memory and reallocation behavior upon insertion, apart from the specific noexcept declaration, is likely to follow the requirements of the C++ standard for [vector]. Question Q-202fb07b334cde64 (open)

The member function push_back of ara::core::Vector serves to synchronously append an element to the end of the vector using move semantics ([SWS_CORE_01364]). It is provided via header #include "ara/core/vector.h", takes an rvalue reference T &&x, and has no return value (void) ([SWS_CORE_01364]).

Regarding error handling and exception behavior, the following properties apply:

• The method is classified as conditionally exception safe (conditionally exception safe) ([SWS_CORE_01364]).
• The noexcept guarantee is tied to the type: noexcept(std::is_nothrow_move_assignable<T>::value) ([SWS_CORE_01364]). If the move assignment operator of T is not declared as exception-free, exceptions are likely to occur during memory allocations or element moves. Question Q-3b8b58d0b218fe21 (open)

The functionality follows the usual semantics in [vector], but deviates due to the conditional noexcept declaration ([SWS_CORE_01364]). Since the operation mutates the container, concurrent accesses to the same instance are likely not thread-safe without external synchronization. Question (open)

In interaction among the interfaces, this move variant complements the copy overload push_back(const T &x) ([SWS_CORE_01363]), which is analogously coupled to is_nothrow_copy_assignable. To be distinguished from this is the identically named member function in ara::core::BasicString ([SWS_CORE_03083]), which appends single characters and is defined as not exception safe.