class ara::core::BasicString

Der Zuweisungsoperator operator+= der Klasse ara::core::BasicString ([SWS_CORE_03072] aus #include "ara/core/string.h") hängt den Inhalt einer übergebenen BasicString-Instanz synchron an das aktuelle Objekt an. Die funktionale Semantik folgt dabei der entsprechenden Verwendung in [basic.string] ([SWS_CORE_03072]). Der Aufruf gibt eine Referenz auf die modifizierte Instanz (*this) zurück, wodurch Zuweisungsketten ermöglicht werden.

In Bezug auf die Fehlerbehandlung ist die Operation in der Spezifikation explizit als „not exception safe“ deklariert ([SWS_CORE_03072]). Spezifische Fehlercodes oder Benachrichtigungsmechanismen über DET oder DEM sind für dieses Element nicht definiert. Sollte eine interne Speicherallokation fehlschlagen, bietet die Methode demnach keine Ausnahme-Sicherheitsgarantie.

Hinsichtlich Nebenläufigkeit und Einschränkungen ist zu beachten, dass der Aufruf den Zustand der Instanz direkt modifiziert. Da der Payload keine Synchronisationsmechanismen nennt, dürfte ein nebenläufiger Lese- oder Schreibzugriff auf dasselbe Objekt über mehrere Threads hinweg ohne externe Synchronisation nicht threadsicher sein. Frage Q-352f9d72ad3dfdbd (offen)

Der Operator bildet zusammen mit weiteren Überladungen von operator+= die Schnittstelle zur Zeichenkettenerweiterung, etwa für Einzelzeichen ([SWS_CORE_03074]), rohe Zeichenzeiger ([SWS_CORE_03073]), Initialisierungslisten ([SWS_CORE_03075]) sowie StringView ([SWS_CORE_03307]). Sämtliche dieser Modifikationsoperatoren teilen die Eigenschaft „not exception safe“ und ergänzen die grundlegenden Konstruktoren von ara::core::BasicString ([SWS_CORE_03024], [SWS_CORE_03025]).

Verwendung

Der Zuweisungsoperator operator+= der Klasse ara::core::BasicString hängt eine zeigerbasierte Zeichenkette synchron an die bestehende Zeichenkette an und gibt eine Referenz auf das modifizierte Objekt zurück [SWS_CORE_03073]. Die Funktion wird über die Header-Datei #include "ara/core/string.h" eingebunden und nimmt als Parameter einen Zeiger s vom Typ const value_type * entgegen [SWS_CORE_03073]. Die funktionale Semantik folgt der standardisierten Definition aus [basic.string], wobei als wesentliche Abweichung der Standard-Zeichentyp charT durch value_type ersetzt ist [SWS_CORE_03073].

Fehlerbehandlung und Einschränkungen

In Bezug auf die Exception-Sicherheit ist die Elementfunktion explizit als nicht ausnahmesicher („not exception safe“) deklariert [SWS_CORE_03073]. Spezifische Fehlercodes, Rückgabewerte zur Fehleranzeige oder Fehlermeldungen an DET oder DEM sind für diesen Operator nicht spezifiziert. Interpretation: Bei einem Fehlschlagen notwendiger interner Speicherallokationen während der Vergrößerung der Zeichenkette dürfte folglich kein konsistenter Objektzustand garantiert sein und es existiert kein gesonderter Fehlerkanal im AUTOSAR-Adaptive-Umfeld. Frage Q-a1498ddbc09bcfa9 (offen)

Zusammenspiel

Die Methode ergänzt die weiteren Zuweisungsoperatoren innerhalb von ara::core::BasicString, welche das Anhängen vollständiger Zeichenketten-Instanzen [SWS_CORE_03072], einzelner Zeichen [SWS_CORE_03074], Initialisiererlisten [SWS_CORE_03075] oder StringView-Objekten [SWS_CORE_03307] realisieren. Wie auch die Konstruktoren für rohe Zeichenzeiger [SWS_CORE_03028] [SWS_CORE_03029] sind alle diese Varianten als nicht ausnahmesicher spezifiziert.

Die Elementfunktion operator+= der Klasse ara::core::BasicString ermöglicht das synchrone Anhängen eines einzelnen Zeichens c vom Typ value_type an das aufrufende Zeichenkettenobjekt [SWS_CORE_03074]. Die Deklaration ist im Header ara/core/string.h enthalten [SWS_CORE_03074]. Das Verhalten entspricht der Spezifikation in [basic.string], wobei abweichend der Parametertyp charT durch value_type ersetzt wurde [SWS_CORE_03074]. Als Rückgabewert wird eine Referenz auf das modifizierte Objekt (BasicString &) bereitgestellt, was verkettete Aufrufe unterstützt.

In Bezug auf Robustheit und Fehlerbehandlung ist die Operation als not exception safe klassifiziert [SWS_CORE_03074]. Spezifische Fehlercodes sowie Meldungen an DET oder DEM sind für diese Funktion nicht definiert. Interpretation: Die Einstufung als nicht ausnahmesicher dürfte darauf beruhen, dass bei Überschreitung der aktuellen Pufferkapazität eine dynamische Allokation über den zugrundeliegenden Allokator ausgelöst werden muss, die bei Speichermangel fehlschlagen kann. Frage Q-d74ec80829327ce0 (offen)

Hinsichtlich Nebenläufigkeit und Randbedingungen modifiziert die Funktion die Instanz direkt; gleichzeitige Lese- oder Schreibzugriffe ohne externe Synchronisation sind daher nicht sicher. Im Zusammenspiel mit anderen Schnittstellen ergänzt der Operator die Instanziierung über Konstruktoren wie [SWS_CORE_03024] oder [SWS_CORE_03025] sowie alternative Verbundzuweisungen für ganze Zeichenketten [SWS_CORE_03072], Zeichenketten-Zeiger [SWS_CORE_03073], Initialisierungslisten [SWS_CORE_03075] und String-Ansichten [SWS_CORE_03307].

Die Elementfunktion operator+= von ara::core::BasicString ([SWS_CORE_03075]) hängt die Zeichen einer std::initializer_list<value_type> synchron an das bestehende String-Objekt an. Als Rückgabewert liefert die Methode eine Referenz auf die modifizierte Zeichenkette (*this). Das Verhalten richtet sich nach dem C++-Standard für [basic.string], wobei charT durch value_type ersetzt ist ([SWS_CORE_03075]). Zur Nutzung ist der Header ara/core/string.h einzubinden ([SWS_CORE_03075]).

Hinsichtlich der Fehlerbehandlung und Robustheit ist die Funktion als not exception safe eingestuft ([SWS_CORE_03075]). Interpretation: Es ist zu vermuten, dass bei unzureichendem Speicher während einer notwendigen Reallokation Ausnahmen ausgelöst werden können, ohne dass eine starke Exception-Garantie für den bisherigen Pufferinhalt zugesichert wird. Frage Q-0f3d6328fb6bfd73 (offen)

Bezüglich Nebenläufigkeit und Einschränkungen erfolgt der Aufruf synchron im Kontext des aufrufenden Threads. Da die aufgerufene Instanz direkt modifiziert wird, ist der gleichzeitige Zugriff mehrerer Threads ohne externe Synchronisation nicht threadsicher.

Im Zusammenspiel mit anderen Schnittstellen ergänzt diese Überladung die weiteren Anhängeoperatoren von ara::core::BasicString, darunter das Anfügen von Strings ([SWS_CORE_03072]), Zeichenarrays ([SWS_CORE_03073]), Einzelzeichen ([SWS_CORE_03074]) oder einem StringView ([SWS_CORE_03307]). Zudem korrespondiert die Initialisierungsliste semantisch mit dem entsprechenden Konstruktor ([SWS_CORE_03032]).

Die Elementfunktion operator+= der Klasse ara::core::BasicString hängt eine durch StringView sv übergebene Zeichenfolge synchron an das aufrufende String-Objekt an und gibt eine Referenz auf dieses modifizierte Objekt zurück [SWS_CORE_03307]. Definiert wird die Operation über die Header-Datei #include "ara/core/string.h", wobei das funktionale Verhalten den allgemeinen Konventionen aus [basic.string] folgt [SWS_CORE_03307].

Fehlerbehandlung und Nebenläufigkeit

In Bezug auf die Ausführung ist die Funktion ausdrücklich als not exception safe klassifiziert [SWS_CORE_03307]. Es werden keine spezifischen Fehlercodes für DET oder DEM vorgegeben. Sollte bei der Verlängerung der Zeichenkette eine interne Speicherallokation fehlschlagen, dürfte der interne Zustand der Instanz nicht garantiert unverändert bleiben. Mangels integrierter Synchronisationsmechanismen ist bei konkurrierendem Schreib- oder Lesezugriff mehrerer Threads auf dieselbe Instanz von fehlender Threadsicherheit auszugehen (Interpretation). Frage Q-1bed85bd42475f62 (offen)

Zusammenspiel

Der Operator fügt sich nahtlos in das Gefüge der Klasse ara::core::BasicString ein und ergänzt die alternativen Überladungen von operator+= für vollständige Strings [SWS_CORE_03072], Zeichen-Pointer const value_type* [SWS_CORE_03073], Einzelzeichen [SWS_CORE_03074] und Initialisierungslisten [SWS_CORE_03075]. Die Erzeugung der beteiligten String-Instanzen erfolgt über die zugehörigen Konstruktoren der Klasse, etwa den Standardkonstruktor [SWS_CORE_03024] oder Kopier- und Verschiebekonstruktoren [SWS_CORE_03033], [SWS_CORE_03034].

Verwendung

Die Funktion BasicString() aus der Header-Datei #include "ara/core/string.h" ist der parameterlose Standardkonstruktor der Klasse ara::core::BasicString ([SWS_CORE_03024]). Der Aufruf erfolgt synchron und liefert als Konstruktor keinen Rückgabewert. Das Verhalten richtet sich nach der entsprechenden Definition in [basic.string] ([SWS_CORE_03024]); die erzeugte Instanz dürfte demnach eine leere Zeichenkette repräsentieren. Frage Q-f36b11fa590a6111 (offen)

Fehlerbehandlung und Ausnahmesicherheit

Das Element ist als bedingt ausnahmesicher (conditionally exception safe) spezifiziert ([SWS_CORE_03024]). Spezifische Fehlercodes, DET- oder DEM-Meldungen existieren laut Spezifikation nicht. Über die Signatur BasicString () noexcept(noexcept(Allocator())); ist die Ausnahmesicherheit direkt an den Standardkonstruktor des Allokators gekoppelt ([SWS_CORE_03024]). Wirft die Erzeugung von Allocator() keine Exception, verhält sich auch die Konstruktion von BasicString garantiert ausnahmefrei.

Zusammenspiel und Einschränkungen

Im Kontext der weiteren Schnittstellen von ara::core::BasicString sind folgende Abhängigkeiten relevant:

• Wird ein bereits instanziierter Allokator übergeben, garantiert die Signatur uneingeschränkte Ausnahmesicherheit (exception safe / noexcept) ([SWS_CORE_03025]).
• Andere Initialisierungen – etwa über Teilbereiche ([SWS_CORE_03026], [SWS_CORE_03027]), Zeiger ([SWS_CORE_03028], [SWS_CORE_03029]), Zeichenfolgen ([SWS_CORE_03030]), Iteratoren ([SWS_CORE_03031]), Initialisierungslisten ([SWS_CORE_03032]) oder Kopier- und Verschiebeoperationen mit Allokator ([SWS_CORE_03033], [SWS_CORE_03034]) – sind demgegenüber als not exception safe eingestuft.
• Die initialisierte Instanz kann synchron erweitert werden, unter anderem durch Überladungen von operator+= für Zeichenketten ([SWS_CORE_03072]), Zeichenzeiger ([SWS_CORE_03073]), Einzelzeichen ([SWS_CORE_03074]), Initializer-Lists ([SWS_CORE_03075]) sowie StringView ([SWS_CORE_03307]).
• Zudem kann das Objekt zur Konstruktion eines Bitset herangezogen werden ([SWS_CORE_01749]).

Der explizite Konstruktor BasicString(const Allocator &a) aus der Header-Datei #include "ara/core/string.h" initialisiert eine leere Instanz von ara::core::BasicString unter Verwendung des übergebenen Allokators [SWS_CORE_03025]. Das semantische Verhalten richtet sich nach dem C++-Standardabschnitt [basic.string] [SWS_CORE_03025]. Durch das Schlüsselwort explicit werden unbeabsichtigte implizite Typkonvertierungen aus einer Allokatorinstanz unterbunden [SWS_CORE_03025].

Hinsichtlich der Fehlerbehandlung und Ausnahmebehandlung ist die Funktion als noexcept deklariert und als ausnahmesicher (exception safe) spezifiziert [SWS_CORE_03025]. Im Unterschied zum Standardkonstruktor [SWS_CORE_03024], dessen Ausnahmesicherheit bedingt von noexcept(noexcept(Allocator())) abhängt, garantiert dieser Aufruf stets ein fehlerfreies Erzeugen ohne Ausnahmen [SWS_CORE_03025], [SWS_CORE_03024]. Interpretation: Die unbedingte Ausnahmesicherheit dürfte darauf beruhen, dass bei der Initialisierung einer leeren Zeichenkette keine speicherintensiven Allokationsschritte ausgeführt werden müssen. Frage Q-88df57e7a9c2abda (offen)

Im Zusammenspiel mit anderen Konstruktoren der Klasse wie [SWS_CORE_03026] oder [SWS_CORE_03028], welche Daten kopieren und als nicht ausnahmesicher (not exception safe) klassifiziert sind, dient dieser Konstruktor als sicherer Einstiegspunkt. Die erzeugte Zeichenkette kann nachfolgend über Modifikatoren wie operator+= ([SWS_CORE_03072], [SWS_CORE_03307]) dynamisch erweitert oder als Eingabe für Typen wie Bitset [SWS_CORE_01749] verwendet werden.

Verwendung

Die Funktion Basic stellt einen Konstruktor der Klasse ara::core::BasicString dar, der über die Header-Datei #include "ara/core/string.h" bereitgestellt wird [SWS_CORE_03026]. Er erzeugt synchron eine neue Zeichenkette als Teilstring aus dem Quellobjekt str ab der Indexposition pos gemäß der Semantik von [basic.string] [SWS_CORE_03026]. Dabei werden folgende Parameter verarbeitet:

• str: Referenz auf die zu kopierende Quellinstanz vom Typ BasicString [SWS_CORE_03026].
• pos: Nullbasierte Startposition des Teilstrings vom Typ size_type [SWS_CORE_03026].
• a: Allokator zur Speicherverwaltung, der standardmäßig mit Allocator() belegt ist [SWS_CORE_03026].

Fehlerbehandlung und Ausnahmesicherheit

Für die Funktion ist in der Spezifikation die Eigenschaft not exception safe festgelegt [SWS_CORE_03026]. Es sind weder spezifische Fehlercodes noch DET- oder DEM-Meldungen definiert. Interpretation: Da der Konstruktor dem Standardverhalten von [basic.string] folgt und keine Ausnahmesicherheit garantiert, dürften ungültige Indexwerte für pos sowie scheiternde Speicherallokationen zum Auslösen von Ausnahmen führen [SWS_CORE_03026]. Frage Q-7ea120ac992dc5ac (offen)

Zusammenspiel und Verwandte Anforderungen

Innerhalb von ara::core::BasicString ergänzt dieser Konstruktor die Variante mit zusätzlicher Längenbegrenzung n [SWS_CORE_03027] sowie Überladungen für Zeiger, Iteratoren und Initialisierungslisten [SWS_CORE_03028], [SWS_CORE_03031], [SWS_CORE_03032]. Im Unterschied zu den Konstruktoren ohne Quellstring, welche bedingt ausnahmesicher [SWS_CORE_03024] oder als noexcept deklariert sind [SWS_CORE_03025], erfordert die dynamische Übernahme von Teilstrings eine gesonderte Beachtung möglicher Allokationsfehler. Zudem dient BasicString als Parameterbasis in anderen Modulbausteinen wie Bitset [SWS_CORE_01749].

Der Konstruktor [SWS_CORE_03027] der Klasse ara::core::BasicString dient der synchronen Erzeugung einer neuen Zeichenkette als Teilsequenz aus einer Quellzeichenkette str. Ausgehend vom Index pos werden bis zu n Zeichen übernommen. Über den optionalen Parameter a kann ein benutzerdefinierter Allokator übergeben werden, andernfalls wird standardmäßig eine Standard-Allokatorinstanz erzeugt. Die Definition wird über den Header #include "ara/core/string.h" bereitgestellt.

Hinsichtlich der Robustheit ist die Funktion als not exception safe deklariert ([SWS_CORE_03027]). Gemäß der Spezifikation nach [basic.string] dürfte dieser Konstruktor fehlschlagen, wenn pos die Länge der Ausgangszeichenkette überschreitet oder die Allokation des neuen Puffers misslingt. Frage Q-31041ea019720daf (offen) Dies steht im Gegensatz zu Standard- und Allokatorkonstruktoren wie [SWS_CORE_03024] und [SWS_CORE_03025], welche als bedingt ausnahmesicher oder explizit mit noexcept spezifiziert sind.

Im Zusammenspiel innerhalb von ara::core::BasicString ergänzt die Funktion alternative Überladungen: Während [SWS_CORE_03026] den Teilstring ab pos bis zum Stringende kopiert, gestattet [SWS_CORE_03027] die explizite Längenbegrenzung. Weitere Alternativen zur Erzeugung bieten iteratorbasierte ([SWS_CORE_03031]) oder zeigerbasierte Initialisierungen ([SWS_CORE_03028]). Darüber hinaus findet dasselbe Teilstring-Muster mit pos und n auch in verwandten Klassen wie Bitset in [SWS_CORE_01749] Verwendung.

Die Konstruktorfunktion der Klasse ara::core::BasicString aus dem Header ara/core/string.h erzeugt synchron eine Zeichenkette aus einem Zeiger s auf ein Zeichenarray und einer expliziten Längenangabe n [SWS_CORE_03028]. Über den Parameter a kann optional ein benutzerdefinierter Allokator übergeben werden, der standardmäßig auf Allocator() zurückfällt [SWS_CORE_03028]. Die Semantik entspricht der Festlegung in [basic.string], wobei abweichend der Parametertyp charT durch value_type ersetzt ist [SWS_CORE_03028].

In der Spezifikation ist die Funktion als nicht ausnahmesicher (not exception safe) ausgewiesen [SWS_CORE_03028]. Dies unterscheidet sie von ausnahmesicheren Initialisierungen wie dem Allokatorkonstruktor [SWS_CORE_03025] oder dem bedingt ausnahmesicheren Standardkonstruktor [SWS_CORE_03024]. Spezifische Fehlercodes, Rückgabewerte oder Diagnosemeldungen an DEM oder DET sind nicht vorgesehen. Als wesentliche Vorbedingung dürfte der Aufrufer vermutlich sicherstellen müssen, dass s auf einen gültigen Speicherbereich mit mindestens n zusammenhängenden Elementen verweist (Interpretation), um undefiniertes Verhalten auszuschließen. Frage Q-957a57c885a2e702 (offen)

Innerhalb der Klasse ara::core::BasicString ergänzt diese Überladung die Konstruktion ohne Längenangabe für nullterminierte Zeichenketten [SWS_CORE_03029] sowie Konstruktoren für Zeichenfolgen gleicher Zeichen [SWS_CORE_03030] oder Teilstrings [SWS_CORE_03027]. Nach der Erzeugung kann das Objekt durch Zuweisungs- und Aneinanderreihungsoperatoren modifiziert werden [SWS_CORE_03072]. Zudem dient die resultierende Zeichenkette als Eingabe für Schnittstellen verwandter Datentypen, beispielsweise für die Initialisierung eines Bitset [SWS_CORE_01749].

Der Konstruktor [SWS_CORE_03029] initialisiert eine Instanz von ara::core::BasicString aus einem nullterminierten Zeiger auf Zeichenketten des Typs const value_type* und einem optionalen Allokator. Seine Semantik folgt der Standarddefinition aus [basic.string], wobei charT durch value_type ersetzt ist [SWS_CORE_03029]. Die Header-Datei ist #include "ara/core/string.h" [SWS_CORE_03029].

Hinsichtlich des Fehlerverhaltens und der Ausnahmesicherheit ist die Funktion explizit als not exception safe spezifiziert [SWS_CORE_03029]. Tritt während der Konstruktion eine Speicherallokation oder ein Fehler auf, wird keine Ausnahmegarantie gewährleistet. Im Gegensatz dazu sind Standardkonstruktoren wie [SWS_CORE_03025] als noexcept und exception safe oder [SWS_CORE_03024] als bedingt ausnahmesicher (conditionally exception safe) eingestuft.

Die Spezifikation definiert das Zusammenspiel innerhalb der BasicString-Konstruktorfamilie:

• Wird die Zeichenanzahl explizit vorgegeben, ist die Überladung mit Längenparameter (const value_type *s, size_type n, ...) gemäß [SWS_CORE_03028] heranzuziehen.
• Weitere Alternativen umfassen Teilbereichskonstruktoren aus bestehenden Strings [SWS_CORE_03026], [SWS_CORE_03027], Füllkonstruktoren [SWS_CORE_03030] sowie Iterator- [SWS_CORE_03031] und Initialisiererlisten [SWS_CORE_03032].
• Zur nachträglichen Verkettung mit rohen Zeichenkettenzeigern korrespondiert operator+= gemäß [SWS_CORE_03073].
• Zudem dient BasicString als Parameterbasis in anderen Hilfsklassen wie Bitset gemäß [SWS_CORE_01749].

Aufrufer müssen sicherstellen, dass der Zeiger s gültig und ordnungsgemäß nullterminiert ist (Interpretation: da ohne Längenangabe die Terminierung zur Längenbestimmung gemäß Standardverhalten dient). Frage Q-7e0172674e115dea (offen) Da der Konstruktor synchron ausgeführt wird, sollte in sicherheitskritischen Kontexten berücksichtigt werden, dass potenziell dynamischer Speicher über den Allokator bezogen wird.

Verwendung

Der Konstruktor [SWS_CORE_03030] der Klasse ara::core::BasicString (definiert im Header ara/core/string.h) erzeugt synchron eine Zeichenkette aus n Kopien des Zeichens c vom Typ value_type. Das funktionale Verhalten folgt der C++-Standardspezifikation [basic.string] mit der Abweichung, dass charT durch value_type ersetzt ist. Optional kann ein benutzerdefinierter Allokator a übergeben werden, für den standardmäßig Allocator() instanziiert wird.

Fehlerbehandlung und Exception-Sicherheit

Die Spezifikation stuft diesen Konstruktor als not exception safe ein, womit er sich von garantierten Noexcept-Konstruktoren wie [SWS_CORE_03025] oder dem bedingt sicheren Default-Konstruktor [SWS_CORE_03024] unterscheidet. Interpretation: Das Fehlen von Ausnahmesicherheit dürfte vor allem auf Fehlschläge bei der dynamischen Speicherallokation für n Zeichen zurückzuführen sein. Frage Q-87ae8b5cae690fdb (offen) Spezifische AUTOSAR-Fehlercodes oder Meldungen an DET oder DEM sind für diesen Aufruf nicht spezifiziert.

Nebenläufigkeit und Zusammenspiel

Gleichzeitige Zugriffe mehrerer Threads auf dieselbe Instanz ohne externe Synchronisation sind nicht thread-sicher. Nach der Erzeugung kann die Zeichenkette über Verkettungsoperatoren wie operator+= für Einzelzeichen ([SWS_CORE_03074]) oder Strings ([SWS_CORE_03072]) modifiziert werden. Die erzeugte Zeichenkette kann zudem zur Initialisierung von ara::core::Bitset gemäß [SWS_CORE_01749] dienen. Für alternative Erzeugungen stehen Konstruktoren über Zeiger ([SWS_CORE_03028], [SWS_CORE_03029]) oder Initialisierungslisten ([SWS_CORE_03032]) bereit.

Verwendung

Die Template-Funktion stellt den Bereichskonstruktor der Klasse ara::core::BasicString im Header <ara/core/string.h> dar [SWS_CORE_03031]. Sie dient der synchronen Initialisierung einer Zeichenkette aus einer Sequenz, die durch die Eingabe-Iteratoren begin und end vom Typ InputIterator definiert wird [SWS_CORE_03031]. Optional kann über den Parameter a eine benutzerdefinierte Allokator-Instanz übergeben werden; bleibt dieser Parameter unbesetzt, wird die Standard-Instanz Allocator() erzeugt [SWS_CORE_03031]. Die funktionale Semantik folgt dabei den Vorgaben des C++-Standards für [basic.string] [SWS_CORE_03031].

Fehlerbehandlung und Exception-Sicherheit

Die Spezifikation deklariert die Funktion explizit als not exception safe [SWS_CORE_03031]. Es werden keine AUTOSAR-spezifischen DET- oder DEM-Meldungen abgesetzt, da das Verhalten jenem der C++-Standardbibliothek entspricht [SWS_CORE_03031]. Interpretation: Die fehlende Ausnahmesicherheit dürfte auf mögliche Speicherallokationsfehler durch den Allokator oder fehlschlagende Operationen der übergebenen Iteratoren zurückzuführen sein. Frage Q-676411ee17d37217 (offen)

Nebenläufigkeit und Einschränkungen

Der Aufruf erfolgt synchron im Kontext des aufrufenden Threads. Im Gegensatz zum Standardkonstruktor [SWS_CORE_03024] oder dem reinen Allokator-Konstruktor [SWS_CORE_03025] ist dieser Konstruktor nicht als noexcept deklariert. Aufrufer müssen daher sicherstellen, dass der Bereich [begin, end) gültig ist und die referenzierten Elemente fehlerfrei gelesen werden können.

Zusammenspiel

Die Funktion ergänzt die alternativen Konstruktoren von ara::core::BasicString, darunter Teilstring- [SWS_CORE_03026], Zeichen-Array- [SWS_CORE_03028] und Initializer-List-Überladungen [SWS_CORE_03032], welche dieselbe Ausnahmeklassifizierung aufweisen. Nach der Konstruktion kann die Instanz über Konkatenationsoperatoren wie operator+= modifiziert werden [SWS_CORE_03072] oder zur Initialisierung abhängiger Typen wie Bitset dienen [SWS_CORE_01749].

Der Konstruktor BasicString dient der synchronen Initialisierung einer Instanz von ara::core::BasicString anhand einer Initialisierungsliste ([SWS_CORE_03032]). Die Deklaration erfolgt über die Header-Datei #include "ara/core/string.h" im Scope der Klasse ara::core::BasicString ([SWS_CORE_03032]). Das Verhalten folgt der Definition in [basic.string], wobei standardkonform charT durch value_type ersetzt wird ([SWS_CORE_03032]). Als Parameter werden eine std::initializer_list<value_type> sowie optional ein Allocator übergeben ([SWS_CORE_03032]).

Hinsichtlich der Fehlerbehandlung und Ausnahmebehandlung ist der Konstruktor als not exception safe spezifiziert ([SWS_CORE_03032]). Dies unterscheidet ihn vom Standardkonstruktor ([SWS_CORE_03024]) oder dem expliziten Allocator-Konstruktor ([SWS_CORE_03025]), welche als ausnahmesicher bzw. noexcept deklariert sind. Spezifische AUTOSAR-Fehlercodes, DET- oder DEM-Meldungen sind für diesen Konstruktor nicht definiert. Interpretation: Bei unzureichendem Speicher dürfte die Objekterzeugung fehlschlagen, da für die Elemente der Initialisierungsliste dynamischer Speicher allokiert werden muss. Frage Q-7ecc7431c1c2f54c (offen)

Im Zusammenspiel mit dem Modul core ergänzt die Funktion alternative Konstruktionswege, wie etwa die Erzeugung aus Teilstrings ([SWS_CORE_03026], [SWS_CORE_03027]), Zeigern ([SWS_CORE_03028], [SWS_CORE_03029]) oder Iteratoren ([SWS_CORE_03031]). Zur nachträglichen Erweiterung eines bestehenden Strings um eine Initialisierungsliste steht der korrespondierende operator+= bereit ([SWS_CORE_03075]). Zudem können erzeugte BasicString-Instanzen zur Initialisierung verwandter Datentypen wie Bitset genutzt werden ([SWS_CORE_01749]).

Der Kopierkonstruktor [SWS_CORE_03033] der Klasse ara::core::BasicString dient der synchronen Erzeugung einer neuen Zeichenkette als Kopie einer bestehenden Instanz unter expliziter Übergabe eines Allokators. Die Funktionsdeklaration BasicString (const BasicString &, const Allocator &); wird über den Header #include "ara/core/string.h" bereitgestellt [SWS_CORE_03033]. Die funktionale Semantik richtet sich dabei nach der entsprechenden Verwendung im Standardmuster [basic.string] [SWS_CORE_03033].

In Bezug auf die Fehlerbehandlung ist die Konstruktorfunktion in der Spezifikation ausdrücklich als not exception safe klassifiziert [SWS_CORE_03033]. Spezifische AUTOSAR-Fehlercodes oder Benachrichtigungen an Diagnosemodule wie DET oder DEM existieren für diesen Aufruf nicht; Ausnahmen bei der dynamischen Speicherallokation durch den Allokator dürften daher dem generellen Verhalten von [basic.string] unterliegen. Frage Q-496b847c39fc25ae (offen)

Hinsichtlich Nebenläufigkeit und Randbedingungen verlangt die Übergabe der Quellinstanz per const BasicString &, dass das Quellobjekt während des Kopiervorgangs nicht zeitgleich modifiziert wird. Gleichzeitige lesende Zugriffe aus mehreren Threads sind zulässig, wohingegen ungesicherte parallele Schreibzugriffe vermutlich zu Dateninkonsistenzen führen. Frage Q-daa5ef2c4672b657 (offen)

Im Zusammenspiel mit verwandten Spezifikationselementen steht der Konstruktor neben alternativen Initialisierungspfaden wie dem Move-Konstruktor mit Allokator [SWS_CORE_03034], dem Default-Konstruktor [SWS_CORE_03024] oder dem Allokator-Konstruktor [SWS_CORE_03025]. Das erzeugte Objekt kann nahtlos über Operatoren wie operator+= modifiziert [SWS_CORE_03072] oder zur Initialisierung abhängiger Typen wie Bitset herangezogen werden [SWS_CORE_01749].

Der Verschiebekonstruktor [SWS_CORE_03034] der Klasse ara::core::BasicString wird über die Header-Datei #include "ara/core/string.h" bereitgestellt. Er erzeugt synchron eine neue Zeichenkette, indem er die Daten einer bestehenden Instanz übernimmt und an einen explizit spezifizierten Allokator bindet. Das semantische Verhalten und die Anforderungen entsprechen dabei den Festlegungen des ISO-C++-Standards in [basic.string].

Im Aufrufkontext verlangt die Funktion zwei Parameter: eine Rvalue-Referenz auf ein Quellobjekt (BasicString&&) sowie eine Allokator-Instanz (const Allocator&). Das Quellobjekt verbleibt nach dem Verschiebevorgang in einem gültigen, aber veränderten Zustand. Hinsichtlich der Fehlerbehandlung ist die Funktion in [SWS_CORE_03034] als not exception safe eingestuft. Interpretation: Dies dürfte darauf zurückzuführen sein, dass bei abweichendem oder inkompatiblem Allokator neuer Speicher allokiert und die Elemente kopiert werden müssen, was bei Speicherknappheit fehlschlagen kann. Frage Q-2a89ad749ae1b2f6 (offen) Dies unterscheidet den Konstruktor von strikt ausnahmesicheren Überladungen wie [SWS_CORE_03025] oder bedingt ausnahmesicheren Varianten wie [SWS_CORE_03024].

Im Zusammenspiel innerhalb von core ergänzt die Signatur das Spektrum der Erzeugungsmethoden neben dem Kopierkonstruktor mit Allokator [SWS_CORE_03033] und Teilstring-Initialisierern wie [SWS_CORE_03026]. Nach erfolgreicher Instanziierung kann die Zeichenkette modifiziert werden, beispielsweise durch Anhängen von Inhalten über operator+= ([SWS_CORE_03072], [SWS_CORE_03307]), oder als Eingabe für abhängige Datentypen wie Bitset gemäß [SWS_CORE_01749] dienen.

Verwendung und Semantik

Die Elementfunktion append der Klasse ara::core::BasicString ([SWS_CORE_03076]) aus der Header-Datei #include "ara/core/string.h" dient dem synchronen Anhängen eines vollständigen Zeichenkettenobjekts str vom Typ BasicString an die aufrufende Instanz. Die Semantik folgt der standardisierten C++-Definition unter [basic.string]; als Rückgabewert liefert die Funktion eine Referenz auf das veränderte Objekt (*this) zurück ([SWS_CORE_03076]).

Fehlerbehandlung und Randbedingungen

Hinsichtlich der Exception-Sicherheit ist die Operation explizit als not exception safe eingestuft ([SWS_CORE_03076]). Interpretation: Tritt während der Ausführung ein Fehler auf (beispielsweise bei unzureichendem Speicher), dürfte der Zustand der Zeichenkette unbestimmt sein, da keine Wiederherstellungsgarantien spezifiziert sind. Frage Q-57504af4ee633d0b (offen) Im Gegensatz zu Varianten mit Positionsindizes wie [SWS_CORE_03077] oder [SWS_CORE_03309] (Auslösung von IsoStdOutOfRangeViolation) oder Puffergrößenprüfungen wie [SWS_CORE_03078] (Auslösung von IsoStdLengthErrorViolation) definiert [SWS_CORE_03076] keine gesonderten Violations.

Zusammenspiel und Überladungen

Die Funktion ist Teil einer Familie von Überladungen innerhalb von ara::core::BasicString:

• Anhängen von Teilstrings über Positions- und Längenangaben ([SWS_CORE_03077]).
• Übernahme von Zeichenarrays des Typs value_type* mit definierter Länge ([SWS_CORE_03078]) oder als nullterminierte Zeichenkette ([SWS_CORE_03079]).
• Mehrfaches Anfügen einzelner Zeichen ([SWS_CORE_03080]) oder Zuweisung über std::initializer_list<value_type> ([SWS_CORE_03082]).
• Integration von Iteratorbereichen ([SWS_CORE_03081]) sowie String-Ansichten mittels StringView ([SWS_CORE_03308]) und typspezifischer Templates ([SWS_CORE_03309]).

Die Elementfunktion append der Klasse ara::core::BasicString ([SWS_CORE_03077], deklariert in #include "ara/core/string.h") hängt synchron einen Teilstring einer anderen BasicString-Instanz str an das aktuelle Objekt an. Die Parameter pos und n (standardmäßig npos) bestimmen den Startindex und die maximale Zeichenanzahl innerhalb von str. Als Rückgabewert wird eine Referenz auf das veränderte Zielobjekt (*this) geliefert.

Hinsichtlich Semantik und Schnittstellenverhalten folgt die Funktion der Definition in [basic.string] des C++-Standards, weicht jedoch bei der Fehlerbehandlung ab: Wenn pos > str.size() gilt, wird gemäß [SWS_CORE_03077] eine IsoStdOutOfRangeViolation ausgelöst (analog zu std::out_of_range). Die Spezifikation stuft die Operation ausdrücklich als not exception safe ein, weshalb im Fehlerfall keine Zusicherung über einen unveränderten oder konsistenten Objektzustand vorliegt.

Mangels dokumentierter Synchronisationsmechanismen dürfte ein nebenläufiger Aufruf an derselben Instanz nicht threadsicher sein. Frage Q-ec3b029fca94ad8a (offen) Für alternative Datenquellen stehen im Modul weitere Überladungen bereit: ganze Strings ([SWS_CORE_03076]), Puffer und Zeiger ([SWS_CORE_03078], [SWS_CORE_03079]), Zeichenwiederholungen ([SWS_CORE_03080]), Iteratorpaare ([SWS_CORE_03081]), Initialisiererlisten ([SWS_CORE_03082]) sowie StringView-Objekte ([SWS_CORE_03308], [SWS_CORE_03309]).

Die Elementfunktion append der Klasse ara::core::BasicString ([SWS_CORE_03078]) fügt die ersten n Zeichen des übergebenen Zeichenfeldes s vom Typ const value_type* synchron an den bestehenden String an. Als Rückgabewert liefert die Funktion eine Referenz auf die modifizierte Instanz (BasicString&), was das Verketten aufeinanderfolgender Aufrufe ermöglicht. Die Deklaration ist über die Header-Datei #include "ara/core/string.h" verfügbar.

Das funktionale Verhalten folgt der Spezifikation von std::basic_string::append gemäß [basic.string], weist jedoch spezifische AUTOSAR-Abweichungen auf ([SWS_CORE_03078]):

• Der Template-Parameter charT wird durch den Typ value_type ersetzt.
• Überschreitet die resultierende Länge die Kapazitätsgrenze (Bedingung size() > n + max_size()), wird anstelle einer std::length_error die Verletzung IsoStdLengthErrorViolation ausgelöst.

Hinsichtlich der Ausführungssicherheit ist die Operation explizit als not exception safe spezifiziert ([SWS_CORE_03078]). Tritt während der Speicherallokation oder beim Kopieren ein Fehler bzw. eine Verletzung auf, garantiert das Objekt keinen konsistenten Zwischenzustand.

Die Methode ergänzt die weiteren Überladungen von append innerhalb von ara::core::BasicString. Dazu zählen das Anhängen vollständiger Instanzen ([SWS_CORE_03076]), von Teilstrings mit Bereichsprüfung via IsoStdOutOfRangeViolation ([SWS_CORE_03077]), nullterminierten Zeichenketten ([SWS_CORE_03079]), Zeichenfolgen gleicher Zeichen ([SWS_CORE_03080]), Iterator-Bereichen ([SWS_CORE_03081]), Initialisierungslisten ([SWS_CORE_03082]) sowie StringView-Objekten ([SWS_CORE_03308], [SWS_CORE_03309]).

Die Elementfunktion append der Klasse ara::core::BasicString ([SWS_CORE_03079]) hängt eine nullterminierte Zeichenkette des Zeigertyps const value_type* an die bestehende Zeichenkette an. Die Semantik entspricht dem Verhalten aus dem C++-Standard [basic.string], wobei charT durch value_type ersetzt wird. Als Rückgabewert liefert die synchrone Funktion eine Referenz auf das aufrufende Objekt (BasicString&), was das Verketten aufeinanderfolgender Operationen ermöglicht.

Hinsichtlich der Fehlerbehandlung und Ausnahme-Sicherheit ist die Operation explizit als not exception safe eingestuft ([SWS_CORE_03079]). Im Gegensatz zu der Überladung mit Längenangabe [SWS_CORE_03078], die bei Überschreiten der Maximallänge eine IsoStdLengthErrorViolation auslöst, oder Teilstring-Überladungen wie [SWS_CORE_03077] mit IsoStdOutOfRangeViolation, definiert diese Variante keine spezifischen Verletzungsklassen. Es dürfte in der Verantwortung des Aufrufers liegen sicherzustellen, dass der übergebene Zeiger s auf eine gültige, nullterminierte Zeichenfolge verweist. Frage Q-4e959f75f98977eb (offen)

Die Funktion ist Teil einer Familie von Überladungen für das Anhängen von Daten in ara::core::BasicString:

• Anhängen vollständiger oder partieller Zeichenketten desselben Typs ([SWS_CORE_03076], [SWS_CORE_03077]),
• Anhängen von Zeiger-Präfixen mit expliziter Längenbegrenzung ([SWS_CORE_03078]),
• Anhängen von Zeichenwiederholungen ([SWS_CORE_03080]) oder Initialisierungslisten ([SWS_CORE_03082]),
• Verarbeitung von Iterator-Bereichen ([SWS_CORE_03081]) sowie String-Views ([SWS_CORE_03308], [SWS_CORE_03309]).

Die Elementfunktion append von ara::core::BasicString ([SWS_CORE_03080]) hängt eine angegebene Anzahl n von Zeichen des Typs value_type (Parameter c) synchron an die bestehende Zeichenkette an. Sie wird über den Header ara/core/string.h bereitgestellt und gibt eine Referenz auf die modifizierte Instanz (*this) zurück, was verkettete Aufrufe ermöglicht.

Das funktionale Verhalten folgt der Definition des C++-Standards für [basic.string], wobei charT durch value_type ersetzt wird ([SWS_CORE_03080]). Hinsichtlich der Exception-Sicherheit ist die Funktion explizit als not exception safe eingestuft ([SWS_CORE_03080]). Im Gegensatz zu anderen Überladungen wie [SWS_CORE_03077] oder [SWS_CORE_03078] sind für diese Variante keine spezifischen Laufzeitverletzungen (Violations) wie IsoStdOutOfRangeViolation oder IsoStdLengthErrorViolation definiert. Vermutlich garantiert die Methode im Fehlerfall keinen unveränderten Zustand der Instanz. Frage Q-15af6c12a1a342a9 (offen)

Im Kontext von Nebenläufigkeit und Thread-Sicherheit ist zu beachten, dass gleichzeitige schreibende Zugriffe auf dieselbe Instanz von BasicString vermutlich extern synchronisiert werden müssen. Frage Q-1e8a1511516e4cd8 (offen) Die Funktion ergänzt die weiteren Überladungen von append in ara::core::BasicString, welche das Anhängen vollständiger Zeichenketten ([SWS_CORE_03076]), von Teilbereichen ([SWS_CORE_03077]), Zeiger-Puffern ([SWS_CORE_03078], [SWS_CORE_03079]), Iterator-Bereichen ([SWS_CORE_03081]), Initialisierungslisten ([SWS_CORE_03082]) oder StringView-Objekten ([SWS_CORE_03308], [SWS_CORE_03309]) abdecken.

Verwendung und Semantik

Die Template-Memberfunktion append der Klasse ara::core::BasicString wird über die Header-Datei ara/core/string.h bereitgestellt [SWS_CORE_03081]. Sie hängt eine Sequenz von Zeichen, die durch das Iterator-Paar first und last der Kategorie InputIterator begrenzt wird, synchron an die bestehende Zeichenkette an [SWS_CORE_03081]. Das funktionale Verhalten richtet sich dabei nach der entsprechenden Definition in [basic.string] des C++-Standards [SWS_CORE_03081]. Als Rückgabewert liefert die Operation eine Referenz auf das veränderte BasicString-Objekt (*this) [SWS_CORE_03081].

Fehlerbehandlung und Ausnahmesicherheit

Für diese Funktion ist die Ausnahme-Sicherheit explizit als not exception safe festgelegt [SWS_CORE_03081]. Im Fehlerfall – beispielsweise bei Erschöpfung des dynamischen Speichers während der Puffervergrößerung – dürfte die Instanz interpretationsgemäß in einem ungültigen Zustand verbleiben. Frage Q-600c7dacc868877c (offen) Spezifische AUTOSAR-Violations wie IsoStdOutOfRangeViolation oder IsoStdLengthErrorViolation sind für diese Iterator-Überladung nicht definiert, im Gegensatz zu anderen Überladungen der Methode [SWS_CORE_03077], [SWS_CORE_03078].

Zusammenspiel im Modul

Die Funktion ist Teil einer umfangreichen Gruppe von Überladungen für das Anfügen von Daten an ara::core::BasicString:

• Anhängen vollständiger oder partieller Zeichenketten vom Typ BasicString [SWS_CORE_03076], [SWS_CORE_03077].
• Anhängen von Zeichen-Arrays mit Längenangabe oder nullterminierten Zeichenfolgen [SWS_CORE_03078], [SWS_CORE_03079].
• Wiederholtes Anhängen einzelner Zeichen [SWS_CORE_03080] sowie Übernahme aus std::initializer_list [SWS_CORE_03082].
• Integration moderner String-Views über StringView bzw. generische View-Typen [SWS_CORE_03308], [SWS_CORE_03309].

Die Iterator-Variante [SWS_CORE_03081] bietet dabei die maximale Flexibilität zur Integration beliebiger generischer Datenquellen.

Die Elementfunktion append der Klasse ara::core::BasicString hängt die Zeichen einer Initialisierungsliste vom Typ std::initializer_list<value_type> synchron an das bestehende String-Objekt an [SWS_CORE_03082]. Das Verhalten folgt der Semantik von [basic.string] aus dem C++-Standard mit der Abweichung, dass charT durch value_type ersetzt ist [SWS_CORE_03082]. Der Aufruf modifiziert die Instanz direkt und liefert eine Referenz auf das Objekt zurück, was Methodenverkettungen ermöglicht.

Hinsichtlich der Fehlerbehandlung ist die Funktion als nicht ausnahmesicher (not exception safe) klassifiziert [SWS_CORE_03082]. Anders als verwandte Überladungen wie [SWS_CORE_03077] oder [SWS_CORE_03078] definiert diese Variante keine spezifischen Verletzungen wie IsoStdOutOfRangeViolation oder IsoStdLengthErrorViolation. Interpretation: Schlägt die interne Speicherallokation fehl, verbleibt das Objekt vermutlich in einem undefinierten Zustand. Frage Q-169750518dc1904b (offen) Da der innere Zustand verändert wird, dürfte ein nebenläufiger Aufruf ohne externe Synchronisation zu Datenrennen führen.

Im Zusammenspiel innerhalb von ara::core::BasicString ist die Funktion Teil einer Gruppe verwandter append-Operationen. Sie ergänzt Überladungen für ganze Zeichenketten ([SWS_CORE_03076]), Teilbereiche ([SWS_CORE_03077]), Zeiger auf Zeichenketten ([SWS_CORE_03078], [SWS_CORE_03079]), wiederholte Einzelzeichen ([SWS_CORE_03080]), Iterator-Bereiche ([SWS_CORE_03081]) und StringView-Instanzen ([SWS_CORE_03308], [SWS_CORE_03309]).

Verwendung

Die synchrone Elementfunktion append der Klasse ara::core::BasicString hängt die Zeichen einer übergebenen Zeichenkettenansicht (StringView sv) an die bestehende Zeichenkette an [SWS_CORE_03308]. Die Schnittstelle wird über den Header #include "ara/core/string.h" eingebunden [SWS_CORE_03308]. Sie gibt eine Referenz auf die aufrufende Instanz (BasicString &) zurück, wodurch mehrere Modifikationen verkettet werden können [SWS_CORE_03308]. Die funktionale Semantik folgt der entsprechenden Spezifikation in C++ [basic.string] [SWS_CORE_03308].

Fehlerbehandlung und Exception-Sicherheit

Die Funktion ist in AUTOSAR explizit als nicht ausnahmesicher („not exception safe“) spezifiziert [SWS_CORE_03308]. Spezifische Fehlercodes, DET- oder DEM-Meldungen sowie explizite AUTOSAR-Violations sind für diesen Aufruf nicht festgelegt, wohingegen verwandte Überladungen wie [SWS_CORE_03077] oder [SWS_CORE_03309] bei Indexüberschreitungen eine IsoStdOutOfRangeViolation und [SWS_CORE_03078] bei Längenüberschreitungen eine IsoStdLengthErrorViolation auslösen.

Nebenläufigkeit und Zusammenspiel

Da append den Zustand des aufgerufenen String-Objekts direkt verändert, dürfte ein nebenläufiger Zugriff mehrerer Threads auf dieselbe Instanz ohne externe Synchronisation nicht threadsicher sein. Frage Q-814665e285846c8e (offen) Die Methode steht im Verbund mit weiteren append-Varianten von ara::core::BasicString, welche das Anhängen vollständiger BasicString-Instanzen [SWS_CORE_03076], C-Strings [SWS_CORE_03079], wiederholter Einzelzeichen [SWS_CORE_03080] sowie Iteratorenbereichen [SWS_CORE_03081] oder Initialisierungslisten [SWS_CORE_03082] ermöglichen.

Verwendung

Die Template-Funktion append der Klasse ara::core::BasicString ([SWS_CORE_03309]) aus der Header-Datei #include "ara/core/string.h" dient dem synchronen Anhängen eines Teilbereichs eines Objekts t an die aufrufende Zeichenkette. Das Verhalten orientiert sich an der ISO-C++-Spezifikation [basic.string]. Der Parameter pos legt den Startindex im Quellobjekt fest, während n die maximale Anzahl anzuhängender Zeichen bestimmt (Standardwert npos). Als Rückgabewert wird eine Referenz auf das modifizierte Zeichenkettenobjekt (*this) geliefert. Interpretation: Das übergebene Objekt t dürfte intern als String-View sv interpretiert werden. Frage Q-9752a5eeaf05b684 (offen)

Fehlerbehandlung

AUTOSAR definiert für diese Funktion eine spezifische Abweichung vom C++-Standard: Wenn die angegebene Position größer als die Größe des Quellbereichs ist (pos > sv.size()), wird eine IsoStdOutOfRangeViolation anstelle von std::out_of_range ausgelöst ([SWS_CORE_03309]). Die semantische Beschreibung dieser Verletzung entspricht der von std::out_of_range.

Einschränkungen und Ausnahmesicherheit

Die Operation ist in der Spezifikation ausdrücklich als not exception safe eingestuft ([SWS_CORE_03309]). Bei auftretenden Fehlern wird daher kein stabiler Erhalt des vorherigen Zustands garantiert.

Zusammenspiel

Die Funktion ergänzt die weiteren Varianten zur Zeichenketten-Erweiterung in ara::core::BasicString. Hierzu zählen Überladungen für vollständige BasicString-Instanzen ([SWS_CORE_03076]) oder deren Teilbereiche ([SWS_CORE_03077]), C-Zeichenketten mit Längenangabe ([SWS_CORE_03078]) bzw. als Null-terminierte Zeiger ([SWS_CORE_03079]), Zeichenwiederholungen ([SWS_CORE_03080]), Iterator-Bereiche ([SWS_CORE_03081]), Initialisierungslisten ([SWS_CORE_03082]) sowie separate StringView-Objekte ([SWS_CORE_03308]).

Die Elementfunktion assign der Klasse ara::core::BasicString dient dem synchronen Zuweisen des Inhalts einer bestehenden Zeichenkette an die aufrufende Instanz gemäß dem Verhalten von [basic.string] [SWS_CORE_03084]. Die Funktion wird über den Header ara/core/string.h bereitgestellt und akzeptiert eine konstante Referenz auf ein BasicString-Objekt (const BasicString &str). Als Rückgabewert liefert sie eine Referenz auf das modifizierte Zielobjekt (*this), was Methodenverkettungen ermöglicht [SWS_CORE_03084].

Hinsichtlich der Robustheit ist die Funktion explizit als not exception safe spezifiziert [SWS_CORE_03084]. Bei dynamischen Speicherallokationen während des Kopiervorgangs können Fehler auftreten, die nicht durch Ausnahme-Garantien abgefangen werden; im Fehlerfall verbleibt die Instanz vermutlich in einem undefinierten Zustand. Frage Q-0ddd5ac03e56490f (offen) Spezifische AUTOSAR-Fehlercodes oder Meldungen an DET oder DEM sind für diese Zuweisungsfunktion nicht vorgesehen.

Im Zusammenspiel mit anderen Schnittstellen stellt assign die Kopiervariante innerhalb einer Familie von Zuweisungsfunktionen dar. Während die verschiebende Überladung [SWS_CORE_03085] als conditionally exception safe deklariert ist, teilen die übrigen Zuweisungen – etwa über Teilstrings [SWS_CORE_03086], Zeichenketten-Views [SWS_CORE_03087] oder Iteratorbereiche [SWS_CORE_03091] – die Eigenschaft not exception safe. Da keine Thread-Sicherheit spezifiziert ist, dürfte ein nebenläufiger Aufruf auf derselben Instanz ohne externe Synchronisation nicht reentrant und datenunsicher sein. Frage Q-37d67c851a296f55 (offen)

Die Move-Überladung der Elementfunktion assign gemäß [SWS_CORE_03085] weist einer bestehenden Instanz von ara::core::BasicString synchron den Inhalt der Rvalue-Referenz str zu (deklariert in der Header-Datei ara/core/string.h). Die Funktion gibt eine Referenz auf das aufrufende Objekt (*this) zurück. Das funktionale Verhalten richtet sich dabei nach der entsprechenden Definition in [basic.string] des C++-Standards.

In Bezug auf die Fehler- und Ausnahmebehandlung ist die Methode als bedingt ausnahmesicher (conditionally exception safe) deklariert [SWS_CORE_03085]. Ein Auslösen von Ausnahmen ist per noexcept genau dann ausgeschlossen, wenn der Allokator die Move-Zuweisung weiterleitet (propagate_on_container_move_assignment::value) oder Allokator-Instanzen stets als gleich gelten (is_always_equal::value). Im Gegensatz zu anderen Zuweisungsfunktionen wie [SWS_CORE_03086] oder [SWS_CORE_03088], die bei Bereichs- oder Längenüberschreitungen spezifische Verletzungen wie IsoStdOutOfRangeViolation bzw. IsoStdLengthErrorViolation auslösen und als nicht ausnahmesicher gelten, definiert diese Operation keine gesonderten AUTOSAR-Violations.

Im Zusammenspiel mit alternativen Überladungen von BasicString::assign – etwa für konstante Lvalue-Referenzen nach [SWS_CORE_03084], Ansichten via [SWS_CORE_03087] oder Zeichenkettenpuffer gemäß [SWS_CORE_03089] – ermöglicht die Rvalue-Variante eine ressourceneffiziente Zuweisung ohne Neubelegung von Speicher. Interpretation: Nach der Übergabe verbleibt das Quellobjekt str vermutlich in einem gültigen, aber unspezifizierten Zustand, wie es für Move-Operationen nach [basic.string] üblich ist. Frage Q-88c8157963cdd7e0 (offen)

Die Elementfunktion assign der Klasse ara::core::BasicString ([SWS_CORE_03086]), bereitgestellt über den Header ara/core/string.h, weist der aktuellen Instanz synchron einen Teilbereich einer übergebenen Quellzeichenkette str zu. Der Aufruf nimmt neben der Quellreferenz str den Startindex pos sowie optional die Anzahl der Zeichen n entgegen, für die standardmäßig npos definiert ist. Nach der Zuweisung wird eine Referenz auf das geänderte Objekt (*this) zurückgegeben. Die funktionale Semantik entspricht dabei grundsätzlich den Vorgaben aus [basic.string] ([SWS_CORE_03086]).

Bei der Fehlerbehandlung besteht eine explizite Abweichung gegenüber dem ISO-C++-Standard: Falls die Bedingung pos > str.size() zutrifft, wird keine std::out_of_range ausgelöst, sondern eine IsoStdOutOfRangeViolation hervorgerufen ([SWS_CORE_03086]). Zudem ist die Funktion in der Spezifikation ausdrücklich als nicht ausnahmesicher (not exception safe) klassifiziert ([SWS_CORE_03086]).

Im Verbund der Zuweisungsmethoden von ara::core::BasicString ergänzt diese Teilzeichenketten-Überladung die Zuweisung vollständiger Zeichenketten ([SWS_CORE_03084]), die bedingt ausnahmesichere Move-Zuweisung ([SWS_CORE_03085]), die Zuweisung aus einer StringView ([SWS_CORE_03087]) sowie Operationen mit Zeichenpuffern ([SWS_CORE_03088]) oder Iterator-Bereichen ([SWS_CORE_03091]).

Verwendung

Die Elementfunktion assign für StringView ([SWS_CORE_03087]) ersetzt den Inhalt einer ara::core::BasicString-Instanz synchron durch die Zeichen der übergebenen Zeichenkettenansicht. Die Semantik folgt der entsprechenden Definition in [basic.string] der C++-Standardbibliothek. Als Rückgabewert liefert die Funktion eine Referenz auf das modifizierte Zielobjekt (BasicString &), was das Verketten aufeinanderfolgender Methodenaufrufe ermöglicht. Die Deklaration wird über die Header-Datei #include "ara/core/string.h" bereitgestellt.

Fehlerbehandlung und Exception-Sicherheit

Die Funktion ist in der Spezifikation als not exception safe ausgewiesen ([SWS_CORE_03087]). Interpretation: Erfordert die Zuweisung eine Vergrößerung der internen Pufferkapazität und schlägt diese Speicherallokation fehl, dürfte eine Ausnahme ausgelöst werden, ohne dass eine Garantie für den unveränderten Zustand der Instanz besteht. Frage (offen)

Nebenläufigkeit und Einschränkungen

Interpretation: Aufrufe von assign auf derselben Instanz von ara::core::BasicString sind nicht threadsicher und bedürfen bei gleichzeitigem lesenden oder schreibenden Zugriff mehrerer Threads einer externen Synchronisation. Frage Q-12774d6cd363b032 (offen)

Zusammenspiel

Die Funktion ergänzt das Zuweisungsspektrum von ara::core::BasicString um typsichere Ansichten. Sie existiert neben den Überladungen für Kopier- und Verschiebezuweisungen ([SWS_CORE_03084], [SWS_CORE_03085]), Teilstrings ([SWS_CORE_03086]), Zeiger auf Zeichendaten ([SWS_CORE_03088], [SWS_CORE_03089]), Zeichenwiederholungen ([SWS_CORE_03090]), Iteratorbereiche ([SWS_CORE_03091]) und Initialisiererlisten ([SWS_CORE_03092]).

Verwendung

Die Elementfunktion assign der Klasse ara::core::BasicString weist der aktuellen Zeichenketteninstanz synchron die ersten n Zeichen aus dem übergebenen Zeichen-Array s vom Typ const value_type* zu und liefert eine Referenz auf das modifizierte Objekt (*this) zurück [SWS_CORE_03088]. Das funktionale Verhalten entspricht grundsätzlich der Definition nach [basic.string], wobei AUTOSAR den generischen Parametertyp charT durch value_type ersetzt [SWS_CORE_03088].

Fehlerbehandlung und Randbedingungen

Die Zuweisung ist als nicht ausnahmesicher (not exception safe) spezifiziert [SWS_CORE_03088]. Falls die angegebene Länge n die maximal darstellbare Größe max_size() überschreitet (n > max_size()), löst die Funktion die AUTOSAR-Verletzung IsoStdLengthErrorViolation anstelle von std::length_error aus [SWS_CORE_03088]. Interpretation: Der Aufrufer dürfte sicherstellen müssen, dass s auf mindestens n gültige Zeichen verweist, da die Spezifikation keine gesonderte Pufferprüfung definiert. Frage Q-290c36db79f27a0a (offen)

Zusammenspiel

Die Funktion eignet sich primär für nicht nullterminierte Puffer oder Teilbereiche von Arrays. Sie ergänzt die Überladung assign(const value_type* s) [SWS_CORE_03089], bei der die Länge implizit ermittelt wird. Im Klassenverbund von ara::core::BasicString existieren weitere Zuweisungsüberladungen zur Übernahme bestehender Zeichenketten per Kopie [SWS_CORE_03084] oder Verschiebung [SWS_CORE_03085], zur Zuweisung von Teilstrings mit Indexprüfung [SWS_CORE_03086], zur Übernahme aus StringView [SWS_CORE_03087] sowie für Zeichenwiederholungen [SWS_CORE_03090], Iteratorbereiche [SWS_CORE_03091] und Initialisierungslisten [SWS_CORE_03092].

Die synchrone Elementfunktion assign der Klasse ara::core::BasicString ([SWS_CORE_03089]) aus dem Header ara/core/string.h ersetzt den aktuellen Inhalt eines Zeichenkettenobjekts durch die übergebene Zeichenfolge s vom Typ const value_type*. Der Aufruf liefert eine Referenz auf das veränderte Objekt (*this) zurück. Das funktionale Verhalten folgt den Vorgaben des ISO-C++-Standards für [basic.string] mit der dokumentierten Abweichung, dass der Zeichentyp charT durch value_type ersetzt ist ([SWS_CORE_03089]). Interpretation: Mangels eines separaten Längenparameters dürfte der Zeiger s auf ein nullterminiertes Zeichen-Array verweisen. Frage Q-eea79e929750c27f (offen)

Hinsichtlich der Fehlerbehandlung und Robustheit ist die Zuweisungsfunktion als nicht ausnahmesicher (not exception safe) klassifiziert ([SWS_CORE_03089]). Im Gegensatz zu verwandten Überladungen wie assign(const BasicString&, size_type, size_type) ([SWS_CORE_03086]) oder assign(const value_type*, size_type) ([SWS_CORE_03088]) sind für diese Variante keine spezifischen Laufzeit-Verletzungen wie IsoStdOutOfRangeViolation oder IsoStdLengthErrorViolation definiert.

Im Modul core ist die Funktion Teil einer umfassenden Überladungsfamilie zur Inhaltszuweisung. Diese deckt neben Rohzeigern auch vollständige Strings ([SWS_CORE_03084]), Move-Semantik ([SWS_CORE_03085]), StringView-Instanzen ([SWS_CORE_03087]), wiederholte Einzelzeichen ([SWS_CORE_03090]), Iterator-Bereiche ([SWS_CORE_03091]) und Initialisierungslisten ([SWS_CORE_03092]) ab. Gleichartige Zuweisungsmuster stellt AUTOSAR auch in Container-Typen wie ara::core::Vector ([SWS_CORE_01328]) bereit.

Verwendung

Die Elementfunktion assign der Klasse ara::core::BasicString (definiert in #include "ara/core/string.h") ersetzt den aktuellen Inhalt der Zeichenkette synchron durch n aufeinanderfolgende Kopien des Zeichens c vom Typ value_type [SWS_CORE_03090]. Die Semantik entspricht der Festlegung für [basic.string] mit der Abweichung, dass der Typparameter charT durch value_type ersetzt wird [SWS_CORE_03090]. Als Rückgabewert liefert die Funktion eine lvalue-Referenz auf die modifizierte Instanz (*this), was das Verketten weiterer Operationen ermöglicht.

Fehlerbehandlung und Ausnahme-Sicherheit

Die Operation ist laut Spezifikation explizit als not exception safe eingestuft [SWS_CORE_03090]. Im Unterschied zu anderen Überladungen, die bei Grenzüberschreitungen definierte Verletzungen wie IsoStdOutOfRangeViolation [SWS_CORE_03086] oder IsoStdLengthErrorViolation [SWS_CORE_03088] auslösen, benennt diese Funktion keine spezifischen Violations. Schlägt eine erforderliche Speicheranforderung fehl, existieren keine Zusicherungen über den Fortbestand des bisherigen Objektzustands.

Nebenläufigkeit und Einschränkungen

Da die Zuweisung den internen Puffer direkt modifiziert und keine interne Synchronisation spezifiziert ist, dürfte der gleichzeitige Zugriff mehrerer Threads auf dieselbe Instanz nicht threadsicher sein (Interpretation). Frage Q-50f419c4bca5c151 (offen) Parallele Aufrufe müssen durch den Aufrufer extern koordiniert werden.

Zusammenspiel

Die Funktion ergänzt das Zuweisungs-Portfolio von ara::core::BasicString, welches neben Kopier- und Verschiebezuweisungen [SWS_CORE_03084], [SWS_CORE_03085] sowie Iteratoren und Initialisiererlisten [SWS_CORE_03091], [SWS_CORE_03092] auch Schnittstellen für String-Views bereitstellt [SWS_CORE_03087]. Ein vergleichbares Zuweisungsmuster mit Wiederholungsanzahl existiert analog für ara::core::Vector::assign [SWS_CORE_01329].