class ara::core::Vector

Verwendung und Aufrufkontext

Die Template-Elementfunktion assign für ara::core::Vector ersetzt den aktuellen Inhalt des Vektors durch die Elemente des Bereichs [first, last) gemäß der entsprechenden Nutzung in std::vector [SWS_CORE_01328]. Die Funktion ist in der Header-Datei #include "ara/core/vector.h" definiert, nimmt zwei Eingabe-Iteratoren entgegen und gibt keinen Wert zurück (void) [SWS_CORE_01328].

Fehlerbehandlung und Ausnahmesicherheit

Die Zuweisungsfunktion ist als nicht ausnahmesicher (not exception safe) eingestuft [SWS_CORE_01328]. Wenn während der Elementverarbeitung oder bei notwendigen internen Speicherallokationen eine Ausnahme auftritt, verbleibt der Container möglicherweise in einem unvollständigen Zustand ohne definierte Sicherheitsgarantien.

Nebenläufigkeit und Randbedingungen

Für nebenläufige Aufrufe dürfte bei gleichzeitiger Nutzung derselben Instanz von ara::core::Vector eine externe Synchronisation notwendig sein, da die Spezifikation keine Thread-Sicherheit garantiert. Frage Q-5ada879738b3856d (offen) Voraussetzung für den fehlerfreien Ablauf ist zudem, dass first und last einen gültigen Iterator-Bereich aufspannen.

Zusammenspiel im Modul core

Neben der Bereichszuweisung über Iteratoren stehen in ara::core::Vector Überladungen mit Anzahl und Referenzwert [SWS_CORE_01329] sowie für std::initializer_list<T> [SWS_CORE_01330] bereit, die ebenfalls als nicht ausnahmesicher deklariert sind. Vergleichbare Zuweisungsmuster existieren auch im Modulkontext von ara::core::BasicString [SWS_CORE_03091].

Verwendung

Die Funktion assign gehört zur Containerklasse ara::core::Vector und wird über die Header-Datei #include "ara/core/vector.h" bereitgestellt [SWS_CORE_01329]. Mit der Signatur void assign (size_type n, const T &u); ersetzt sie den aktuellen Inhalt des Vektors vollständig durch n Elemente mit dem Wert u. Der Aufruf erfolgt synchron und liefert keinen Rückgabewert (void). Gemäß der Spezifikation richtet sich das Verhalten nach der korrespondierenden Verwendung im Standard-Container [vector] [SWS_CORE_01329], womit vermutlich die Semantik von std::vector::assign gemeint ist. Frage Q-3630162224047ee0 (offen)

Fehlerbehandlung

Hinsichtlich der Ausfallsicherheit ist die Funktion explizit als not exception safe eingestuft [SWS_CORE_01329]. Es werden keine AUTOSAR-spezifischen Fehlercodes, Fehlerklassen oder Meldungen an DET bzw. DEM definiert. Tritt während der Speicherallokation oder beim Zuweisen der Elemente eine Ausnahme auf, bietet die Funktion vermutlich keine Garantien für die Wiederherstellung des ursprünglichen Objektzustands. Frage Q-f4eb9afa74847bf7 (offen)

Nebenläufigkeit und Einschränkungen

Da assign den Zustand und potenziell die Kapazität der Containerinstanz modifiziert, ist der Aufruf nicht reentrant auf derselben Instanz. Mangels gesonderter Thread-Sicherheitszusagen in der Spezifikation dürfte ein nebenläufiger Lese- oder Schreibzugriff auf dasselbe Vector-Objekt ohne externe Synchronisation nicht threadsicher sein. Frage Q-1df95afd2340ec57 (offen)

Zusammenspiel

Die Funktion bildet zusammen mit weiteren Überladungen der Klasse ara::core::Vector die Schnittstelle zur Neubelegung von Vektorinhalten:

• Iteratorbasierte Zuweisung über einen Bereich assign(InputIterator first, InputIterator last) gemäß [SWS_CORE_01328].
• Zuweisung über eine Initialisierungsliste assign(std::initializer_list<T>) gemäß [SWS_CORE_01330].

Beide alternativen Überladungen teilen mit [SWS_CORE_01329] die Eigenschaft, als not exception safe spezifiziert zu sein.

Die Elementfunktion assign der Klasse ara::core::Vector ersetzt den gesamten bisherigen Inhalt einer Vektorinstanz synchron durch die Elemente der bereitgestellten Initialisierungsliste std::initializer_list<T> ([SWS_CORE_01330]). Das funktionale Verhalten folgt dabei der korrespondierenden Verwendung des Standard-Containers in [vector] ([SWS_CORE_01330]). Die Funktion besitzt keinen Rückgabewert (void) und wird über den Header ara/core/vector.h deklariert ([SWS_CORE_01330]).

Für die Fehlerbehandlung ist festgelegt, dass die Methode als not exception safe eingestuft ist ([SWS_CORE_01330]). Interpretation: Tritt während der Speicherallokation oder beim Kopieren bzw. Verschieben der Elemente eine Ausnahme auf, bietet die Implementierung vermutlich keine starke Ausnahmesicherheit; der Vektor dürfte in einem veränderten oder unvollständigen Zustand verbleiben. Frage Q-ac196ecfba85d821 (offen)

Im Zusammenspiel mit weiteren Schnittstellen von ara::core::Vector ergänzt die Funktion alternative Zuweisungsüberladungen wie die Initialisierung über Iterator-Bereiche ([SWS_CORE_01328]) und die wiederholte Zuweisung eines Einzelwerts ([SWS_CORE_01329]). Alle diese assign-Varianten teilen die Eigenschaft, nicht ausnahmesicher zu sein. Eine vergleichbare Zuweisungssemantik mittels std::initializer_list findet sich innerhalb der Kernbibliothek auch bei ara::core::BasicString ([SWS_CORE_03092]).

Verwendung und Semantik

Die Elementfunktion at stellt einen synchronen, lesenden Zugriff auf ein Element des Containers ara::core::Vector am angegebenen Index n bereit und gibt eine const_reference auf das Element zurück [SWS_CORE_01354]. Die Deklaration ist über den Header ara/core/vector.h verfügbar [SWS_CORE_01354]. Die Semantik entspricht der standardmäßigen std::vector::at-Funktion aus dem C++-Standard, unterscheidet sich jedoch bei der Fehlerbehandlung [SWS_CORE_01354].

Fehlerbehandlung und Randbedingungen

Wird ein Index angefordert, der die Containergröße erreicht oder überschreitet (n >= size()), wird eine IsoStdOutOfRangeViolation ausgelöst anstelle der Standard-Ausnahme std::out_of_range [SWS_CORE_01354]. Die Funktion ist als not exception safe deklariert [SWS_CORE_01354]. Interpretation: Da keine C++-Ausnahme geworfen wird, dürfte das Auslösen der Verletzung vermutlich zu einem Abbruch des Programmflusses führen, der potenziell mit Behandlungsmechanismen wie AddAbortHandler interagieren kann [SWS_CORE_00054]. Frage Q-2182d648ff4a28b8 (offen)

Zusammenspiel im Modul

Für modifizierende Zugriffe steht die nicht-konstante Überladung mit der Rückgabe reference bereit, welche demselben Fehlerpfad folgt [SWS_CORE_01355]. Das identische Abweichungsverhalten mit IsoStdOutOfRangeViolation findet sich auch in weiteren Core-Datentypen wie ara::core::Array [SWS_CORE_01273] [SWS_CORE_01274] und ara::core::BasicString [SWS_CORE_03063].

Die Elementfunktion at der Klasse ara::core::Vector ([SWS_CORE_01355]), bereitgestellt über den Header #include "ara/core/vector.h", ermöglicht den indizierten Lese- und Schreibzugriff auf einzelne Elemente eines Vektors. Die Funktion akzeptiert einen Positionsindex n vom Typ size_type und liefert eine modifizierbare Referenz (reference) auf das Element an der angegebenen Position zurück. Die Semantik folgt der korrespondierenden Implementierung in [vector]. Interpretation: Da die Schnittstelle synchron nach C++-Standard deklariert ist, dürfte die Ausführung blockierend direkt im aufrufenden Thread-Kontext erfolgen. Frage Q-81f43622c244ce91 (offen)

Im Unterschied zum ISO-C++-Standardvektor löst die Funktion bei Indexüberschreitungen (n >= size()) die Verletzung IsoStdOutOfRangeViolation anstelle der Standard-Ausnahme std::out_of_range aus ([SWS_CORE_01355]). In der Spezifikation ist die Funktion als nicht ausnahmesicher (not exception safe) eingestuft ([SWS_CORE_01355]). Interpretation: Da für diesen Vektorzugriff keine Synchronisationsmechanismen spezifiziert sind, dürfte ein ungeschützter nebenläufiger Zugriff auf dieselbe Instanz nicht threadsicher sein. Frage Q-e65ae0c574610719 (offen)

Für den konstanten Nur-Lese-Zugriff steht die Überladung const_reference at(size_type n) const zur Verfügung, die ebenfalls IsoStdOutOfRangeViolation meldet und als nicht ausnahmesicher gilt ([SWS_CORE_01354]). Dieselbe Verletzungssemantik bei fehlerhaftem Zugriff nutzen auch verwandte Container und Typen der Core-Bibliothek, darunter ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), ara::core::StringView ([SWS_CORE_02133]) sowie ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).

Verwendung und Semantik

Die Methode clear() der Klasse ara::core::Vector dient dem vollständigen Leeren des Vektors gemäß [SWS_CORE_01375]. Die Funktion ist im Header ara/core/vector.h deklariert, synchron aufrufbar, nimmt keine Parameter entgegen und liefert keinen Rückgabewert (void). Ihre funktionale Semantik richtet sich nach der entsprechenden Spezifikation für [vector]. Interpretation: Dies dürfte bedeuten, dass alle im Vektor vorhandenen Elemente destruiert werden und die Elementanzahl auf 0 sinkt, wobei die zugewiesene Speicherkapazität unverändert erhalten bleiben dürfte. Frage Q-ecde315e61455c32 (offen)

Fehlerbehandlung und Exception-Sicherheit

Für den Aufruf gilt die Kennzeichnung noexcept sowie die Einstufung als ausnahmesicher (exception safe) gemäß [SWS_CORE_01375]. Da die Methode garantiert keine Ausnahmen wirft, existieren keine spezifischen Fehlercodes und es werden weder DET- noch DEM-Fehlermeldungen im Fehlerfall abgesetzt.

Zusammenspiel mit verwandten Containern

Das Konzept einer ausnahmesicheren clear()-Funktion wird in ara::core konsistent auf weitere Datenstrukturen übertragen. So stellt ara::core::Map im Header ara/core/map.h eine identische clear()-Methode gemäß [map] bereit [SWS_CORE_01485]. Ebenso bietet ara::core::BasicString im Header ara/core/string.h eine gleichwertige clear()-Operation gemäß [basic.string] an [SWS_CORE_03057].

Die Elementfunktion crbegin von ara::core::Vector stellt gemäß [SWS_CORE_01342] einen konstanten Umkehr-Iterator (const_reverse_iterator) auf das letzte Element der Sequenz bereit. Der Aufruf erfolgt synchron und parameterlos über den Header ara/core/vector.h. Das Verhalten entspricht der Spezifikation der zugrunde liegenden Standard-C++-Bibliothek für [vector]. Bei einem leeren Container dürfte der zurückgegebene Iterator dem Wert von crend() entsprechen (Interpretation basierend auf [vector]). Frage Q-a2badba87f86486c (offen)

Hinsichtlich der Fehlerbehandlung ist die Schnittstelle mit dem Bezeichner noexcept versehen und als ausnahmesicher (exception safe) deklariert ([SWS_CORE_01342]). Aufrufe werfen keine Ausnahmen und melden keine Fehler an Laufzeit- oder Diagnoseüberwachungen.

Bezüglich Nebenläufigkeit und Einschränkungen ist die Methode als const qualifiziert. Der gleichzeitige lesende Zugriff auf dieselbe Instanz aus mehreren Threads dürfte reentrant und threadsicher sein, solange keine konkurrierenden Schreiboperationen auf den Vektor ausgeführt werden (Interpretation analog zum C++-Containermodell). Frage Q-094ba5878c1adc74 (offen)

Im Modul core ist das Konzept der konstanten Rückwärtsiteration konsistent über diverse Typen hinweg implementiert. Ähnliche Schnittstellen finden sich bei ara::core::Array ([SWS_CORE_01260]), ara::core::Map ([SWS_CORE_01450]), ara::core::Span ([SWS_CORE_01978]), ara::core::StringView ([SWS_CORE_02126]) sowie ara::core::BasicString ([SWS_CORE_03049]).

Die Elementfunktion crend der Klasse ara::core::Vector stellt einen konstanten Reverse-Iterator bereit, der auf das theoretische Element vor dem ersten Element des Vektors verweist [SWS_CORE_01343]. Die Semantik folgt der entsprechenden Verwendung im C++-Standard für std::vector („As per corresponding usage in [vector]“) [SWS_CORE_01343].

Verwendung und Verhalten

• Aufrufkontext und Parameter: Die Methode ist parameterlos und als const deklariert, sodass sie auf konstanten wie nicht-konstanten Instanzen von ara::core::Vector synchron aufgerufen werden kann [SWS_CORE_01343].
• Rückgabewert: Es wird ein const_reverse_iterator zurückgegeben, der das logische Ende einer rückwärtsgerichteten Iteration markiert [SWS_CORE_01343].

Fehlerbehandlung und Exception-Sicherheit

Die Funktion ist mit noexcept spezifiziert und gilt laut Spezifikation als ausnahmesicher („exception safe“) [SWS_CORE_01343]. Es werden keine spezifischen Fehlercodes zurückgegeben, und es treten keine Exceptions auf.

Zusammenspiel mit verwandten Containern

Das Konzept eines konstanten Reverse-Iterators zum Endpunkt einer Rückwärtsiteration wird containerübergreifend in ara::core einheitlich bereitgestellt. Ähnliche Schnittstellen mit identischer Ausnahmebehandlung (noexcept) existieren unter anderem für ara::core::Array [SWS_CORE_01261], ara::core::Map [SWS_CORE_01451], ara::core::Span [SWS_CORE_01979], ara::core::StringView [SWS_CORE_02127] sowie ara::core::BasicString [SWS_CORE_03050].

Die Funktion emplace fügt ein Element an der angegebenen Position direkt in einen ara::core::Vector ein, indem übergebene Argumente weitergeleitet werden [SWS_CORE_01366]. Die Deklaration befindet sich im Header #include "ara/core/vector.h" und folgt der entsprechenden Verwendung in [vector] [SWS_CORE_01366].

Verwendung

Der Aufruf von emplace erfolgt synchron und nimmt als Parameter einen Positionsiterator position vom Typ const_iterator sowie ein Parameterpaket args vom Typ Args&&... entgegen [SWS_CORE_01366]. Als Rückgabewert liefert die Funktion einen iterator auf das neu konstruierte Element [SWS_CORE_01366].

Fehlerbehandlung und Nebenläufigkeit

Für emplace in ara::core::Vector ist die Exception-Sicherheit explizit als not exception safe spezifiziert [SWS_CORE_01366]. Spezifische Fehlercodes, DET- oder DEM-Meldungen sind im Standard nicht definiert. Interpretation: Mangels interner Synchronisationsmechanismen dürfte der nebenläufige Aufruf von emplace auf derselben Instanz ohne externe Absicherung nicht threadsicher sein. Frage Q-d72278df37e86c8a (offen)

Zusammenspiel

Innerhalb von ara::core variiert die Ausnahmesicherheit für emplace je nach Typ:

• In ara::core::Map ist emplace ebenfalls als not exception safe definiert, liefert jedoch std::pair<iterator, bool> zurück [SWS_CORE_01458].
• In ara::core::Optional sind die Varianten bedingt ausnahmesicher ([SWS_CORE_01119], [SWS_CORE_01120]) bzw. für Referenzen vollständig ausnahmesicher [SWS_CORE_01164].
• In ara::core::Variant ist emplace als conditionally exception safe mit noexcept deklariert ([SWS_CORE_01661], [SWS_CORE_01662], [SWS_CORE_01663], [SWS_CORE_01664]).

Verwendung

Die Template-Methode emplace_back der Klasse ara::core::Vector dient gemäß [SWS_CORE_01362] dazu, ein neues Element direkt am Ende des Vektors zu konstruieren. Die Übergabeparameter Args&&... args werden dabei entsprechend der Semantik von [vector] direkt an den Konstruktor des Elementtyps weitergereicht. Als Rückgabewert liefert die Funktion eine Referenz (reference) auf das neu erzeugte Element zurück. Zur Nutzung muss der Header #include "ara/core/vector.h" eingebunden werden [SWS_CORE_01362].

Fehlerbehandlung und Exception-Sicherheit

Hinsichtlich der Exception-Sicherheit ist die Operation in [SWS_CORE_01362] explizit als not exception safe deklariert. Spezifische Fehlercodes, Rückfallwerte oder Meldungen an Fehlerdienste wie DET oder DEM werden in der Spezifikation nicht definiert.

Einschränkungen und Verhalten

Aufgrund der Eigenschaft not exception safe und der Orientierung an [vector] dürfte im Fehlerfall, beispielsweise bei einer fehlschlagenden Speicherallokation oder Konstruktion, keine Garantie für den Erhalt des bisherigen Containerzustands bestehen (Interpretation). Frage Q-ca44b2f27d8ae1c8 (offen) Aufrufer müssen daher sicherstellen, dass mögliche Fehlerbedingungen vorab vermieden werden.

Die Funktion erase der Klasse ara::core::Vector dient gemäß [SWS_CORE_01372] dem synchronen Entfernen eines einzelnen Elements an der durch den Parameter position (const_iterator) bezeichneten Stelle. Als Rückgabewert liefert sie einen iterator auf das nachfolgende Element beziehungsweise das Containerende, falls das gelöschte Element an letzter Position stand, entsprechend der referenzierten Semantik in [vector]. Deklariert ist die Funktion in der Header-Datei #include "ara/core/vector.h".

In Bezug auf die Fehlerbehandlung ist die Operation in der Spezifikation ausdrücklich als nicht ausnahmesicher („not exception safe“) ausgewiesen [SWS_CORE_01372]. Es sind keine spezifischen Fehlerrückgaben, DET- oder DEM-Meldungen definiert; ungültige oder nicht dereferenzierbare Iteratoren dürften daher zu undefiniertem Verhalten führen. Frage Q-efa4c40e48a6f98d (offen) Durch die Verschiebung der Elemente im Vektor ist als Interpretation: anzunehmen, dass nachfolgende Iteratoren und Referenzen ungültig werden, wie es der Standardsemantik von [vector] entspricht.

Im Zusammenspiel innerhalb von ara::core::Vector existiert neben dem Löschen an einer Einzelposition die Überladung erase(first, last) für ganze Bereiche gemäß [SWS_CORE_01373]. Analoge Schnittstellen zum Entfernen von Einträgen finden sich in weiteren Containern der Adaptive-Core-Bibliothek: ara::core::Map stellt positions- und schlüsselbasierte Überladungen bereit ([SWS_CORE_01480], [SWS_CORE_01481], [SWS_CORE_01482], [SWS_CORE_01483]), während ara::core::BasicString index- und iteratorbasierte Varianten umfasst ([SWS_CORE_03102], [SWS_CORE_03103], [SWS_CORE_03104]).

Die Elementfunktion erase der Klasse ara::core::Vector dient dem Entfernen eines Bereichs von Elementen aus dem Vektor gemäß der Spezifikation [SWS_CORE_01373]. Die Deklaration ist über den Header ara/core/vector.h verfügbar. Die Semantik folgt der entsprechenden Nutzung im Standard-Vektor („As per corresponding usage in [vector]“). Als Parameter werden zwei Iteratoren first und last übergeben, die den zu löschenden Bereich abgrenzen; zurückgegeben wird ein iterator auf das nachfolgende Element.

Hinsichtlich der Fehlerbehandlung und Ausnahme-Sicherheit ist die Operation in der Spezifikation explizit als „not exception safe“ klassifiziert [SWS_CORE_01373]. Spezifische Fehlercodes oder Fehler-Verletzungen (Violations) sind für diese Funktion im Gegensatz zu anderen Container-Operationen nicht definiert. Sollte bei der Durchführung ein Fehler auftreten, hinterlässt dies den Container vermutlich in einem inkonsistenten Zustand. Frage (offen)

Bezüglich der Nebenläufigkeit und Einschränkungen schweigt die Spezifikation; modifizierende Operationen an ara::core::Vector dürften jedoch nicht reentrant sein und bedürfen im Mehrthread-Betrieb voraussichtlich einer externen Absicherung. Frage Q-07fc291a523a82f1 (offen)

Im Zusammenspiel mit weiteren Schnittstellen des Core-Moduls ergänzt diese Funktion die Überladung zur Entfernung eines Einzelelements an einer bestimmten Position mittels iterator erase(const_iterator position) [SWS_CORE_01372]. Korrespondierende Bereichslöschungen nach dem gleichen Muster sind auch für assoziative Container wie ara::core::Map über [SWS_CORE_01483] sowie Zeichenketten in ara::core::BasicString über [SWS_CORE_03104] definiert.

Verwendung

Die Elementfunktion insert der Klasse ara::core::Vector dient dem synchronen Einfügen eines Elements an einer vorgegebenen Position [SWS_CORE_01367]. Sie ist im Header #include "ara/core/vector.h" definiert [SWS_CORE_01367]. Die Funktion übernimmt als Parameter einen Iterator position vom Typ const_iterator, der die Zielposition markiert, sowie eine konstante Referenz x auf das einzufügende Objekt vom Typ const T & [SWS_CORE_01367]. Der Rückgabewert ist ein iterator, der auf das neu eingefügte Element verweist [SWS_CORE_01367]. Das funktionale Verhalten richtet sich dabei nach der Verwendung im Standard-Vektor („As per corresponding usage in [vector]“) [SWS_CORE_01367].

Fehlerbehandlung und Einschränkungen

Die Spezifikation stuft die Funktion ausdrücklich als nicht ausnahmesicher („not exception safe“) ein [SWS_CORE_01367]. Spezifische Fehlercodes, Rückgabewerte für Fehlerfälle oder Meldungen an DET oder DEM sind nicht definiert. Interpretation: Schlägt eine interne Speicherallokation oder das Kopieren des Elements fehl, dürfte keine Gewährleistung für den Erhalt des Containerzustands oder die Gültigkeit von Iteratoren bestehen. Frage Q-d2b5552bb124d16e (offen)

Zusammenspiel

Innerhalb von ara::core::Vector existieren mehrere Überladungen von insert, die alternative Einfügeoperationen ermöglichen:

• Einfügen eines Elements über Rvalue-Referenz T &&x [SWS_CORE_01368],
• Einfügen einer bestimmten Anzahl identischer Elemente mit size_type n, const T &x [SWS_CORE_01369],
• Einfügen einer Sequenz über einen Iteratorbereich [first, last) [SWS_CORE_01370],
• Einfügen über eine Initialisierungsliste std::initializer_list<T> [SWS_CORE_01371].

Analoge insert-Methoden definieren im Modul core auch assoziative Container wie ara::core::Map [SWS_CORE_01460] sowie Zeichenkettenklassen wie ara::core::BasicString [SWS_CORE_03093].

Verwendung

Die Methode insert gemäß [SWS_CORE_01368] ist im Header #include "ara/core/vector.h" als Elementfunktion der Klasse ara::core::Vector definiert. Sie dient dem synchronen Einfügen eines Elements über eine Rvalue-Referenz (T&& x) an der Position vor dem Iterator position. Gemäß Verweis auf [vector] dürfte die Funktion den Inhalt von x per Move-Semantik in den Vektor übertragen und einen iterator auf das neu eingefügte Element zurückgeben. Frage Q-97f2551da8fd303f (offen)

Fehlerbehandlung und Einschränkungen

Die Spezifikation stuft die Funktion in [SWS_CORE_01368] als not exception safe ein. Spezifische Fehlercodes, Rückgabewerte zur Fehleranzeige oder Meldungen an DET oder DEM sind nicht definiert. Interpretation: Schlägt eine interne Speicherallokation oder das Verschieben der Elemente fehl, dürfte keine Ausnahme-Sicherheit garantiert sein, was den Container in einem inkonsistenten Zustand hinterlassen oder zum Abbruch führen kann. Frage Q-297ef8ff6f6eb76b (offen) Zudem existiert vermutlich kein interner Nebenläufigkeitsschutz, weshalb gleichzeitige Zugriffe extern synchronisiert werden müssen.

Zusammenspiel

Die Rvalue-Variante [SWS_CORE_01368] bildet mit weiteren insert-Überladungen von ara::core::Vector eine zusammenhängende Schnittstelle:

• [SWS_CORE_01367]: Kopierendes Einfügen eines Werts mittels Lvalue-Referenz (const T& x).
• [SWS_CORE_01369]: Einfügen von n Kopien eines Werts (size_type n, const T& x).
• [SWS_CORE_01370]: Einfügen einer Sequenz über einen Iteratorbereich (InputIterator first, InputIterator last).
• [SWS_CORE_01371]: Einfügen einer Liste mittels std::initializer_list<T>.

Die Elementfunktion insert aus [SWS_CORE_01369] gehört zur Klasse ara::core::Vector und wird über die Header-Datei #include "ara/core/vector.h" bereitgestellt. Die synchrone Operation dient dem Einfügen mehrerer identischer Elemente. Interpretation: Gemäß dem spezifizierten Verweis „As per corresponding usage in [vector]“ dürfte der Aufruf genau n Kopien des übergebenen Werts x unmittelbar vor der Iterator-Position position in den Vektor einfügen und einen iterator auf das erste neu eingefügte Element zurückgeben. Frage Q-c92add148c490868 (offen)

Hinsichtlich der Fehlerbehandlung und Robustheit ist die Funktion in [SWS_CORE_01369] ausdrücklich als „not exception safe“ klassifiziert. Spezifische AUTOSAR-Fehlercodes oder Meldungen an DET oder DEM sind für diesen Methodenaufruf nicht vorgesehen.

Zu den Nebenläufigkeits- und Aufrufbedingungen enthält die Spezifikation keine gesonderten Garantien. Vermutlich erfordert die Modifikation des Containers wie bei Standard-Vektoren eine externe Synchronisation, da konkurrierende Schreib- oder Lesezugriffe nicht threadsicher sein dürften. Frage (offen)

Innerhalb von ara::core::Vector existieren neben dieser Überladung für wiederholte Werte weitere Varianten von insert:

• Einfügen eines einzelnen Werts per Kopie ([SWS_CORE_01367]) oder per Move-Semantik ([SWS_CORE_01368]).
• Einfügen eines Wertebereichs über Input-Iteratoren ([SWS_CORE_01370]) oder über eine std::initializer_list ([SWS_CORE_01371]).

Die Template-Elementfunktion insert des sequenziellen Containers ara::core::Vector ([SWS_CORE_01370]) aus dem Header #include "ara/core/vector.h" fügt eine Sequenz von Elementen synchron in den Vektor ein. Der einzufügende Bereich wird über die Eingabe-Iteratoren first und last bestimmt und unmittelbar vor der durch position (Typ const_iterator) bezeichneten Stelle platziert. Als Rückgabewert liefert die Funktion einen iterator, der auf das erste eingefügte Element verweist. Die fachliche Semantik wird spezifikationsseitig mit „As per corresponding usage in [vector]“ ([SWS_CORE_01370]) beschrieben; Interpretation: Dies dürfte dem standardisierten Bereichs-Einfügeverhalten von std::vector entsprechen. Frage Q-c6cd06fb1964ead6 (offen)

Bezüglich der Fehlerbehandlung und Robustheit ist die Funktion ausdrücklich als not exception safe spezifiziert ([SWS_CORE_01370]). Besondere Fehlercodes, Ausnahmen oder Meldungen an Fehler- und Diagnosemonitore (wie DET oder DEM) sind im Spezifikationsumfang nicht vorgesehen.

Im Rahmen der Schnittstelle von ara::core::Vector ergänzt diese Bereichsüberladung die übrigen Einfügemethoden:

• das Einfügen eines einzelnen Werts per Kopie ([SWS_CORE_01367]) oder per Move-Semantik ([SWS_CORE_01368]),
• das Einfügen einer festgelegten Anzahl identischer Werte ([SWS_CORE_01369]),
• sowie das Einfügen aus einer Initialisierungsliste via std::initializer_list ([SWS_CORE_01371]).

Alle genannten Überladungen innerhalb des Vektors teilen die Einschränkung, nicht ausnahmesicher zu sein ([SWS_CORE_01367], [SWS_CORE_01371]).

Die synchrone Memberfunktion insert der Klasse ara::core::Vector fügt die Elemente einer Initialisierungsliste an einer vorgegebenen Position in den Container ein [SWS_CORE_01371]. Sie ist in der Header-Datei ara/core/vector.h deklariert [SWS_CORE_01371]. Als Parameter erwartet die Funktion einen Iterator position vom Typ const_iterator, der die Einfügestelle markiert, sowie il vom Typ std::initializer_list<T> [SWS_CORE_01371]. Der Rückgabewert ist ein iterator auf das erste eingefügte Element beziehungsweise auf position, falls die Liste leer ist [SWS_CORE_01371].

Bezüglich der Fehlerbehandlung und Robustheit stuft die Spezifikation diese Operation explizit als „not exception safe“ ein [SWS_CORE_01371]. Spezifische AUTOSAR-Fehlercodes oder Fehlermeldungen (DET/DEM) sind nicht vorgesehen. Interpretation: Durch den Verweis „As per corresponding usage in [vector]“ dürfte das Laufzeitverhalten, einschließlich möglicher Reallokationen und der damit einhergehenden Ungültigkeit bestehender Iteratoren, der Semantik von std::vector::insert entsprechen [SWS_CORE_01371]. Frage Q-67ac8e3de4d4ce7a (offen) Besondere Synchronisationsmechanismen für nebenläufige Zugriffe sind nicht spezifiziert.

Im Modul core steht die Funktion im Kontext weiterer Einfügeoperationen von ara::core::Vector:

• Einfügen eines Einzelelements durch Kopieren [SWS_CORE_01367] oder Move-Semantik [SWS_CORE_01368],
• Einfügen von n Kopien eines Werts [SWS_CORE_01369],
• Bereichsbasiertes Einfügen über zwei Eingabe-Iteratoren [SWS_CORE_01370].

Sämtliche Überladungen in ara::core::Vector teilen die Eigenschaft, nicht ausnahmesicher zu sein [SWS_CORE_01367], [SWS_CORE_01368], [SWS_CORE_01369], [SWS_CORE_01370].

Verwendung und Semantik

Die Elementfunktion pop_back des Containers ara::core::Vector dient dem synchronen Entfernen des letzten Elements [SWS_CORE_01365]. Die Funktion ist in der Header-Datei ara/core/vector.h deklariert und besitzt die Signatur void pop_back () [SWS_CORE_01365]. AUTOSAR verweist für das funktionale Verhalten explizit auf die entsprechende Verwendung in [vector], sodass keine Parameter übergeben werden und kein Rückgabewert existiert [SWS_CORE_01365].

Fehlerbehandlung und Exception-Sicherheit

Hinsichtlich der Fehlerbehandlung weist die Spezifikation die Eigenschaft not exception safe aus [SWS_CORE_01365]. Da keine spezifischen Fehlercodes, Rückgabewerte oder Prüfmechanismen im Payload definiert sind, existiert keine integrierte Fehlerbehandlung bei unzulässigen Aufrufen [SWS_CORE_01365]. Interpretation: Vor dem Aufruf muss der Aufrufer sicherstellen, dass der Vektor nicht leer ist; ein Aufruf auf einer leeren Instanz dürfte analog zu [vector] zu undefiniertem Verhalten führen. Frage Q-add313a489db4726 (offen)

Zusammenspiel und verwandte Anforderungen

Ein korrespondierendes Muster findet sich in der Klasse ara::core::BasicString aus ara/core/string.h, deren Funktion pop_back das letzte Zeichen gemäß [basic.string] entfernt und gleichermaßen als not exception safe spezifiziert ist [SWS_CORE_03105]. Beide Definitionen vereinheitlichen die Modifikation sequentieller Datenstrukturen im Modul core [SWS_CORE_01365], [SWS_CORE_03105].

Verwendung

Die Elementfunktion push_back im Scope von ara::core::Vector fügt ein übergebenes Element durch Kopieren am Ende des Containers ein [SWS_CORE_01363]. Sie ist über den Header #include "ara/core/vector.h" definiert, nimmt eine Referenz auf einen konstanten Wert const T &x entgegen und besitzt keinen Rückgabewert (void) [SWS_CORE_01363]. Der Aufruf erfolgt synchron im Kontext des Aufrufers.

Fehlerbehandlung und Ausnahmesicherheit

Die Spezifikation weicht von [vector] darin ab, dass die Funktion als bedingt noexcept deklariert ist: Sie ist genau dann als nicht-werfend garantiert, wenn std::is_nothrow_copy_assignable<T>::value zutrifft [SWS_CORE_01363]. Entsprechend ist die Exception-Sicherheit als „conditionally exception safe“ definiert [SWS_CORE_01363]. Spezifische Fehlercodes sowie Fehlermeldungen über DET oder DEM sind für diese Funktion nicht definiert.

Zusammenspiel und verwandte Anforderungen

Für bewegliche Objekte stellt ara::core::Vector die Überladung void push_back(T &&x) bereit, deren noexcept-Eigenschaft analog an std::is_nothrow_move_assignable<T>::value gekoppelt ist [SWS_CORE_01364]. Im Gegensatz dazu besitzt push_back in ara::core::BasicString keine Noexcept-Garantie und ist als „not exception safe“ klassifiziert [SWS_CORE_03083].

Interpretation: Das interne Speicher- und Reallokationsverhalten beim Einfügen dürfte sich, abgesehen von der spezifischen noexcept-Deklaration, an den Vorgaben des C++-Standards für [vector] orientieren. Frage Q-202fb07b334cde64 (offen)

Die Elementfunktion push_back von ara::core::Vector dient dem synchronen Anhängen eines Elements an das Ende des Vektors unter Nutzung von Move-Semantik ([SWS_CORE_01364]). Sie wird über den Header #include "ara/core/vector.h" bereitgestellt, nimmt eine Rvalue-Referenz T &&x entgegen und besitzt keinen Rückgabewert (void) ([SWS_CORE_01364]).

Hinsichtlich Fehlerbehandlung und Ausnahmeverhalten gelten folgende Eigenschaften:

• Die Methode ist als bedingt ausnahmesicher (conditionally exception safe) eingestuft ([SWS_CORE_01364]).
• Die noexcept-Garantie ist an den Typ gebunden: noexcept(std::is_nothrow_move_assignable<T>::value) ([SWS_CORE_01364]). Ist der Move-Zuweisungsoperator von T nicht als ausnahmefrei deklariert, dürften bei Speicherallokationen oder Elementverschiebungen Ausnahmen auftreten. Frage Q-3b8b58d0b218fe21 (offen)

Die Funktionsweise folgt der üblichen Semantik in [vector], weicht jedoch durch die bedingte noexcept-Deklaration ab ([SWS_CORE_01364]). Da die Operation den Container mutiert, dürften gleichzeitige Zugriffe auf dieselbe Instanz ohne externe Synchronisation nicht threadsicher sein. Frage (offen)

Im Zusammenspiel der Schnittstellen ergänzt diese Move-Variante die Copy-Überladung push_back(const T &x) ([SWS_CORE_01363]), welche analog an is_nothrow_copy_assignable gekoppelt ist. Davon abzugrenzen ist die gleichnamige Elementfunktion in ara::core::BasicString ([SWS_CORE_03083]), die einzelne Zeichen anfügt und als nicht ausnahmesicher definiert ist.