klasse ara::core::BasicString

De toewijzingsoperator operator+= van de klasse ara::core::BasicString ([SWS_CORE_03072] uit #include "ara/core/string.h") voegt de inhoud van een meegegeven BasicString-instantie synchroon toe aan het huidige object. De functionele semantiek volgt daarbij het overeenkomstige gebruik in [basic.string] ([SWS_CORE_03072]). De aanroep retourneert een referentie naar de gemodificeerde instantie (*this), waardoor toewijzingsketens mogelijk worden.

Met betrekking tot foutafhandeling is de bewerking in de specificatie expliciet gedeclareerd als „not exception safe” ([SWS_CORE_03072]). Specifieke foutcodes of notificatiemechanismen via DET of DEM zijn voor dit element niet gedefinieerd. Mocht een interne geheugenallocatie mislukken, dan biedt de methode bijgevolg geen uitzonderingsveiligheidsgarantie.

Wat betreft gelijktijdigheid en beperkingen dient in acht te worden genomen dat de aanroep de toestand van de instantie direct modificeert. Omdat de payload geen synchronisatiemechanismen vermeldt, zal een gelijktijdige lees- of schrijftoegang tot hetzelfde object over meerdere threads heen zonder externe synchronisatie vermoedelijk niet-thread-safe zijn. Vraag Q-352f9d72ad3dfdbd (open)

De operator vormt samen met verdere overloads van operator+= de interface voor tekenreeksuitbreiding, bijvoorbeeld voor losse tekens ([SWS_CORE_03074]), ruwe tekenpointers ([SWS_CORE_03073]), initialisatielijsten ([SWS_CORE_03075]) en StringView ([SWS_CORE_03307]). Al deze modificatie-operators delen de eigenschap „not exception safe” en vormen een aanvulling op de basisconstructors van ara::core::BasicString ([SWS_CORE_03024], [SWS_CORE_03025]).

Gebruik

De toewijzingsoperator operator+= van de klasse ara::core::BasicString voegt een pointer-gebaseerde tekenreeks synchroon toe aan de bestaande tekenreeks en retourneert een referentie naar het gewijzigde object [SWS_CORE_03073]. De functie wordt ingevoegd via het headerbestand #include "ara/core/string.h" en accepteert als parameter een pointer s van het type const value_type * [SWS_CORE_03073]. De functionele semantiek volgt de gestandaardiseerde definitie uit [basic.string], waarbij als wezenlijke afwijking het standaard-tekentype charT is vervangen door value_type [SWS_CORE_03073].

Foutafhandeling en beperkingen

Met betrekking tot uitzonderingsveiligheid is de lidfunctie expliciet gedeclareerd als niet uitzonderingsveilig („not exception safe”) [SWS_CORE_03073]. Specifieke foutcodes, retourwaarden voor foutindicatie of foutmeldingen aan DET of DEM zijn voor deze operator niet gespecificeerd. Interpretatie: bij het mislukken van noodzakelijke interne geheugenallocaties tijdens het vergroten van de tekenreeks kan er vermoedelijk geen consistente objectstatus worden gegarandeerd en bestaat er geen afzonderlijk foutkanaal in de AUTOSAR Adaptive-omgeving. Vraag Q-a1498ddbc09bcfa9 (open)

Samenspel

De methode vormt een aanvulling op de overige toewijzingsoperatoren binnen ara::core::BasicString, die het toevoegen van volledige tekenreeksinstanties [SWS_CORE_03072], afzonderlijke tekens [SWS_CORE_03074], initialisatielijsten [SWS_CORE_03075] of StringView-objecten [SWS_CORE_03307] realiseren. Net als de constructors voor ruwe tekenpointers [SWS_CORE_03028] [SWS_CORE_03029] zijn al deze varianten als niet uitzonderingsveilig gespecificeerd.

De lidfunctie operator+= van de klasse ara::core::BasicString maakt het synchroon toevoegen van een enkel teken c van het type value_type aan het aanroepende tekenreeksobject [SWS_CORE_03074] mogelijk. De declaratie is opgenomen in de header ara/core/string.h [SWS_CORE_03074]. Het gedrag komt overeen met de specificatie in [basic.string], waarbij afwijkend het parametertype charT is vervangen door value_type [SWS_CORE_03074]. Als retourwaarde wordt een referentie naar het gewijzigde object (BasicString &) geleverd, wat gekoppelde aanroepen ondersteunt.

Met betrekking tot robuustheid en foutafhandeling is de operatie geclassificeerd als not exception safe [SWS_CORE_03074]. Specifieke foutcodes en meldingen aan DET of DEM zijn voor deze functie niet gedefinieerd. Interpretatie: de classificatie als niet uitzonderingsveilig berust er vermoedelijk op dat bij overschrijding van de actuele buffercapaciteit een dynamische allocatie via de onderliggende allocator moet worden geactiveerd, die bij geheugentekort kan mislukken. Vraag Q-d74ec80829327ce0 (open)

Wat betreft gelijktijdigheid en randvoorwaarden wijzigt de functie de instantie rechtstreeks; gelijktijdige lees- of schrijftoegangen zonder externe synchronisatie zijn daarom niet veilig. In samenspel met andere interfaces vult de operator de instantiëring via constructors zoals [SWS_CORE_03024] of [SWS_CORE_03025] aan, evenals alternatieve samengestelde toewijzingen voor gehele tekenreeksen [SWS_CORE_03072], tekenreeks-pointers [SWS_CORE_03073], initialisatielijsten [SWS_CORE_03075] en string views [SWS_CORE_03307].

De lidfunctie operator+= van ara::core::BasicString ([SWS_CORE_03075]) voegt de tekens van een std::initializer_list<value_type> synchroon toe aan het bestaande string-object. Als retourwaarde levert de methode een referentie naar de gewijzigde tekenreeks (*this). Het gedrag richt zich naar de C++-standaard voor [basic.string], waarbij charT is vervangen door value_type ([SWS_CORE_03075]). Voor gebruik moet de header ara/core/string.h worden ingevoegd ([SWS_CORE_03075]).

Wat betreft foutafhandeling en robuustheid is de functie geclassificeerd als not exception safe ([SWS_CORE_03075]). Interpretatie: vermoedelijk kunnen er bij onvoldoende geheugen tijdens een noodzakelijke herallocatie uitzonderingen worden gegenereerd, zonder dat een sterke uitzonderingsgarantie voor de bestaande bufferinhoud wordt toegezegd. Vraag Q-0f3d6328fb6bfd73 (open)

Wat betreft gelijktijdigheid en beperkingen vindt de aanroep synchroon plaats in de context van de aanroepende thread. Omdat de aangeroepen instantie rechtstreeks wordt gewijzigd, is gelijktijdige toegang door meerdere threads zonder externe synchronisatie niet thread-safe.

In samenspel met andere interfaces vormt deze overload een aanvulling op de overige toevoegoperatoren van ara::core::BasicString, waaronder het toevoegen van strings ([SWS_CORE_03072]), tekenarrays ([SWS_CORE_03073]), afzonderlijke tekens ([SWS_CORE_03074]) of een StringView ([SWS_CORE_03307]). Daarnaast correspondeert de initialisatielijst semantisch met de overeenkomstige constructor ([SWS_CORE_03032]).

De lidfunctie operator+= van de klasse ara::core::BasicString voegt een via StringView sv doorgegeven tekenreeks synchroon toe aan het aanroepende string-object en retourneert een referentie naar dit gewijzigde object [SWS_CORE_03307]. De bewerking wordt gedefinieerd via het headerbestand #include "ara/core/string.h", waarbij het functionele gedrag de algemene conventies uit [basic.string] volgt [SWS_CORE_03307].

Foutafhandeling en gelijktijdigheid

Met betrekking tot de uitvoering is de functie uitdrukkelijk geclassificeerd als not exception safe [SWS_CORE_03307]. Er worden geen specifieke foutcodes voor DET of DEM voorgeschreven. Mocht bij het verlengen van de tekenreeks een interne geheugenallocatie mislukken, dan blijft de interne toestand van de instantie vermoedelijk niet gegarandeerd ongewijzigd. Bij gebrek aan geïntegreerde synchronisatiemechanismen moet bij concurrerende schrijf- of leestoegang van meerdere threads tot dezelfde instantie worden uitgegaan van ontbrekende thread-veiligheid (interpretatie). Vraag Q-1bed85bd42475f62 (open)

Samenspel

De operator past naadloos in de structuur van de klasse ara::core::BasicString en vormt een aanvulling op de alternatieve overbelastingen van operator+= voor volledige strings [SWS_CORE_03072], tekenpointers const value_type* [SWS_CORE_03073], afzonderlijke tekens [SWS_CORE_03074] en initialisatielijsten [SWS_CORE_03075]. Het aanmaken van de betrokken string-instanties vindt plaats via de bijbehorende constructors van de klasse, zoals de standaardconstructor [SWS_CORE_03024] of kopieer- en verplaatsingsconstructors [SWS_CORE_03033], [SWS_CORE_03034].

Gebruik

De functie BasicString() uit het headerbestand #include "ara/core/string.h" is de parameterloze standaardconstructor van de klasse ara::core::BasicString ([SWS_CORE_03024]). De aanroep geschiedt synchroon en levert als constructor geen retourwaarde op. Het gedrag richt zich naar de overeenkomstige definitie in [basic.string] ([SWS_CORE_03024]); de aangemaakte instantie representeert dan ook vermoedelijk een lege tekenreeks. Vraag Q-f36b11fa590a6111 (open)

Foutafhandeling en uitzonderingsveiligheid

Het element is gespecificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) ([SWS_CORE_03024]). Specifieke foutcodes, DET- of DEM-meldingen bestaan volgens de specificatie niet. Via de signatuur BasicString () noexcept(noexcept(Allocator())); is de uitzonderingsveiligheid rechtstreeks gekoppeld aan de standaardconstructor van de allocator ([SWS_CORE_03024]). Werpt de aanmaak van Allocator() geen exceptie, dan verloopt ook de constructie van BasicString gegarandeerd zonder uitzonderingen.

Interactie en beperkingen

In de context van de overige interfaces van ara::core::BasicString zijn de volgende afhankelijkheden relevant:

• Wordt een reeds geïnstantieerde allocator meegegeven, dan garandeert de signatuur onbeperkte uitzonderingsveiligheid (exception safe / noexcept) ([SWS_CORE_03025]).
• Andere initialisaties – zoals via deelbereiken ([SWS_CORE_03026], [SWS_CORE_03027]), pointers ([SWS_CORE_03028], [SWS_CORE_03029]), tekenreeksen ([SWS_CORE_03030]), iterators ([SWS_CORE_03031]), initialisatielijsten ([SWS_CORE_03032]) of kopieer- en verplaatsingsoperaties met allocator ([SWS_CORE_03033], [SWS_CORE_03034]) – zijn daarentegen aangemerkt als not exception safe.
• De geïnitialiseerde instantie kan synchroon worden uitgebreid, onder meer door overbelastingen van operator+= voor tekenreeksen ([SWS_CORE_03072]), tekenpointers ([SWS_CORE_03073]), afzonderlijke tekens ([SWS_CORE_03074]), initializer-lists ([SWS_CORE_03075]) en StringView ([SWS_CORE_03307]).
• Bovendien kan het object worden gebruikt voor de constructie van een Bitset ([SWS_CORE_01749]).

De expliciete constructor BasicString(const Allocator &a) uit het headerbestand #include "ara/core/string.h" initialiseert een lege instantie van ara::core::BasicString met gebruikmaking van de meegegeven allocator [SWS_CORE_03025]. Het semantische gedrag richt zich naar de C++-standaardparagraaf [basic.string] [SWS_CORE_03025]. Door het sleutelwoord explicit worden onbedoelde impliciete typeconversies vanuit een allocatorinstantie voorkomen [SWS_CORE_03025].

Wat betreft foutafhandeling en uitzonderingsafhandeling is de functie gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_03025]. In tegenstelling tot de standaardconstructor [SWS_CORE_03024], waarvan de uitzonderingsveiligheid voorwaardelijk afhangt van noexcept(noexcept(Allocator())), garandeert deze aanroep altijd een foutloze creatie zonder uitzonderingen [SWS_CORE_03025], [SWS_CORE_03024]. Interpretatie: de onvoorwaardelijke uitzonderingsveiligheid zal er vermoedelijk op berusten dat er bij het initialiseren van een lege tekenreeks geen geheugenintensieve allocatiestappen hoeven te worden uitgevoerd. Vraag Q-88df57e7a9c2abda (open)

In samenspel met andere constructors van de klasse zoals [SWS_CORE_03026] of [SWS_CORE_03028], die gegevens kopiëren en geclassificeerd zijn als niet-uitzonderingsveilig (not exception safe), dient deze constructor als een veilig startpunt. De aangemaakte tekenreeks kan vervolgens via modificatoren zoals operator+= ([SWS_CORE_03072], [SWS_CORE_03307]) dynamisch worden uitgebreid of als invoer voor typen zoals Bitset [SWS_CORE_01749] worden gebruikt.

Gebruik

De functie Basic vormt een constructor van de klasse ara::core::BasicString, die beschikbaar wordt gesteld via het headerbestand #include "ara/core/string.h" [SWS_CORE_03026]. Deze creëert synchroon een nieuwe tekenreeks als deelstring uit het bronobject str vanaf de indexpositie pos conform de semantiek van [basic.string] [SWS_CORE_03026]. Daarbij worden de volgende parameters verwerkt:

• str: Referentie naar de te kopiëren broninstantie van het type BasicString [SWS_CORE_03026].
• pos: Zero-based startpositie van de deelstring van het type size_type [SWS_CORE_03026].
• a: Allocator voor geheugenbeheer, die standaard is ingesteld op Allocator() [SWS_CORE_03026].

Foutafhandeling en uitzonderingsveiligheid

Voor de functie is in de specificatie de eigenschap not exception safe vastgelegd [SWS_CORE_03026]. Er zijn noch specifieke foutcodes noch DET- of DEM-meldingen gedefinieerd. Interpretatie: aangezien de constructor het standaardgedrag van [basic.string] volgt en geen uitzonderingsveiligheid garandeert, leiden ongeldige indexwaarden voor pos en mislukkende geheugenallocaties vermoedelijk tot het werpen van uitzonderingen [SWS_CORE_03026]. Vraag Q-7ea120ac992dc5ac (open)

Samenspel en verwante eisen

Binnen ara::core::BasicString vult deze constructor de variant met aanvullende lengtebeperking n [SWS_CORE_03027] alsook overloads voor pointers, iterators en initialisatielijsten [SWS_CORE_03028], [SWS_CORE_03031], [SWS_CORE_03032] aan. In tegenstelling tot de constructors zonder bronstring, die voorwaardelijk uitzonderingsveilig [SWS_CORE_03024] of als noexcept zijn gedeclareerd [SWS_CORE_03025], vereist de dynamische overname van deelstrings afzonderlijke aandacht voor mogelijke allocatiefouten. Bovendien dient BasicString als parameterbasis in andere modulebouwstenen zoals Bitset [SWS_CORE_01749].

De constructor [SWS_CORE_03027] van de klasse ara::core::BasicString dient voor het synchroon aanmaken van een nieuwe tekenreeks als deelsequentie uit een brontekenreeks str. Uitgaande van de index pos worden maximaal n tekens overgenomen. Via de optionele parameter a kan een aangepaste allocator worden doorgegeven; anders wordt standaard een standaard-allocatorinstantie aangemaakt. De definitie wordt beschikbaar gesteld via de header #include "ara/core/string.h".

Wat betreft de robuustheid is de functie gedeclareerd als not exception safe ([SWS_CORE_03027]). Volgens de specificatie volgens [basic.string] kan deze constructor mislukken wanneer pos de lengte van de brontekenreeks overschrijdt of de allocatie van de nieuwe buffer mislukt. Vraag Q-31041ea019720daf (open) Dit staat in contrast met standaard- en allocatorconstructors zoals [SWS_CORE_03024] en [SWS_CORE_03025], die gespecificeerd zijn als voorwaardelijk uitzonderingsveilig of expliciet met noexcept.

In het samenspel binnen ara::core::BasicString vult de functie alternatieve overladen versies aan: terwijl [SWS_CORE_03026] de deelreeks vanaf pos tot het einde van de tekenreeks kopieert, staat [SWS_CORE_03027] de expliciete lengtebegrenzing toe. Verdere alternatieven voor creatie bieden iteratorgebaseerde ([SWS_CORE_03031]) of pointergebaseerde initialisaties ([SWS_CORE_03028]). Daarnaast vindt hetzelfde deelreekspatroon met pos en n ook toepassing in verwante klassen zoals Bitset in [SWS_CORE_01749].

De constructorfunctie van de klasse ara::core::BasicString uit de header ara/core/string.h maakt synchroon een string aan vanuit een pointer s naar een teken-array en een expliciete lengteopgave n [SWS_CORE_03028]. Via de parameter a kan optioneel een door de gebruiker gedefinieerde allocator worden doorgegeven, die standaard terugvalt op Allocator() [SWS_CORE_03028]. De semantiek komt overeen met de bepaling in [basic.string], waarbij afwijkend het parametertype charT is vervangen door value_type [SWS_CORE_03028].

In de specificatie is de functie aangeduid als niet uitzonderingsveilig (not exception safe) [SWS_CORE_03028]. Dit onderscheidt haar van uitzonderingsveilige initialisaties zoals de allocator-constructor [SWS_CORE_03025] of de voorwaardelijk uitzonderingsveilige standaardconstructor [SWS_CORE_03024]. Specifieke foutcodes, retourwaarden of diagnoseberichten aan DEM of DET zijn niet voorzien. Als essentiële voorwaarde moet de aanroeper er vermoedelijk voor zorgen dat s verwijst naar een geldig geheugengebied met minimaal n opeenvolgende elementen (interpretatie), om ongedefinieerd gedrag uit te sluiten. Vraag Q-957a57c885a2e702 (open)

Binnen de klasse ara::core::BasicString vormt deze overbelasting een aanvulling op de constructie zonder lengteaanduiding voor nul-getermineerde tekenreeksen [SWS_CORE_03029], evenals constructors voor reeksen van identieke tekens [SWS_CORE_03030] of deelstrings [SWS_CORE_03027]. Na het aanmaken kan het object worden gewijzigd via toekennings- en aaneenschakelingsoperatoren [SWS_CORE_03072]. Daarnaast dient de resulterende tekenreeks als invoer voor interfaces van verwante gegevenstypen, bijvoorbeeld voor de initialisatie van een Bitset [SWS_CORE_01749].

De constructor [SWS_CORE_03029] initialiseert een instantie van ara::core::BasicString op basis van een met nul afgesloten pointer naar tekenreeksen van het type const value_type* en een optionele allocator. De semantiek volgt de standaarddefinitie uit [basic.string], waarbij charT is vervangen door value_type [SWS_CORE_03029]. Het headerbestand is #include "ara/core/string.h" [SWS_CORE_03029].

Wat betreft het foutgedrag en de uitzonderingsveiligheid is de functie expliciet gespecificeerd als not exception safe [SWS_CORE_03029]. Als er tijdens de constructie een geheugenallocatie of een fout optreedt, wordt er geen uitzonderingsgarantie geboden. Daarentegen zijn standaardconstructors zoals [SWS_CORE_03025] geclassificeerd als noexcept en exception safe of [SWS_CORE_03024] als voorwaardelijk uitzonderingsveilig (conditionally exception safe).

De specificatie definieert de interactie binnen de BasicString-constructorfamilie:

• Wordt het aantal tekens expliciet opgegeven, dan dient de overload met lengteparameter (const value_type *s, size_type n, ...) conform [SWS_CORE_03028] te worden gebruikt.
• Verdere alternatieven omvatten deelbereikconstructors uit bestaande strings [SWS_CORE_03026], [SWS_CORE_03027], vulconstructors [SWS_CORE_03030] alsook iterator- [SWS_CORE_03031] en initialisatielijsten [SWS_CORE_03032].
• Voor het naderhand aaneenschakelen met ruwe tekenreekspointers correspondeert operator+= conform [SWS_CORE_03073].
• Bovendien dient BasicString als parameterbasis in andere hulpklassen zoals Bitset conform [SWS_CORE_01749].

Aanroepers moeten ervoor zorgen dat de pointer s geldig en correct met nul afgesloten is (interpretatie: aangezien zonder lengteopgave de afsluiting dient voor de lengtebepaling conform standaardgedrag). Vraag Q-7e0172674e115dea (open) Aangezien de constructor synchroon wordt uitgevoerd, moet er in veiligheidskritische contexten rekening mee worden gehouden dat er potentieel dynamisch geheugen via de allocator wordt betrokken.

Gebruik

De constructor [SWS_CORE_03030] van de klasse ara::core::BasicString (gedefinieerd in de header ara/core/string.h) creëert synchroon een tekenreeks uit n kopieën van het teken c van het type value_type. Het functionele gedrag volgt de C++-standaardspecificatie [basic.string], met de afwijking dat charT is vervangen door value_type. Optioneel kan een door de gebruiker gedefinieerde allocator a worden doorgegeven, waarvoor standaard Allocator() wordt geïnstantieerd.

Foutafhandeling en exception-veiligheid

De specificatie classificeert deze constructor als not exception safe, waarmee hij verschilt van gegarandeerde noexcept-constructors zoals [SWS_CORE_03025] of de voorwaardelijk veilige default-constructor [SWS_CORE_03024]. Interpretatie: Het ontbreken van uitzonderingsveiligheid is vermoedelijk vooral toe te schrijven aan mislukkingen bij de dynamische geheugenallocatie voor n tekens. Vraag Q-87ae8b5cae690fdb (open) Specifieke AUTOSAR-foutcodes of meldingen aan DET of DEM zijn voor deze aanroep niet gespecificeerd.

Gelijktijdigheid en wisselwerking

Gelijktijdige toegang door meerdere threads tot dezelfde instantie zonder externe synchronisatie is niet thread-safe. Na de creatie kan de tekenreeks worden gewijzigd via aaneenschakelingsoperatoren zoals operator+= voor afzonderlijke tekens ([SWS_CORE_03074]) of strings ([SWS_CORE_03072]). De gecreëerde tekenreeks kan bovendien dienen voor de initialisatie van ara::core::Bitset conform [SWS_CORE_01749]. Voor alternatieve creaties zijn constructors via pointers ([SWS_CORE_03028], [SWS_CORE_03029]) of initialisatielijsten ([SWS_CORE_03032]) beschikbaar.

Gebruik

De templatefunctie representeert de bereikconstructor van de klasse ara::core::BasicString in header <ara/core/string.h> [SWS_CORE_03031]. Deze dient voor de synchrone initialisatie van een tekenreeks uit een reeks die wordt gedefinieerd door de invoer-iterators begin en end van het type InputIterator [SWS_CORE_03031]. Optioneel kan via de parameter a een door de gebruiker gedefinieerde allocatorinstantie worden meegegeven; blijft deze parameter oningevuld, dan wordt de standaardinstantie Allocator() aangemaakt [SWS_CORE_03031]. De functionele semantiek volgt daarbij de voorschriften van de C++-standaard voor [basic.string] [SWS_CORE_03031].

Foutafhandeling en exception-veiligheid

De specificatie declareert de functie expliciet als not exception safe [SWS_CORE_03031]. Er worden geen AUTOSAR-specifieke DET- of DEM-meldingen verstuurd, aangezien het gedrag overeenkomt met dat van de C++-standaardbibliotheek [SWS_CORE_03031]. Interpretatie: het ontbreken van uitzonderingsveiligheid is vermoedelijk te wijten aan mogelijke geheugenallocatiefouten door de allocator of mislukkende operaties van de doorgegeven iterators. Vraag Q-676411ee17d37217 (open)

Gelijktijdigheid en beperkingen

De aanroep vindt synchroon plaats in de context van de aanroepende thread. In tegenstelling tot de standaardconstructor [SWS_CORE_03024] of de zuivere allocator-constructor [SWS_CORE_03025] is deze constructor niet gedeclareerd als noexcept. Aanroepers moeten daarom waarborgen dat het bereik [begin, end) geldig is en de gereferentieerde elementen foutloos kunnen worden gelezen.

Samenspel

De functie vormt een aanvulling op de alternatieve constructors van ara::core::BasicString, waaronder deelstring- [SWS_CORE_03026], tekenreeksarray- [SWS_CORE_03028] en initializer-list-overloads [SWS_CORE_03032], die dezelfde uitzonderingsclassificatie hebben. Na constructie kan de instantie worden gewijzigd via concatenatie-operatoren zoals operator+= [SWS_CORE_03072] of dienen ter initialisatie van afhankelijke typen zoals Bitset [SWS_CORE_01749].

De constructor BasicString dient voor de synchrone initialisatie van een instantie van ara::core::BasicString aan de hand van een initialisatielijst ([SWS_CORE_03032]). De declaratie vindt plaats via het headerbestand #include "ara/core/string.h" in de scope van de klasse ara::core::BasicString ([SWS_CORE_03032]). Het gedrag volgt de definitie in [basic.string], waarbij conform de standaard charT door value_type wordt vervangen ([SWS_CORE_03032]). Als parameters worden een std::initializer_list<value_type> en optioneel een allocator meegegeven ([SWS_CORE_03032]).

Wat betreft foutafhandeling en exceptieafhandeling is de constructor gespecificeerd als not exception safe ([SWS_CORE_03032]). Dit onderscheidt deze van de standaardconstructor ([SWS_CORE_03024]) of de expliciete allocator-constructor ([SWS_CORE_03025]), die als uitzonderingsveilig resp. noexcept zijn gedeclareerd. Specifieke AUTOSAR-foutcodes, DET- of DEM-meldingen zijn voor deze constructor niet gedefinieerd. Interpretatie: Bij onvoldoende geheugen mislukt de objectcreatie vermoedelijk, aangezien voor de elementen van de initialisatielijst dynamisch geheugen moet worden gealloceerd. Vraag Q-7ecc7431c1c2f54c (open)

In samenspel met de module core vormt de functie een aanvulling op alternatieve constructiewijzen, zoals het aanmaken vanuit deelstrings ([SWS_CORE_03026], [SWS_CORE_03027]), pointers ([SWS_CORE_03028], [SWS_CORE_03029]) of iterators ([SWS_CORE_03031]). Voor het achteraf uitbreiden van een bestaande string met een initialisatielijst staat de corresponderende operator+= klaar ([SWS_CORE_03075]). Bovendien kunnen gecreëerde BasicString-instanties worden gebruikt voor het initialiseren van verwante datatypen zoals Bitset ([SWS_CORE_01749]).

De copy-constructor [SWS_CORE_03033] van de klasse ara::core::BasicString dient voor het synchroon creëren van een nieuwe tekenreeks als kopie van een bestaande instantie onder expliciete doorgifte van een allocator. De functiedeclaratie BasicString (const BasicString &, const Allocator &); wordt beschikbaar gesteld via de header #include "ara/core/string.h" [SWS_CORE_03033]. De functionele semantiek richt zich daarbij naar het overeenkomstige gebruik in het standaardpatroon [basic.string] [SWS_CORE_03033].

Met betrekking tot de foutafhandeling is de constructorfunctie in de specificatie uitdrukkelijk geclassificeerd als not exception safe [SWS_CORE_03033]. Specifieke AUTOSAR-foutcodes of notificaties aan diagnosemodules zoals DET of DEM bestaan niet voor deze aanroep; exceptions bij de dynamische geheugenallocatie door de allocator zijn daarom vermoedelijk onderworpen aan het algemene gedrag van [basic.string]. Vraag Q-496b847c39fc25ae (open)

Wat betreft gelijktijdigheid en randvoorwaarden vereist het doorgeven van de broninstantie via const BasicString & dat het bronobject tijdens het kopieerproces niet gelijktijdig wordt gewijzigd. Gelijktijdige leestoegang vanuit meerdere threads is toegestaan, terwijl onbeveiligde parallelle schrijftoegang vermoedelijk leidt tot inconsistentie van gegevens. Vraag Q-daa5ef2c4672b657 (open)

In samenspel met verwante specificatie-elementen staat de constructor naast alternatieve initialisatiepaden zoals de move-constructor met allocator [SWS_CORE_03034], de default-constructor [SWS_CORE_03024] of de allocator-constructor [SWS_CORE_03025]. Het gecreëerde object kan naadloos worden gewijzigd via operatoren zoals operator+= [SWS_CORE_03072] of worden gebruikt voor de initialisatie van afhankelijke typen zoals Bitset [SWS_CORE_01749].

De move-constructor [SWS_CORE_03034] van de klasse ara::core::BasicString wordt beschikbaar gesteld via het headerbestand #include "ara/core/string.h". Hij creëert synchroon een nieuwe tekenreeks door de gegevens van een bestaande instantie over te nemen en te binden aan een expliciet gespecificeerde allocator. Het semantische gedrag en de vereisten komen daarbij overeen met de bepalingen van de ISO-C++-standaard in [basic.string].

In de aanroepcontext vereist de functie twee parameters: een rvalue-referentie naar een bronobject (BasicString&&) en een allocator-instantie (const Allocator&). Het bronobject bevindt zich na het move-proces in een geldige, maar gewijzigde toestand. Wat betreft de foutafhandeling is de functie in [SWS_CORE_03034] geclassificeerd als not exception safe. Interpretatie: Dit is vermoedelijk toe te schrijven aan het feit dat bij een afwijkende of incompatibele allocator nieuw geheugen moet worden gealloceerd en de elementen moeten worden gekopieerd, wat bij geheugengebrek kan mislukken. Vraag Q-2a89ad749ae1b2f6 (open) Dit onderscheidt de constructor van strikt uitzonderingsveilige overloads zoals [SWS_CORE_03025] of voorwaardelijk uitzonderingsveilige varianten zoals [SWS_CORE_03024].

In het samenspel binnen core vult de signatuur het spectrum van aanmaakmethoden aan naast de kopieerconstructor met allocator [SWS_CORE_03033] en deeltekenreeks-initialiseerders zoals [SWS_CORE_03026]. Na succesvolle instantiëring kan de tekenreeks worden gewijzigd, bijvoorbeeld door inhoud toe te voegen via operator+= ([SWS_CORE_03072], [SWS_CORE_03307]), of dienen als invoer voor afhankelijke gegevenstypen zoals Bitset conform [SWS_CORE_01749].

Gebruik en semantiek

De elementfunctie append van de klasse ara::core::BasicString ([SWS_CORE_03076]) uit het headerbestand #include "ara/core/string.h" dient voor het synchroon toevoegen van een volledig tekenreeksobject str van het type BasicString aan de aanroepende instantie. De semantiek volgt de gestandaardiseerde C++-definitie onder [basic.string]; als retourwaarde levert de functie een referentie naar het gewijzigde object (*this) op ([SWS_CORE_03076]).

Foutafhandeling en randvoorwaarden

Wat betreft exception-veiligheid is de bewerking expliciet geclassificeerd als not exception safe ([SWS_CORE_03076]). Interpretatie: treedt er tijdens de uitvoering een fout op (bijvoorbeeld bij onvoldoende geheugen), dan is de toestand van de tekenreeks vermoedelijk onbepaald, aangezien er geen herstelgaranties zijn gespecificeerd. Vraag Q-57504af4ee633d0b (open) In tegenstelling tot varianten met positie-indices zoals [SWS_CORE_03077] of [SWS_CORE_03309] (activeren van IsoStdOutOfRangeViolation) of buffergroottecontroles zoals [SWS_CORE_03078] (activeren van IsoStdLengthErrorViolation) definieert [SWS_CORE_03076] geen afzonderlijke violations.

Interactie en overbelastingen

De functie maakt deel uit van een familie overbelastingen binnen ara::core::BasicString:

• Toevoegen van deelstrings via positie- en lengtegegevens ([SWS_CORE_03077]).
• Overname van tekenarrays van het type value_type* met gedefinieerde lengte ([SWS_CORE_03078]) of als nul-getermineerde tekenreeks ([SWS_CORE_03079]).
• Meervoudig toevoegen van afzonderlijke tekens ([SWS_CORE_03080]) of toekenning via std::initializer_list<value_type> ([SWS_CORE_03082]).
• Integratie van iteratorbereiken ([SWS_CORE_03081]) en string-views met behulp van StringView ([SWS_CORE_03308]) en typespecifieke templates ([SWS_CORE_03309]).

De lidfunctie append van de klasse ara::core::BasicString ([SWS_CORE_03077], gedeclareerd in #include "ara/core/string.h") voegt synchroon een deelstring van een andere BasicString-instantie str toe aan het huidige object. De parameters pos en n (standaard npos) bepalen de startindex en het maximale aantal tekens binnen str. Als returnwaarde wordt een referentie naar het gewijzigde doelobject (*this) opgeleverd.

Wat betreft semantiek en interfacegedrag volgt de functie de definitie in [basic.string] van de C++-standaard, maar wijkt af bij de foutafhandeling: als pos > str.size() geldt, wordt conform [SWS_CORE_03077] een IsoStdOutOfRangeViolation geactiveerd (analoog aan std::out_of_range). De specificatie classificeert de bewerking uitdrukkelijk als not exception safe, waardoor er bij fouten geen garantie is op een ongewijzigde of consistente objecttoestand.

Bij gebrek aan gedocumenteerde synchronisatiemechanismen is een gelijktijdige aanroep op dezelfde instantie vermoedelijk niet thread-safe. Vraag Q-ec3b029fca94ad8a (open) Voor alternatieve gegevensbronnen zijn in de module aanvullende overbelastingen beschikbaar: gehele strings ([SWS_CORE_03076]), buffers en pointers ([SWS_CORE_03078], [SWS_CORE_03079]), herhalingen van tekens ([SWS_CORE_03080]), iteratorparen ([SWS_CORE_03081]), initialisatielijsten ([SWS_CORE_03082]) en StringView-objecten ([SWS_CORE_03308], [SWS_CORE_03309]).

De elementfunctie append van de klasse ara::core::BasicString ([SWS_CORE_03078]) voegt de eerste n tekens van de meegegeven tekenarray s van het type const value_type* synchroon toe aan de bestaande string. Als retourwaarde levert de functie een referentie naar de gewijzigde instantie (BasicString&), wat het aaneenschakelen van opeenvolgende aanroepen mogelijk maakt. De declaratie is beschikbaar via het headerbestand #include "ara/core/string.h".

Het functionele gedrag volgt de specificatie van std::basic_string::append conform [basic.string], maar vertoont specifieke AUTOSAR-afwijkingen ([SWS_CORE_03078]):

• De template-parameter charT wordt vervangen door het type value_type.
• Overschrijdt de resulterende lengte de capaciteitsgrens (voorwaarde size() > n + max_size()), dan wordt in plaats van een std::length_error de overtreding IsoStdLengthErrorViolation geactiveerd.

Wat betreft uitvoeringsveiligheid is de bewerking expliciet gespecificeerd als not exception safe ([SWS_CORE_03078]). Treedt er tijdens de geheugenallocatie of bij het kopiëren een fout resp. overtreding op, dan garandeert het object geen consistente tussentoestand.

De methode vult de overige overbelastingen van append binnen ara::core::BasicString aan. Daartoe behoren het toevoegen van volledige instanties ([SWS_CORE_03076]), van deelstrings met bereikcontrole via IsoStdOutOfRangeViolation ([SWS_CORE_03077]), nul-getermineerde tekenreeksen ([SWS_CORE_03079]), reeksen van identieke tekens ([SWS_CORE_03080]), iteratorbereiken ([SWS_CORE_03081]), initialisatielijsten ([SWS_CORE_03082]) en StringView-objecten ([SWS_CORE_03308], [SWS_CORE_03309]).

De lidfunctie append van de klasse ara::core::BasicString ([SWS_CORE_03079]) voegt een nul-getermineerde tekenreeks van het pointertype const value_type* toe aan de bestaande tekenreeks. De semantiek komt overeen met het gedrag uit de C++-standaard [basic.string], waarbij charT wordt vervangen door value_type. Als retourwaarde levert de synchrone functie een referentie op naar het aanroepende object (BasicString&), wat het koppelen van opeenvolgende bewerkingen mogelijk maakt.

Wat betreft foutafhandeling en uitzonderingsveiligheid is de bewerking expliciet geclassificeerd als not exception safe ([SWS_CORE_03079]). In tegenstelling tot de overbelasting met lengteopgave [SWS_CORE_03078], die bij overschrijding van de maximale lengte een IsoStdLengthErrorViolation activeert, of deelstring-overbelastingen zoals [SWS_CORE_03077] met IsoStdOutOfRangeViolation, definieert deze variant geen specifieke schendingsklassen. Het ligt vermoedelijk in de verantwoordelijkheid van de aanroeper om ervoor te zorgen dat de doorgegeven pointer s verwijst naar een geldige, nul-getermineerde tekenreeks. Vraag Q-4e959f75f98977eb (open)

De functie maakt deel uit van een familie overbelastingen voor het toevoegen van gegevens in ara::core::BasicString:

• Toevoegen van volledige of gedeeltelijke tekenreeksen van hetzelfde type ([SWS_CORE_03076], [SWS_CORE_03077]),
• Toevoegen van pointer-voorvoegsels met expliciete lengtebeperking ([SWS_CORE_03078]),
• Toevoegen van tekenherhalingen ([SWS_CORE_03080]) of initialisatielijsten ([SWS_CORE_03082]),
• Verwerking van iteratorbereiken ([SWS_CORE_03081]) en string-views ([SWS_CORE_03308], [SWS_CORE_03309]).

De lidfunctie append van ara::core::BasicString ([SWS_CORE_03080]) voegt een opgegeven aantal n tekens van het type value_type (parameter c) synchroon toe aan de bestaande tekenreeks. Deze wordt beschikbaar gesteld via de header ara/core/string.h en retourneert een referentie naar de gewijzigde instantie (*this), wat gekoppelde aanroepen mogelijk maakt.

Het functionele gedrag volgt de definitie van de C++-standaard voor [basic.string], waarbij charT wordt vervangen door value_type ([SWS_CORE_03080]). Wat betreft uitzonderingsveiligheid is de functie expliciet geclassificeerd als not exception safe ([SWS_CORE_03080]). In tegenstelling tot andere overbelastingen zoals [SWS_CORE_03077] of [SWS_CORE_03078] zijn voor deze variant geen specifieke runtime-schendingen (violations) zoals IsoStdOutOfRangeViolation of IsoStdLengthErrorViolation gedefinieerd. Vermoedelijk garandeert de methode bij fouten geen ongewijzigde toestand van de instantie. Vraag Q-15af6c12a1a342a9 (open)

In de context van concurrency en thread-veiligheid moet worden opgemerkt dat gelijktijdige schrijftoegangen tot dezelfde instantie van BasicString vermoedelijk extern moeten worden gesynchroniseerd. Vraag Q-1e8a1511516e4cd8 (open) De functie vormt een aanvulling op de overige overbelastingen van append in ara::core::BasicString, die het toevoegen van volledige tekenreeksen ([SWS_CORE_03076]), deelbereiken ([SWS_CORE_03077]), pointerbuffers ([SWS_CORE_03078], [SWS_CORE_03079]), iteratorbereiken ([SWS_CORE_03081]), initialisatielijsten ([SWS_CORE_03082]) of StringView-objecten ([SWS_CORE_03308], [SWS_CORE_03309]) afdekken.

Gebruik en semantiek

De template-lidfunctie append van de klasse ara::core::BasicString wordt beschikbaar gesteld via het headerbestand ara/core/string.h [SWS_CORE_03081]. Deze voegt een sequentie van tekens, die wordt begrensd door het iteratorpaar first en last van de categorie InputIterator, synchroon toe aan de bestaande tekenreeks [SWS_CORE_03081]. Het functionele gedrag richt zich daarbij naar de overeenkomstige definitie in [basic.string] van de C++-standaard [SWS_CORE_03081]. Als retourwaarde levert de bewerking een referentie op naar het gewijzigde BasicString-object (*this) [SWS_CORE_03081].

Foutafhandeling en uitzonderingsveiligheid

Voor deze functie is de uitzonderingsveiligheid expliciet vastgelegd als not exception safe [SWS_CORE_03081]. In geval van een fout – bijvoorbeeld bij uitputting van het dynamische geheugen tijdens buffervergroting – blijft de instantie naar interpretatie vermoedelijk in een ongeldige toestand achter. Vraag Q-600c7dacc868877c (open) Specifieke AUTOSAR-violations zoals IsoStdOutOfRangeViolation of IsoStdLengthErrorViolation zijn voor deze iterator-overbelasting niet gedefinieerd, in tegenstelling tot andere overbelastingen van de methode [SWS_CORE_03077], [SWS_CORE_03078].

Interactie in de module

De functie maakt deel uit van een omvangrijke groep overbelastingen voor het toevoegen van gegevens aan ara::core::BasicString:

• Toevoegen van volledige of partiële tekenreeksen van het type BasicString [SWS_CORE_03076], [SWS_CORE_03077].
• Toevoegen van tekenarrays met lengteopgave of nul-getermineerde tekenreeksen [SWS_CORE_03078], [SWS_CORE_03079].
• Herhaald toevoegen van afzonderlijke tekens [SWS_CORE_03080] en overname uit std::initializer_list [SWS_CORE_03082].
• Integratie van moderne string-views via StringView resp. generieke view-types [SWS_CORE_03308], [SWS_CORE_03309].

De iteratorvariant [SWS_CORE_03081] biedt daarbij maximale flexibiliteit voor de integratie van willekeurige generieke gegevensbronnen.

De lidfunctie append van de klasse ara::core::BasicString voegt de tekens van een initialisatielijst van het type std::initializer_list<value_type> synchroon toe aan het bestaande string-object [SWS_CORE_03082]. Het gedrag volgt de semantiek van [basic.string] uit de C++-standaard, met de afwijking dat charT is vervangen door value_type [SWS_CORE_03082]. De aanroep wijzigt de instantie direct en levert een referentie naar het object op, wat methodekoppeling mogelijk maakt.

Wat betreft foutafhandeling is de functie geclassificeerd als niet-uitzonderingsveilig (not exception safe) [SWS_CORE_03082]. Anders dan verwante overbelastingen zoals [SWS_CORE_03077] of [SWS_CORE_03078] definieert deze variant geen specifieke schendingen zoals IsoStdOutOfRangeViolation of IsoStdLengthErrorViolation. Interpretatie: Mislukt de interne geheugenallocatie, dan blijft het object vermoedelijk in een ongedefinieerde toestand achter. Vraag Q-169750518dc1904b (open) Aangezien de interne toestand wordt gewijzigd, leidt een gelijktijdige aanroep zonder externe synchronisatie vermoedelijk tot datacraces.

In het samenspel binnen ara::core::BasicString maakt de functie deel uit van een groep verwante append-bewerkingen. Deze vult overbelastingen aan voor gehele tekenreeksen ([SWS_CORE_03076]), deelbereiken ([SWS_CORE_03077]), pointers naar tekenreeksen ([SWS_CORE_03078], [SWS_CORE_03079]), herhaalde afzonderlijke tekens ([SWS_CORE_03080]), iteratorbereiken ([SWS_CORE_03081]) en StringView-instanties ([SWS_CORE_03308], [SWS_CORE_03309]).

Gebruik

De synchrone elementfunctie append van de klasse ara::core::BasicString voegt de tekens van een meegegeven tekenreeksweergave (StringView sv) toe aan de bestaande tekenreeks [SWS_CORE_03308]. De interface wordt ingesloten via de header #include "ara/core/string.h" [SWS_CORE_03308]. Zij retourneert een referentie naar de aanroepende instantie (BasicString &), waardoor meerdere modificaties aaneengeschakeld kunnen worden [SWS_CORE_03308]. De functionele semantiek volgt de overeenkomstige specificatie in C++ [basic.string] [SWS_CORE_03308].

Foutafhandeling en exception-veiligheid

De functie is in AUTOSAR expliciet gespecificeerd als niet uitzonderingsveilig („not exception safe”) [SWS_CORE_03308]. Specifieke foutcodes, DET- of DEM-meldingen en expliciete AUTOSAR-violations zijn voor deze aanroep niet vastgelegd, terwijl verwante overbelastingen zoals [SWS_CORE_03077] of [SWS_CORE_03309] bij indexoverschrijdingen een IsoStdOutOfRangeViolation en [SWS_CORE_03078] bij lengteoverschrijdingen een IsoStdLengthErrorViolation activeren.

Gelijktijdigheid en wisselwerking

Aangezien append de toestand van het aangeroepen string-object direct wijzigt, is gelijktijdige toegang door meerdere threads tot dezelfde instantie zonder externe synchronisatie vermoedelijk niet thread-veilig. Vraag Q-814665e285846c8e (open) De methode staat in verband met verdere append-varianten van ara::core::BasicString, die het toevoegen van volledige BasicString-instanties [SWS_CORE_03076], C-strings [SWS_CORE_03079], herhaalde afzonderlijke tekens [SWS_CORE_03080] en iteratorbereiken [SWS_CORE_03081] of initialisatielijsten [SWS_CORE_03082] mogelijk maken.

Gebruik

De template-functie append van de klasse ara::core::BasicString ([SWS_CORE_03309]) uit het headerbestand #include "ara/core/string.h" dient voor het synchroon toevoegen van een deelbereik van een object t aan de aanroepende tekenreeks. Het gedrag is georiënteerd op de ISO-C++-specificatie [basic.string]. De parameter pos legt de startindex in het bronobject vast, terwijl n het maximale aantal toe te voegen tekens bepaalt (standaardwaarde npos). Als retourwaarde wordt een referentie naar het gewijzigde tekenreeksobject (*this) geleverd. Interpretatie: Het overgedragen object t wordt intern vermoedelijk geïnterpreteerd als string-view sv. Vraag Q-9752a5eeaf05b684 (open)

Foutafhandeling

AUTOSAR definieert voor deze functie een specifieke afwijking van de C++-standaard: als de opgegeven positie groter is dan de grootte van het bronbereik (pos > sv.size()), wordt een IsoStdOutOfRangeViolation geactiveerd in plaats van std::out_of_range ([SWS_CORE_03309]). De semantische beschrijving van deze schending komt overeen met die van std::out_of_range.

Beperkingen en uitzonderingsveiligheid

De bewerking is in de specificatie uitdrukkelijk geclassificeerd als not exception safe ([SWS_CORE_03309]). Bij optredende fouten wordt daarom geen stabiel behoud van de eerdere toestand gegarandeerd.

Samenspel

De functie vormt een aanvulling op de overige varianten voor uitbreiding van tekenreeksen in ara::core::BasicString. Hiertoe behoren overbelastingen voor volledige BasicString-instanties ([SWS_CORE_03076]) of deelbereiken daarvan ([SWS_CORE_03077]), C-tekenreeksen met lengteopgave ([SWS_CORE_03078]) resp. als nul-getermineerde pointers ([SWS_CORE_03079]), tekenherhalingen ([SWS_CORE_03080]), iteratorbereiken ([SWS_CORE_03081]), initialisatielijsten ([SWS_CORE_03082]) en afzonderlijke StringView-objecten ([SWS_CORE_03308]).

De elementfunctie assign van de klasse ara::core::BasicString dient voor het synchroon toekennen van de inhoud van een bestaande tekenreeks aan de aanroepende instantie conform het gedrag van [basic.string] [SWS_CORE_03084]. De functie wordt beschikbaar gesteld via de header ara/core/string.h en accepteert een constante referentie naar een BasicString-object (const BasicString &str). Als retourwaarde levert zij een referentie naar het gewijzigde doelobject (*this), wat methodeketens mogelijk maakt [SWS_CORE_03084].

Wat betreft robuustheid is de functie expliciet gespecificeerd als not exception safe [SWS_CORE_03084]. Bij dynamische geheugenallocaties tijdens het kopiëren kunnen fouten optreden die niet door uitzonderingsgaranties worden opgevangen; in het geval van een fout blijft de instantie vermoedelijk in een ongedefinieerde toestand achter. Vraag Q-0ddd5ac03e56490f (open) Specifieke AUTOSAR-foutcodes of meldingen aan DET of DEM zijn voor deze toekenningsfunctie niet voorzien.

In samenspel met andere interfaces vormt assign de kopieervariant binnen een familie van toekenningsfuncties. Terwijl de verplaatsende overbelasting [SWS_CORE_03085] gedeclareerd is als conditionally exception safe, delen de overige toekenningen – zoals via deelstrings [SWS_CORE_03086], string-views [SWS_CORE_03087] of iteratorbereiken [SWS_CORE_03091] – de eigenschap not exception safe. Aangezien er geen thread-veiligheid is gespecificeerd, is een gelijktijdige aanroep op dezelfde instantie zonder externe synchronisatie vermoedelijk niet-re-entrant en onveilig wat betreft data. Vraag Q-37d67c851a296f55 (open)

De move-overbelasting van de lidfunctie assign conform [SWS_CORE_03085] wijst synchroon de inhoud van de rvalue-referentie str toe aan een bestaande instantie van ara::core::BasicString (gedeclareerd in het headerbestand ara/core/string.h). De functie retourneert een referentie naar het aanroepende object (*this). Het functionele gedrag richt zich daarbij naar de overeenkomstige definitie in [basic.string] van de C++-standaard.

Met betrekking tot fout- en uitzonderingsafhandeling is de methode gedeclareerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) [SWS_CORE_03085]. Het activeren van uitzonderingen is via noexcept precies dan uitgesloten wanneer de allocator de move-toewijzing doorgeeft (propagate_on_container_move_assignment::value) of allocator-instanties altijd als gelijk gelden (is_always_equal::value). In tegenstelling tot andere toewijzingsfuncties zoals [SWS_CORE_03086] of [SWS_CORE_03088], die bij bereik- of lengteoverschrijdingen specifieke schendingen zoals IsoStdOutOfRangeViolation resp. IsoStdLengthErrorViolation activeren en als niet-uitzonderingsveilig gelden, definieert deze bewerking geen afzonderlijke AUTOSAR-violations.

In samenspel met alternatieve overbelastingen van BasicString::assign – bijvoorbeeld voor constante lvalue-referenties volgens [SWS_CORE_03084], views via [SWS_CORE_03087] of tekenreeksbuffers conform [SWS_CORE_03089] – maakt de rvalue-variant een bronefficiënte toewijzing mogelijk zonder nieuwe toewijzing van geheugen. Interpretatie: Na de overdracht bevindt het bronobject str zich vermoedelijk in een geldige, maar niet-gespecificeerde toestand, zoals gebruikelijk is voor move-bewerkingen volgens [basic.string]. Vraag Q-88c8157963cdd7e0 (open)

De elementfunctie assign van de klasse ara::core::BasicString ([SWS_CORE_03086]), beschikbaar gesteld via de header ara/core/string.h, kent synchroon een deelbereik van een meegegeven brontekenreeks str toe aan de huidige instantie. De aanroep accepteert naast de bronreferentie str de startindex pos en optioneel het aantal tekens n, waarvoor standaard npos is gedefinieerd. Na de toekenning wordt een referentie naar het gewijzigde object (*this) geretourneerd. De functionele semantiek komt daarbij in principe overeen met de voorschriften uit [basic.string] ([SWS_CORE_03086]).

Bij de foutafhandeling bestaat er een expliciete afwijking ten opzichte van de ISO-C++-standaard: indien voorwaarde pos > str.size() van toepassing is, wordt er geen std::out_of_range geactiveerd, maar wordt een IsoStdOutOfRangeViolation teweeggebracht ([SWS_CORE_03086]). Bovendien is de functie in de specificatie uitdrukkelijk geclassificeerd als niet uitzonderingsveilig (not exception safe) ([SWS_CORE_03086]).

Binnen het geheel van toekenningsmethoden van ara::core::BasicString vult deze deelstring-overbelasting de toekenning van volledige tekenreeksen ([SWS_CORE_03084]), de voorwaardelijk uitzonderingsveilige move-toekenning ([SWS_CORE_03085]), de toekenning vanuit een StringView ([SWS_CORE_03087]) en bewerkingen met tekenbuffers ([SWS_CORE_03088]) of iteratorbereiken ([SWS_CORE_03091]) aan.

Gebruik

De elementfunctie assign voor StringView ([SWS_CORE_03087]) vervangt de inhoud van een ara::core::BasicString-instantie synchroon door de tekens van de meegegeven tekenreeksweergave. De semantiek volgt de overeenkomstige definitie in [basic.string] van de C++-standaardbibliotheek. Als retourwaarde levert de functie een referentie naar het gewijzigde doelobject (BasicString &), wat het aaneenschakelen van opeenvolgende methode-aanroepen mogelijk maakt. De declaratie wordt beschikbaar gesteld via het headerbestand #include "ara/core/string.h".

Foutafhandeling en exception-veiligheid

De functie is in de specificatie aangeduid als not exception safe ([SWS_CORE_03087]). Interpretatie: vereist de toekenning een vergroting van de interne buffercapaciteit en mislukt deze geheugenallocatie, dan wordt er vermoedelijk een uitzondering geactiveerd zonder dat er een garantie bestaat voor de ongewijzigde toestand van de instantie. Vraag (open)

Gelijktijdigheid en beperkingen

Interpretatie: aanroepen van assign op dezelfde instantie van ara::core::BasicString zijn niet thread-veilig en vereisen bij gelijktijdige lees- of schrijftoegang door meerdere threads externe synchronisatie. Vraag Q-12774d6cd363b032 (open)

Samenspel

De functie breidt het toekenningsspectrum van ara::core::BasicString uit met typeveilige views. Zij bestaat naast de overbelastingen voor kopieer- en verplaatstoekenningen ([SWS_CORE_03084], [SWS_CORE_03085]), deelstrings ([SWS_CORE_03086]), pointers naar tekendata ([SWS_CORE_03088], [SWS_CORE_03089]), tekenherhalingen ([SWS_CORE_03090]), iteratorbereiken ([SWS_CORE_03091]) en initialisatielijsten ([SWS_CORE_03092]).

Gebruik

De elementfunctie assign van de klasse ara::core::BasicString kent aan de huidige tekenreeksinstantie synchroon de eerste n tekens uit de meegegeven tekenarray s van het type const value_type* toe en levert een referentie naar het gewijzigde object (*this) terug [SWS_CORE_03088]. Het functionele gedrag komt in principe overeen met de definitie volgens [basic.string], waarbij AUTOSAR het generieke parametertype charT vervangt door value_type [SWS_CORE_03088].

Foutafhandeling en randvoorwaarden

De toekenning is gespecificeerd als niet uitzonderingsveilig (not exception safe) [SWS_CORE_03088]. Indien de opgegeven lengte n de maximaal representeerbare grootte max_size() overschrijdt (n > max_size()), genereert de functie de AUTOSAR-overtreding IsoStdLengthErrorViolation in plaats van std::length_error [SWS_CORE_03088]. Interpretatie: de aanroeper moet er vermoedelijk voor zorgen dat s verwijst naar minimaal n geldige tekens, aangezien de specificatie geen afzonderlijke buffercontrole definieert. Vraag Q-290c36db79f27a0a (open)

Samenspel

De functie is primair geschikt voor niet-nul-getermineerde buffers of deelbereiken van arrays. Zij vormt een aanvulling op de overbelasting assign(const value_type* s) [SWS_CORE_03089], waarbij de lengte impliciet wordt bepaald. Binnen het klassenverband van ara::core::BasicString bestaan er verdere toekennings-overbelastingen voor het overnemen van bestaande tekenreeksen via kopie [SWS_CORE_03084] of verplaatsing [SWS_CORE_03085], voor het toekennen van deelstrings met indexcontrole [SWS_CORE_03086], voor overname uit StringView [SWS_CORE_03087], evenals voor tekenherhalingen [SWS_CORE_03090], iteratorbereiken [SWS_CORE_03091] en initialisatielijsten [SWS_CORE_03092].

De synchrone elementfunctie assign van de klasse ara::core::BasicString ([SWS_CORE_03089]) uit de header ara/core/string.h vervangt de actuele inhoud van een tekenreeksobject door de meegegeven tekenreeks s van het type const value_type*. De aanroep levert een referentie naar het gewijzigde object (*this) op. Het functionele gedrag volgt de voorschriften van de ISO-C++-standaard voor [basic.string] met de gedocumenteerde afwijking dat het tekentype charT is vervangen door value_type ([SWS_CORE_03089]). Interpretatie: Bij gebrek aan een afzonderlijke lengteparameter wijst de pointer s vermoedelijk naar een nulgetermineerde tekenarray. Vraag Q-eea79e929750c27f (open)

Wat betreft de foutafhandeling en robuustheid is de toewijzingsfunctie geclassificeerd als niet-uitzonderingsveilig (not exception safe) ([SWS_CORE_03089]). In tegenstelling tot verwante overbelastingen zoals assign(const BasicString&, size_type, size_type) ([SWS_CORE_03086]) of assign(const value_type*, size_type) ([SWS_CORE_03088]) zijn voor deze variant geen specifieke runtime-schendingen zoals IsoStdOutOfRangeViolation of IsoStdLengthErrorViolation gedefinieerd.

In de module core maakt de functie deel uit van een omvangrijke familie van overbelastingen voor inhoudstoewijzing. Deze dekt naast raw pointers ook volledige strings ([SWS_CORE_03084]), move-semantiek ([SWS_CORE_03085]), StringView-instanties ([SWS_CORE_03087]), herhaalde afzonderlijke tekens ([SWS_CORE_03090]), iteratorbereiken ([SWS_CORE_03091]) en initialisatielijsten ([SWS_CORE_03092]) af. Gelijkaardige toewijzingspatronen stelt AUTOSAR ook beschikbaar in containertypen zoals ara::core::Vector ([SWS_CORE_01328]).

Gebruik

De elementfunctie assign van de klasse ara::core::BasicString (gedefinieerd in #include "ara/core/string.h") vervangt de actuele inhoud van de tekenreeks synchroon door n opeenvolgende kopieën van het teken c van het type value_type [SWS_CORE_03090]. De semantiek komt overeen met de bepaling voor [basic.string] met de afwijking dat de typeparameter charT wordt vervangen door value_type [SWS_CORE_03090]. Als retourwaarde levert de functie een lvalue-referentie naar de gemodificeerde instantie (*this) op, wat het aaneenschakelen van verdere bewerkingen mogelijk maakt.

Foutafhandeling en uitzonderingsveiligheid

De bewerking is volgens de specificatie expliciet geclassificeerd als not exception safe [SWS_CORE_03090]. In tegenstelling tot andere overbelastingen, die bij grensoverschrijdingen gedefinieerde schendingen zoals IsoStdOutOfRangeViolation [SWS_CORE_03086] of IsoStdLengthErrorViolation [SWS_CORE_03088] activeren, noemt deze functie geen specifieke violations. Mislukt een vereiste geheugenaanvraag, dan bestaan er geen garanties over het voortbestaan van de eerdere toestand van het object.

Gelijktijdigheid en beperkingen

Aangezien de toewijzing de interne buffer direct wijzigt en er geen interne synchronisatie gespecificeerd is, is de gelijktijdige toegang van meerdere threads tot dezelfde instantie vermoedelijk niet thread-safe (interpretatie). Vraag Q-50f419c4bca5c151 (open) Parallelle aanroepen moeten door de aanroeper extern worden gecoördineerd.

Samenspel

De functie vult het toewijzingsportfolio van ara::core::BasicString aan, dat naast kopieer- en verplaatstoewijzingen [SWS_CORE_03084], [SWS_CORE_03085] en iterators en initialisatielijsten [SWS_CORE_03091], [SWS_CORE_03092] ook interfaces voor string-views ter beschikking stelt [SWS_CORE_03087]. Een vergelijkbaar toewijzingspatroon met herhalingsaantal bestaat analoog voor ara::core::Vector::assign [SWS_CORE_01329].