klasse ara::core::StringView

Gebruik

De lidfunctie at van de klasse ara::core::StringView biedt synchrone leestoegang tot afzonderlijke tekens ([SWS_CORE_02133]). Deze accepteert als parameter de index pos van het type size_type en geeft een constante referentie (const_reference) naar het teken op die positie terug. De functie is gespecificeerd als constexpr en noexcept, waardoor aanroepen ook tijdens compileertijd kunnen worden geëvalueerd.

Foutafhandeling

In tegenstelling tot het gedrag in de standaard [string.view] werpt de functie bij fouten geen exceptie van het type std::out_of_range op ([SWS_CORE_02133]). Wanneer aan de voorwaarde pos >= size() is voldaan, wordt in plaats daarvan een IsoStdOutOfRangeViolation geactiveerd. De specificatie classificeert de functie als uitzonderingsveilig (exception safe).

Gelijktijdigheid en beperkingen

Aangezien at gedeclareerd is als const, wijzigt de aanroep de onderliggende instantie niet. De aanroeper moet ervoor zorgen dat de gerefereerde tekenreeks geldig blijft gedurende de gehele levensduur van het StringView-object. Bij het optreden van de bereikschending IsoStdOutOfRangeViolation wordt de uitvoering vermoedelijk gecontroleerd afgebroken; aangepaste afbreekroutines kunnen hiervoor via AddAbortHandler ([SWS_CORE_00054]) worden geregistreerd (interpretatie). Vraag Q-0836f4dc6fa946a6 (open)

Samenspel

Het concept om bereikoverschrijdingen via IsoStdOutOfRangeViolation af te vangen, wordt consistent toegepast over meerdere containers in ara::core:

• In ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]) en ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]) is at eveneens gedeclareerd als noexcept en uitzonderingsveilig.
• In tegenstelling daartoe zijn de overeenkomstige at-functies in ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]) en in ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]) geclassificeerd als niet-uitzonderingsveilig (not exception safe) en niet gemarkeerd als noexcept.

Gebruik

De memberfunctie compare van de klasse ara::core::StringView uit de header #include "ara/core/string_view.h" dient voor de synchrone lexicografische vergelijking van de actuele tekenreeksweergave met een meegegeven instantie s van het type StringView [SWS_CORE_02142]. Het gedrag richt zich naar het overeenkomstige gebruik in [string.view] van de C++-standaard [SWS_CORE_02142]. Als retourwaarde levert de functie een int, die de relationele verhouding van de tekensequenties weergeeft [SWS_CORE_02142].

Foutafhandeling

De functie is gedeclareerd met noexcept en gespecificeerd als exception safe [SWS_CORE_02142]. Zij genereert geen C++-uitzonderingen. Specifieke foutcodes, AUTOSAR-ontwikkelfouten (DET) of meldingen aan de Diagnostic Event Manager (DEM) zijn voor deze bewerking niet voorzien [SWS_CORE_02142].

Gelijktijdigheid en randvoorwaarden

Door de indeling als const en constexpr kan de aanroep reeds tijdens compile-time worden geëvalueerd [SWS_CORE_02142]. Interpretatie: Aangezien de functie lezende toegang heeft tot onveranderlijke tekenreeksen, is een gelijktijdige aanroep via dezelfde StringView vanuit meerdere threads vermoedelijk thread-safe, mits de onderliggende tekendata niet worden gewijzigd. Vraag Q-7489abeeb3fd7124 (open)

Samenspel

Terwijl basistypen in ara::core zoals ErrorDomain [SWS_CORE_00137] of ErrorCode [SWS_CORE_00571] primair binaire gelijkheidsoperatoren voor controles bieden, biedt compare bij StringView een driewaardige vergelijkingswaarde [SWS_CORE_02142].

Gebruik

De memberfunctie compare van de klasse ara::core::StringView voert een synchrone lexicografische vergelijking uit van een deelbereik van de actuele tekenreeksweergave met een meegegeven StringView s [SWS_CORE_02143]. De te vergelijken substring begint bij index pos1 en beslaat een lengte van maximaal n1 tekens. De retourwaarde is een geheelgetallige int, die het relationele resultaat aangeeft. Aangezien de functie gedeclareerd is als constexpr, kan de evaluatie reeds tijdens compile-time plaatsvinden [SWS_CORE_02143].

Foutafhandeling

De semantiek richt zich naar de voorschriften van [string.view] uit de ISO-C++-standaard, maar definieert twee wezenlijke afwijkingen [SWS_CORE_02143]:

• De functie is gespecificeerd met noexcept en geldt als uitzonderingsveilig (exception safe) [SWS_CORE_02143].
• Overschrijdt de startindex de lengte van de view (pos1 > size()), dan wordt er geen standaarduitzondering van het type std::out_of_range gegenereerd, maar een IsoStdOutOfRangeViolation veroorzaakt [SWS_CORE_02143].

Gelijktijdigheid en randvoorwaarden

Aanroepers moeten vooraf controleren of pos1 de waarde van size() niet overschrijdt, om een IsoStdOutOfRangeViolation te voorkomen [SWS_CORE_02143]. Aangezien compare gedeclareerd is als const en geen wijzigingen aan de instantie aanbrengt, is gelijktijdige leestoegang vanuit meerdere threads vermoedelijk niet-kritiek (interpretatie). Vraag Q-be4ec80ab2529ed3 (open)

De memberfunctie compare van de klasse ara::core::StringView ([SWS_CORE_02144], headerbestand #include "ara/core/string_view.h") dient voor de synchrone, lexicografische vergelijking van twee deelreeksen. Het basisgedrag komt overeen met de werking in [string.view] van de ISO-C++-standaard, maar vertoont specifieke afwijkingen voor AUTOSAR Adaptive [SWS_CORE_02144].

De overdrachtsparameters bepalen de te vergelijken delen van beide sequenties [SWS_CORE_02144]:

• pos1 en n1: Startindex en maximaal aantal tekens binnen de aanroepende instantie.
• s: Het te vergelijken object van het type StringView.
• pos2 en n2: Startindex en maximaal aantal tekens binnen het meegegeven object s.

Als retourwaarde levert de functie een geheelgetallige waarde (int), die negatief is als de eigen deelsequentie lexicografisch kleiner is, nul bij overeenstemming en positief als deze groter is [SWS_CORE_02144].

Wat betreft foutafhandeling wijkt de implementatie af van de standaard: de methode is gedeclareerd als noexcept en geldt als uitzonderingsveilig (exception safe) [SWS_CORE_02144]. Indien een van de startposities buiten het geldige bereik ligt (pos1 > size() || pos2 > s.size()), wordt geen std::out_of_range-exception geworpen, maar een IsoStdOutOfRangeViolation geactiveerd [SWS_CORE_02144].

Door de qualifiers constexpr en const kan de functie reeds tijdens compile-time worden geëvalueerd [SWS_CORE_02144]. Omdat er geen interne toestanden worden gewijzigd, zijn gelijktijdige leestoegangen tot dezelfde instantie vermoedelijk thread-safe. Vraag Q-a93f872ee88becc9 (open)

De lidfunctie compare van de klasse ara::core::StringView (headerbestand #include "ara/core/string_view.h") dient voor de synchrone, lexicografische vergelijking van de huidige tekenreeksweergave met een nul-getermineerde C-string const char* s [SWS_CORE_02145]. Aangezien de operatie is gespecificeerd als constexpr, kan de evaluatie zowel tijdens runtime als in het kader van compile-time-expressies plaatsvinden. Als retourwaarde levert de functie een geheel getal van het type int op, waarvan het voorteken het vergelijkingsresultaat analoog aan [string.view] weerspiegelt: een waarde kleiner dan nul betekent dat de instantie lexicografisch vóór s staat; de waarde nul betekent gelijkheid; een waarde groter dan nul geeft aan dat de instantie na s volgt [SWS_CORE_02145].

Met betrekking tot de foutafhandeling wijkt de AUTOSAR-specificatie expliciet af van de template in [string.view]: De methode is gedeclareerd als noexcept en bezit de eigenschap exception safe [SWS_CORE_02145]. Aanroepen kunnen zodoende gegarandeerd geen C++-excepties veroorzaken. Specifieke foutcodes, terugmeldingen aan de Development Error Tracer (DET) of de Diagnostic Event Manager (DEM) zijn voor deze basisfunctie niet voorzien.

Als const-gekwalificeerde methode wijzigt compare de toestand van de ara::core::StringView-instantie niet en kan deze gelijktijdig lezend veilig worden aangeroepen. Bij het gebruik moet er rekening mee worden gehouden dat de pointer s vermoedelijk naar een geldige tekenreeks moet verwijzen, aangezien de uit [string.view] overgenomen semantiek bij het meegeven van een null-pointer ongedefinieerd gedrag teweeg zou brengen [SWS_CORE_02145]. Vraag Q-cff1a1f55603dbd4 (open)

Gebruik

De methode compare van de klasse ara::core::StringView maakt een synchrone lexicografische vergelijking mogelijk van een deelbereik van de tekenreeksweergave met een nul-getermineerde C-tekenreeks s [SWS_CORE_02146]. Meegegeven worden de startindex pos1, de maximale lengte n1 en de pointer s naar de te vergelijken tekenreeks. De retourwaarde van het type int weerspiegelt het relationele ordeningsresultaat analoog aan de standaardbibliotheek: een retourwaarde kleiner dan nul, gelijk aan nul of groter dan nul kenmerkt de lexicografische relatie [SWS_CORE_02146].

Foutafhandeling en randvoorwaarden

De bewerking is gespecificeerd als noexcept en \"exception safe\" [SWS_CORE_02146]. In tegenstelling tot het gedrag volgens de C++-standaard [string.view] genereert een ongeldige startindex met pos1 > size() geen std::out_of_range-exception, maar leidt deze tot een IsoStdOutOfRangeViolation [SWS_CORE_02146]. Deze violation wordt in de AUTOSAR-runtimecontext vermoedelijk aangemerkt als programmeerfout en forceert een directe platformafbreking, aangezien reguliere C++-exceptions niet over noexcept-grenzen heen kunnen ontsnappen. Vraag Q-d4ce6b496b80fdde (open) Er moet bovendien voor worden gezorgd dat s verwijst naar een geldige tekenreeks, aangezien een null-pointer vermoedelijk ongedefinieerd gedrag veroorzaakt.

Concurrency

Aangezien compare gedefinieerd is als const en constexpr, blijft de toestand van de instantie ongewijzigd [SWS_CORE_02146]. Gelijktijdige leestoegangen tot hetzelfde ara::core::StringView-object zijn zodoende veilig uitvoerbaar.

Gebruik

De memberfunctie compare van de klasse ara::core::StringView uit de header ara/core/string_view.h voert een synchrone lexicografische vergelijking uit [SWS_CORE_02147]. Daarbij wordt een deelsequentie van de huidige instantie, beginnend vanaf de index pos1 met maximaal n1 tekens, vergeleken met de eerste n2 tekens van de externe C-teken-array s. De geheelgetallige retourwaarde (int) volgt de semantiek van [string.view] en signaleert via het voorteken of het eigen deelbereik lexicografisch kleiner, gelijk of groter is dan de referentiesequentie. Als constexpr- en const-methode wijzigt zij het object niet en kan zij reeds tijdens compile-time worden geëvalueerd [SWS_CORE_02147].

Foutafhandeling en randvoorwaarden

Wat betreft foutafhandeling en uitzonderingsveiligheid definieert AUTOSAR twee bindende afwijkingen van de standaard [SWS_CORE_02147]:

• De memberfunctie is gespecificeerd als noexcept en volledig ingeschaald als exception safe [SWS_CORE_02147].
• Overschrijdt de startpositie de lengte van de instantie (pos1 > size()), dan wordt geen std::out_of_range-uitzondering geworpen, maar een IsoStdOutOfRangeViolation geactiveerd [SWS_CORE_02147].

Interpretatie: Door de combinatie van noexcept-garantie en IsoStdOutOfRangeViolation is een overschrijding van het bereik vermoedelijk niet af te vangen met behulp van klassieke C++-try-catch-blokken, maar leidt deze vermoedelijk tot een onmiddellijke afbreking dan wel foutafhandeling door het platform. Vraag Q-67fb8eda4c594a06 (open)

Gebruik en aanroepcontext

De memberfunctie contains van de klasse ara::core::StringView dient voor de synchrone controle of een tekenweergave een vooraf bepaalde deelreeks bevat [SWS_CORE_02154]. De functie wordt gedefinieerd in de header ara/core/string_view.h conform de semantiek van het C++-standaardontwerp N4950 ([string.view]) [SWS_CORE_02154]. Als parameter neemt de methode een andere instantie van StringView (sv) per waarde aan en levert direct een waarheidswaarde van het type bool terug: true wanneer de deelsequentie voorkomt, anders false [SWS_CORE_02154].

Door de specificatie als constexpr kan de aanroep zowel tijdens runtime als reeds tijdens compilatie in het kader van compile-time-contexten plaatsvinden [SWS_CORE_02154].

Foutafhandeling en uitzonderingsveiligheid

Voor contains is het gedrag vastgelegd als exception safe en is de signatuur expliciet aangeduid met noexcept [SWS_CORE_02154]. De functie werpt bijgevolg onder geen beding C++-exceptions en retourneert geen fouten via ara::core::Result of ara::core::ErrorCode. Er bestaan noch DET- noch DEM-foutmeldingen voor deze basisfunctie.

Gelijktijdigheid en beperkingen

Als constante memberfunctie (const) wijzigt contains de toestand van de StringView-instantie niet [SWS_CORE_02154]. Interpretatie: Parallelle, zuiver lezende aanroepen op dezelfde StringView-instantie of op de onderliggende tekenbuffer zijn vermoedelijk onbeperkt re-entrant en gelijktijdig veilig, zolang het gereferentieerde geheugengebied door geen enkele thread gelijktijdig wordt gewijzigd. Vraag Q-80f1a9989a098913 (open) Er bestaan geen bijzondere volgordevoorwaarden of initialisatieplichten buiten het aanbieden van een geldige StringView.

De lidfunctie contains controleert synchroon of een bepaald teken c binnen een ara::core::StringView aanwezig is [SWS_CORE_02155]. De functie is gedeclareerd in de header ara/core/string_view.h en volgt de semantiek van [string.view] uit de C++-conceptstandaard N4950 [SWS_CORE_02155]. Deze accepteert een enkel teken van het type char en levert een waarheidswaarde van het type bool terug, die vermoedelijk dan en slechts dan true oplevert wanneer het teken in het gereferentieerde tekstgebied wordt gevonden [SWS_CORE_02155]. Vraag Q-3293fccace7af3ab (open)

Wat betreft de foutafhandeling is de operatie gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_02155]. Er worden geen excepties opgeworpen en geen foutcodes via DET, DEM of retourtypen gesignaleerd; het niet-bestaan van het teken wordt regulier via de booleaanse retourwaarde gemeld.

Aangezien de functie als constexpr evenals const is aangemerkt, kan deze reeds tijdens compile-time worden geëvalueerd [SWS_CORE_02155]. Aanroepen wijzigen het onderliggende ara::core::StringView-object niet, waardoor parallelle leestoegangen op dezelfde instantie vermoedelijk veilig gelijktijdig kunnen plaatsvinden. Vraag Q-298dbc4d080853bc (open)

In het samenspel van de basistypen van het cluster core dient contains voor directe tekstinspectie op tekenreeksweergaven [SWS_CORE_02155]. Terwijl typen zoals ara::core::Result eigen controlemechanismen voor aanwezige waarden of fouten bieden – zoals HasValue [SWS_CORE_00751] of CheckError [SWS_CORE_00765] –, werkt contains lichtgewicht zonder allocatie of foutinkapseling.

De memberfunctie contains van de klasse ara::core::StringView controleert synchroon of de gereferentieerde tekenreeks de als parameter meegegeven tekensequentie str bevat [SWS_CORE_02156]. De functie wordt beschikbaar gesteld via het headerbestand ara/core/string_view.h en levert het controleresultaat terug als retourwaarde van het type bool [SWS_CORE_02156]. Door de declaratie als constexpr kan de aanroep zowel tijdens runtime als in het kader van expressies tijdens compile-time worden uitgevoerd [SWS_CORE_02156].

De functionele semantiek volgt de vastlegging van [string.view] in de Working Draft van de C++-standaard N4950, maar vertoont een bindende afwijking: de functie is in AUTOSAR Adaptive gedeclareerd met de identifier noexcept [SWS_CORE_02156]. Overeenkomstig is de bewerking gespecificeerd als uitzonderingsveilig (exception safe), zodat gegarandeerd is dat er tijdens de uitvoering geen C++-uitzonderingen worden geactiveerd [SWS_CORE_02156]. Specifieke AUTOSAR-foutcodes of meldingen aan ontwikkelings- of diagnose-foutregistraties zijn voor deze functie niet gedefinieerd [SWS_CORE_02156].

Als constante memberfunctie (const) wijzigt contains de aanroepende instantie niet [SWS_CORE_02156]. Interpretatie: Voor de parameter str wordt vermoedelijk de doorgifte van een geldige, nul-getermineerde tekenreeks verondersteld, aangezien de interface const char *str gebruikt en geen aparte lengte- of foutcontrole voorziet [SWS_CORE_02156]. Vraag Q-a2d7cd456a72a792 (open)

Gebruik

De synchrone elementfunctie copy van de klasse ara::core::StringView ([SWS_CORE_02140]) kopieert een deelreeks naar een bereitgestelde buffer. De toegang verloopt via het headerbestand #include "ara/core/string_view.h":

• Parameters: char *s verwijst naar de doel-array, n bepaalt het maximaal te kopiëren aantal tekens en pos definieert de startpositie (standaardwaarde 0).
• Retourwaarde: een waarde van het type size_type, die het aantal daadwerkelijk gekopieerde tekens aangeeft.
• Semantiek: de functie werkt synchroon en oriënteert zich op de ISO-C++-specificatie [string.view] ([SWS_CORE_02140]).

Foutafhandeling

In foutsituaties, wanneer pos > size() geldt, wordt een IsoStdOutOfRangeViolation geactiveerd ([SWS_CORE_02140]). Dit wijkt af van de standaard [string.view], die std::out_of_range werpt. Aangezien de interface is gedeclareerd als noexcept, leidt het activeren van de violation vermoedelijk tot directe beëindiging van het proces (interpretatie: er wordt geen C++-exception doorgestuurd). Vraag Q-4ddbe4dfb002c41f (open)

Gelijktijdigheid en beperkingen

De operatie is gespecificeerd als const en noexcept en geldt als exception safe ([SWS_CORE_02140]). De aanroeper moet waarborgen dat de doel-array s voldoende geheugen biedt voor ten minste min(n, size() - pos) tekens, aangezien bereikfouten van de doelbuffer niet worden opgevangen.

Samenspel

In vergelijking met ara::core::BasicString::copy ([SWS_CORE_03410]), die met value_type werkt en geclassificeerd is als not exception safe, biedt de variant in StringView een exception-safe noexcept-garantie ([SWS_CORE_02140]).

De memberfunctie crbegin van de klasse ara::core::StringView levert synchroon een constante reverse-iterator (const_reverse_iterator) op naar het eerste teken van de omgekeerde tekenweergave [SWS_CORE_02126]. De functie accepteert geen parameters, wordt gedeclareerd via het headerbestand ara/core/string_view.h en volgt de standaardsemantiek van [string.view] [SWS_CORE_02126].

Wat betreft de foutafhandeling is de operatie gedefinieerd als noexcept en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_02126]. Er worden noch foutcodes geretourneerd, noch foutmeldingen via DET of DEM verzonden, aangezien de aanroep gegarandeerd foutloos verloopt [SWS_CORE_02126].

Dankzij de specificatie als constexpr en const kan de functie ook worden aangeroepen in het kader van constante expressies tijdens compilatietijd [SWS_CORE_02126]. Interpretatie: Parallelle aanroepen van crbegin op dezelfde instantie zijn vermoedelijk gelijktijdig thread-safe, aangezien de operatie geen enkele modificatie aan het object uitvoert. Vraag Q-ce8bc6d0753d1aa8 (open)

De interface past naadloos binnen het containeroverstijgende iteratorconcept van AUTOSAR Adaptive Core. Equivalente constexpr-implementaties van crbegin zijn te vinden in ara::core::Array [SWS_CORE_01260] en ara::core::Span [SWS_CORE_01978]. Daarnaast stellen ook containers zoals ara::core::Vector [SWS_CORE_01342], ara::core::Map [SWS_CORE_01450] en ara::core::BasicString [SWS_CORE_03049] overeenkomstige niet-constexpr const_reverse_iterator-toegangspunten ter beschikking.

De memberfunctie crend van de klasse ara::core::StringView levert een constante achterwaartse iterator op ([SWS_CORE_02127]). De aanroep vindt synchroon en parameterloos plaats op een bestaande instantie uit de header ara/core/string_view.h. De geretourneerde const_reverse_iterator markeert het logische einde van een omgekeerde iteratie; volgens de C++-referentie [string.view] verwijst deze als sentinel-positie naar het theoretische element direct vóór het eerste teken van de string (interpretatie: analoog aan de C++-standaard). Vraag Q-5fd666f8d3eaf308 (open)

Foutafhandeling en gelijktijdigheid

De functie is gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (“exception safe”) ([SWS_CORE_02127]). Er worden noch excepties getriggerd, noch foutcodes geretourneerd of DET-/DEM-meldingen verzonden. Dankzij de constexpr-kwalificatie kan de iterator reeds tijdens compile-time worden aangemaakt. Als zuivere const-methode zonder toestandseffecten zijn gelijktijdige leesaanroepen op dezelfde instantie vermoedelijk gelijktijdig veilig (interpretatie). Vraag Q-207e2b9561f61d27 (open)

Samenspel

De interface volgt het uniforme iteratieconcept van ara::core voor sequentiële datastructuren. Verwante specificaties definiëren analoge crend-interfaces:

• ara::core::Array ([SWS_CORE_01261]) en ara::core::Span ([SWS_CORE_01979]), eveneens gespecificeerd als constexpr,
• ara::core::Vector ([SWS_CORE_01343]), ara::core::Map ([SWS_CORE_01451]) en ara::core::BasicString ([SWS_CORE_03050]).

Gebruik

De lidfunctie ara::core::StringView::ends_with controleert synchroon of de beschouwde tekensequentie eindigt op de doorgegeven deelsequentie sv [SWS_CORE_02151]. Deze is gedeclareerd in het headerbestand ara/core/string_view.h en volgt de gestandaardiseerde C++-semantiek volgens [string.view] uit ISO/IEC 14882:2020 [SWS_CORE_02151]. Dankzij de aanduiding als constexpr kan de vergelijking reeds tijdens compile-time worden geëvalueerd. Aangezien het om een const-methode gaat, wordt het aanroepende object niet gewijzigd.

Foutafhandeling en gelijktijdigheid

De specificatie kent aan ends_with de eigenschap exception safe toe en declareert deze als noexcept [SWS_CORE_02151]. De functie werpt dus geen uitzonderingen en meldt mislukkingen noch via AUTOSAR-foutkanalen zoals DET of DEM, noch via specifieke foutcodes. Als zuivere leesbewerking op een onveranderlijke tekenreeksweergave is de functie vermoedelijk re-entrant en veilig bij gelijktijdige leestoegangen op dezelfde instantie zonder synchronisatiemechanismen. Vraag Q-821d4d0f216694ef (open)

Samenspel

De methode maakt deel uit van de klasse ara::core::StringView en wordt aangevuld door verwante overloadings: naast de evaluatie ten opzichte van een ander StringView-object zijn varianten voor controle ten opzichte van een afzonderlijk teken char [SWS_CORE_02152] alsook ten opzichte van een nul-getermineerde C-string const char* [SWS_CORE_02153] beschikbaar, die eveneens uitzonderingsveilig en tijdens compile-time bruikbaar zijn.

Gebruik

De lidfunctie ends_with van de klasse ara::core::StringView controleert synchroon of de gereferentieerde tekenreeks eindigt op het opgegeven teken c ([SWS_CORE_02152]). Zij wordt gedeclareerd via de header ara/core/string_view.h en volgt de gestandaardiseerde werking uit [string.view] conform ISO/IEC 14882:2020 ([SWS_CORE_02152]). Door de aanduiding als constexpr kan de evaluatie zowel tijdens runtime als vooraf in het kader van de compilatie worden uitgevoerd ([SWS_CORE_02152]).

Foutafhandeling en runtimegedrag

De interface garandeert volledige uitzonderingsveiligheid („exception safe”) en is voorzien van de specificeerder noexcept ([SWS_CORE_02152]). Zij genereert bijgevolg nooit uitzonderingen en gebruikt geen foutmeldingen via DET of DEM. Bij een lege tekenreeks levert de controle altijd het booleaanse resultaat false op.

Gelijktijdigheid en wisselwerking

Aangezien ends_with als zuivere const-operatie zonder toestandseffecten is gedefinieerd, is gelijktijdige leestoegang vanuit meerdere threads tot dezelfde instantie vermoedelijk veilig (interpretatie). Vraag Q-b3a5dccbd8ff638a (open) Naast het losse teken biedt ara::core::StringView voor eindcontroles twee aanvullende overbelastingen: de vergelijking met een andere StringView ([SWS_CORE_02151]) en de controle tegen een nul-getermineerde C-string van het type const char* ([SWS_CORE_02153]). Beide varianten zijn eveneens synchroon, constexpr en noexcept uitgevoerd ([SWS_CORE_02151], [SWS_CORE_02153]).

De memberfunctie ends_with van de klasse ara::core::StringView controleert synchroon of de beschouwde tekenreeks eindigt op een bepaalde tekenreeks [SWS_CORE_02153]. De functie accepteert een pointer const char* str als parameter en levert een retourwaarde van het type bool [SWS_CORE_02153]. Door de declaratie als constexpr kan de evaluatie zowel tijdens runtime als al tijdens compile-time plaatsvinden [SWS_CORE_02153]. De functionele semantiek volgt de definitie van paragraaf [string.view] uit de norm ISO/IEC 14882:2020 [SWS_CORE_02153].

Wat betreft de foutafhandeling is de functie gedeclareerd als noexcept en geclassificeerd als uitzonderingsveilig (exception safe), waardoor er geen C++-exceptions worden gegenereerd [SWS_CORE_02153]. Specifieke AUTOSAR-foutcodes of foutmeldingen aan DET of DEM zijn voor deze hulpfunctie niet voorzien.

Interpretatie: Bij de aanroep zal de parameter str vermoedelijk moeten verwijzen naar een geldige, nulgetermineerde tekenreeks, aangezien er geen aanvullende lengteparameter wordt meegegeven [SWS_CORE_02153]. Vraag Q-d6d076a1a2ab7dce (open) Aangezien de methode gekwalificeerd is als const en geen interne toestand wijzigt, is gelijktijdige leestoegang tot dezelfde instantie veilig.

De functie is via het headerbestand #include "ara/core/string_view.h" beschikbaar binnen de scope van ara::core::StringView [SWS_CORE_02153]. Zij vormt een aanvulling op verwante overloads van ends_with, die in plaats van een C-string een StringView-object [SWS_CORE_02151] of een enkel teken char [SWS_CORE_02152] aannemen.

De elementfunctie find van de klasse ara::core::StringView zoekt synchroon naar het eerste voorkomen van de doorgegeven deelstring s vanaf de startpositie pos volgens het gedrag in [string.view] [SWS_CORE_02157]. De functie is gedefinieerd als constexpr en const, waardoor deze ook tijdens compile-time en op onveranderlijke instanties kan worden aangeroepen [SWS_CORE_02157].

Wat de foutafhandeling betreft, is de methode gedeclareerd als noexcept en geclassificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_02157]; specifieke foutcodes en DET- of DEM-meldingen zijn niet voorzien. Omdat de uitvoering de toestand van het object niet verandert, is gelijktijdige leestoegang van meerdere executiedraden op dezelfde StringView-instantie vermoedelijk toegestaan zonder aanvullende synchronisatie. Vraag Q-e27507133b5a4e20 (open)

Binnen ara::core::StringView wordt deze functie aangevuld met verdere zoekoverbelastingen voor afzonderlijke tekens van het type char [SWS_CORE_02158] en C-strings [SWS_CORE_02159], [SWS_CORE_02160]. In samenspel met andere containers biedt ara::core::BasicString een vergelijkbare zoekfunctie voor StringView [SWS_CORE_03315], terwijl de functie find in ara::core::Map dient voor het zoeken naar sleutels en iterators retourneert [SWS_CORE_01490].

Gebruik en parameters

De synchrone elementfunctie find van de klasse ara::core::StringView zoekt vanaf de indexpositie pos naar het eerste voorkomen van het teken c ([SWS_CORE_02158]). Ze wordt opgenomen via het headerbestand #include "ara/core/string_view.h" en levert als retourwaarde de index van de vindplaats van het type size_type op. Als het teken niet wordt gevonden, wordt conform de verwijzing naar [string.view] vermoedelijk de waarde npos geretourneerd. Vraag Q-60ea50d6f006004f (open)

Foutafhandeling en gelijktijdigheid

De functie is gedeclareerd met noexcept en gespecificeerd als uitzonderingsveilig (exception safe) ([SWS_CORE_02158]). Door de aanduiding als constexpr en const is ze geschikt voor constante expressies tijdens compileertijd en modificeert ze het onderliggende object niet. Gelijktijdige leestoegangen op dezelfde instantie zijn vermoedelijk re-entrant en thread-safe, zolang de gereferentieerde tekenreeks in het geheugen ongewijzigd blijft. Vraag (open)

Interactie en alternatieven

De methode vult andere overladen versies van find in ara::core::StringView aan, die zoeken naar deelreeksen ([SWS_CORE_02157]) of pointersequenties ([SWS_CORE_02159], [SWS_CORE_02160]). In tegenstelling tot het op tekens gebaseerde zoeken in ara::core::BasicString ([SWS_CORE_03324]), dat als not exception safe is geclassificeerd, garandeert deze variant volledige uitzonderingsvrijheid. Ze onderscheidt zich bovendien van het op sleutels gebaseerde zoeken in ara::core::Map ([SWS_CORE_01490]).

Gebruik

De elementfunctie find van de klasse ara::core::StringView ([SWS_CORE_02159]) dient voor het synchroon zoeken naar een tekenreeks binnen de string-view. Deze wordt beschikbaar gesteld via het headerbestand ara/core/string_view.h. De functie accepteert een pointer s naar een tekenarray, een startpositie pos van het type size_type evenals het aantal te zoeken tekens n en levert de gevonden positie als size_type op. Interpretatie: conform de gerefereerde semantiek uit [string.view] verwijst s vermoedelijk naar een veld met minimaal n tekens en wordt bij een niet-succesvolle zoekopdracht de waarde npos geretourneerd. Vraag Q-e7f54bb1b42a99d8 (open)

Foutafhandeling en gelijktijdigheid

De methode is gedeclareerd als noexcept en gespecificeerd als exception safe ([SWS_CORE_02159]). Fouttoestanden worden zodoende niet via C++-exceptions gesignaleerd. Aangezien de functie is gedefinieerd als const en constexpr, modificeert deze de instantie niet en is deze geschikt voor evaluaties tijdens compilatietijd evenals voor gelijktijdige leestoegangen.

Samenspel

Binnen ara::core::StringView vormt de functie een aanvulling op andere zoek-overloads:

• Zoeken naar een StringView ([SWS_CORE_02157]) of een afzonderlijk teken ([SWS_CORE_02158]),
• Zoeken aan de hand van een nul-getermineerde C-string ([SWS_CORE_02160]), waarbij geen expliciete lengte n wordt opgegeven.

In vergelijking met de corresponderende signatuur in ara::core::BasicString ([SWS_CORE_03409]), die gedeclareerd is als not exception safe en geen noexcept garandeert, biedt de variant in StringView ([SWS_CORE_02159]) strikte exceptieveiligheid zonder allocatie-overhead.

Gebruik

De synchrone elementfunctie find van de klasse ara::core::StringView ([SWS_CORE_02160]) uit de header #include "ara/core/string_view.h" zoekt naar het eerste voorkomen van de opgegeven C-string s vanaf de startpositie pos. Het functionele gedrag richt zich naar de C++-standaard [string.view], maar wijkt af door de expliciete aanduiding als noexcept ([SWS_CORE_02160]).

Foutafhandeling

De functie is gedefinieerd als exception safe en garandeert het wegblijven van welke excepties dan ook ([SWS_CORE_02160]). Specifieke foutcodes evenals meldingen aan DET of DEM bestaan niet. Interpretatie: als de gezochte tekenreeks niet aanwezig is, wordt het mislukken van de zoekopdracht analoog aan het standaardgedrag van [string.view] vermoedelijk aangegeven door de retourwaarde npos. Vraag Q-febde79f1c992c2a (open)

Gelijktijdigheid en randvoorwaarden

Aangezien find gedeclareerd is als constexpr en const ([SWS_CORE_02160]), modificeert de aanroep de toestand van het StringView-object niet en kan deze reeds tijdens compile-time worden geëvalueerd. Interpretatie: gelijktijdige leestoegangen via meerdere threads zijn vermoedelijk zonder aanvullende synchronisatiemaatregelen re-entrant en concurrency-safe. Vraag (open)

Samenspel

Binnen ara::core::StringView bestaan er verdere overloads van find voor StringView-parameters ([SWS_CORE_02157]), afzonderlijke tekens ([SWS_CORE_02158]) en deelreeksen met expliciete lengtebeperking n ([SWS_CORE_02159]). In tegenstelling tot analoge C-string-zoekoperaties in ara::core::BasicString ([SWS_CORE_03408], [SWS_CORE_03409]), die geclassificeerd zijn als not exception safe, waarborgt de implementatie in ara::core::StringView volledige exceptieveiligheid ([SWS_CORE_02160]).

Gebruik

De elementfunctie find_first_not_of van de klasse ara::core::StringView ([SWS_CORE_02173]) dient voor het synchroon zoeken naar het eerste teken binnen de tekenreeksweergave dat niet in de meegegeven StringView s is opgenomen. Als tweede parameter kan optioneel de startpositie pos worden opgegeven (standaardwaarde pos=0). De functie geeft de gevonden indexpositie terug als size_type. Het gedrag richt zich daarbij naar de overeenkomstige semantiek in [string.view]. Interpretatie: wordt er geen afwijkend teken gevonden, dan geeft de functie overeenkomstig deze standaardsemantiek vermoedelijk de waarde npos terug. Vraag Q-8f55419868615e5a (open)

Foutafhandeling en gelijktijdigheid

De functie is gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (“exception safe”) ([SWS_CORE_02173]). Er worden geen exceptions geactiveerd en er zijn geen specifieke foutmeldingen via DET of DEM gedefinieerd. Door de kwalificeerders const en constexpr kan de aanroep zonder neveneffecten tijdens compileertijd of parallel op ongewijzigde objecten plaatsvinden.

Interactie en overbelastingen

Binnen ara::core::StringView wordt de functie aangevuld met verdere noexcept-overbelastingen:

• Zoeken naar tekens ongelijk aan een afzonderlijk teken char c ([SWS_CORE_02174]).
• Zoeken aan de hand van een C-string const char *s met lengtebeperking n ([SWS_CORE_02175]) of vanaf startpositie ([SWS_CORE_02176]).

Een vergelijkbaar zoekpatroon bestaat voor ara::core::BasicString, onder meer met StringView ([SWS_CORE_03319]) en BasicString ([SWS_CORE_03337]). In tegenstelling tot StringView zijn de aldaar aanwezige overbelastingen voor pointers en tekens ([SWS_CORE_03338], [SWS_CORE_03339], [SWS_CORE_03340]) geclassificeerd als niet-uitzonderingsveilig.

De elementfunctie find_first_not_of van de klasse ara::core::StringView bepaalt synchroon de positie van het eerste teken binnen de tekenreeks dat ongelijk is aan het meegegeven teken c [SWS_CORE_02174]. De zoekopdracht begint standaard aan het begin van de view of vanaf de optionele offset pos. Door de verwijzing naar de standaard [string.view] levert de functie vermoedelijk de zero-based index van het type size_type van het gevonden teken op, of de waarde npos indien er geen afwijkend teken bestaat. Vraag Q-9f3eeedf35e475e7 (open)

Wat betreft de foutafhandeling is de functie gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_02174]. Zij gooit zodoende geen exceptions, gebruikt geen DET- of DEM-meldingen en meldt het niet-vinden van een teken louter via haar retourwaarde.

Als constexpr- en const-methode kan find_first_not_of reeds tijdens compile-time worden geëvalueerd en garandeert zij een toestandloze, neveneffectvrije leestoegang tot de onderliggende tekenreeks. Gelijktijdige aanroepen op dezelfde StringView-instantie zijn daarom re-entrant en veilig zonder aanvullende synchronisatie.

De functie maakt deel uit van een familie van zoekoperaties in ara::core::StringView en vormt een aanvulling op de overloads voor het zoeken naar afwijkende deelreeksen via StringView [SWS_CORE_02173] evenals pointer-lengteparen respectievelijk nulgetermineerde C-strings [SWS_CORE_02175] [SWS_CORE_02176]. Een functioneel equivalent voor muteerbare tekenreeksen bestaat in ara::core::BasicString [SWS_CORE_03340], dat in tegenstelling tot StringView als niet-uitzonderingsveilig is gedeclareerd.

De elementfunctie find_first_not_of van de klasse ara::core::StringView dient conform [SWS_CORE_02175] voor het synchroon vinden van het eerste teken binnen de tekenreeks dat niet voorkomt in een vooraf opgegeven tekenreeks. Het gedrag komt daarbij in principe overeen met het gebruik in [string.view], met de gedocumenteerde afwijking dat de functie is gedeclareerd als noexcept [SWS_CORE_02175]. Interpretatie: Via de verwijzing naar [string.view] begrenzen de parameters s, pos en n vermoedelijk de zoekopdracht vanaf de positie pos tot de eerste n tekens van de array s [SWS_CORE_02175]. Vraag Q-745f5bc9246c11a2 (open)

Gebruik en foutafhandeling

De functie is gedefinieerd als constexpr en const, wordt beschikbaar gesteld via het headerbestand #include "ara/core/string_view.h" en retourneert een index van het type size_type [SWS_CORE_02175]. De specificatie classificeert de methode als exception safe [SWS_CORE_02175]. Aangezien zij gespecificeerd is als noexcept, genereert zij geen uitzonderingen; foutcodes of meldingen aan DET of DEM zijn niet gedefinieerd [SWS_CORE_02175].

Interactie en alternatieven

In ara::core::StringView zijn voor afwijkende zoekpatronen verwante overloads beschikbaar:

• Zoeken via een andere tekenreeksweergave StringView conform [SWS_CORE_02173],
• Zoeken naar de eerste afwijking van een afzonderlijk teken c conform [SWS_CORE_02174] en
• Zoeken aan de hand van een nulgetermineerde pointer const char *s zonder expliciete lengteopgave conform [SWS_CORE_02176].

In tegenstelling tot de qua structuur vergelijkbare signatuur in ara::core::BasicString [SWS_CORE_03338], die geclassificeerd is als not exception safe en niet over noexcept beschikt, biedt de variant in StringView volledige uitzonderingsveiligheid [SWS_CORE_02175].

De elementfunctie find_first_not_of van de klasse ara::core::StringView ([SWS_CORE_02176]) uit de header ara/core/string_view.h zoekt vanaf de startpositie pos synchroon naar het eerste teken dat niet voorkomt in de tekenreeks s. Het gedrag komt overeen met de definitie in [string.view], maar wijkt af door de expliciete aanduiding als noexcept ([SWS_CORE_02176]). Interpretatie: Uit de referentie naar de norm [string.view] volgt vermoedelijk dat s moet verwijzen naar een geldige, nulgetermineerde tekenarray en dat in geval van een mislukking npos wordt geretourneerd. Vraag Q-aa48a331975274a1 (open)

Met betrekking tot de foutafhandeling is de functie gespecificeerd als uitzonderingsveilig (exception safe) ([SWS_CORE_02176]). Er worden geen exceptions gegenereerd; runtime-foutmeldingen via AUTOSAR-mechanismen zoals DET of DEM zijn voor deze functie in de payload niet gedefinieerd.

Vanwege de kwalificatie als constexpr en const ([SWS_CORE_02176]) wijzigt de zoekoperatie de toestand van het StringView-object niet. Zij is re-entrant en kan worden uitgevoerd in willekeurige threads alsook reeds tijdens compile-time in constante expressies.

In samenspel met verwante interfaces vult de functie verdere overloads binnen ara::core::StringView aan, met name voor het zoeken met een StringView ([SWS_CORE_02173]), een enkel teken char ([SWS_CORE_02174]) of een buffer met lengtebeperking n ([SWS_CORE_02175]). In tegenstelling tot de pointergebaseerde overloads in ara::core::BasicString ([SWS_CORE_03338], [SWS_CORE_03339]), die zijn ingeschaald als not exception safe, waarborgt deze variant op StringView volledige uitzonderingsveiligheid.

De elementfunctie find_first_of van de klasse ara::core::StringView ([SWS_CORE_02165]) doorzoekt een tekensequentie synchroon vanaf de index pos naar het eerste voorkomen van een willekeurig teken uit de doorgegeven tekenweergave s. De methode retourneert de gevonden positie als index van het type size_type.

Volgens de specificatie is de functie gedeclareerd als noexcept en ingedeeld als uitzonderingsveilig (exception safe) ([SWS_CORE_02165]). Ze werpt geen uitzonderingen op en meldt geen fouten aan DET of DEM. Interpretatie: als er geen passend teken wordt gevonden of de startindex buiten het geldige bereik ligt, komt het resultaat analoog aan de standaardsemantiek van [string.view] vermoedelijk overeen met de waarde npos. Vraag Q-ad877979579b5bd1 (open)

Aangezien find_first_of gespecificeerd is als const, voert de aanroep geen toestandswijzigingen uit ([SWS_CORE_02165]). Gelijktijdige leestoegangen op dezelfde instantie zijn mogelijk zonder aanvullende synchronisatie. Dankzij de aanduiding als constexpr kan de zoekactie bovendien tijdens compileertijd worden geëvalueerd.

In module core bestaan voor ara::core::StringView aanvullende overladen versies, waaronder voor individuele tekens ([SWS_CORE_02166]), pointers met een expliciet aantal tekens ([SWS_CORE_02167]) en nul-getermineerde tekenreeksen ([SWS_CORE_02168]). In de klasse ara::core::BasicString staat met [SWS_CORE_03317] een vergelijkbare overladen versie voor StringView ter beschikking; in tegenstelling tot StringView zijn de pointer-gebaseerde zoekfuncties aldaar echter gedeclareerd als niet-uitzonderingsveilig ([SWS_CORE_03330]).

Gebruik

De elementfunctie find_first_of van de klasse ara::core::StringView dient voor het synchroon zoeken naar het eerste voorkomen van een teken binnen de gereferentieerde tekenreeks [SWS_CORE_02166]. Zij is beschikbaar via de header ara/core/string_view.h en accepteert het gezochte teken c en optioneel de startpositie pos, die standaard is ingesteld op 0. De functie retourneert de index van de gevonden positie van het type size_type conform het gedrag in [string.view] [SWS_CORE_02166]. Als constexpr-methode kan zij zowel tijdens runtime als tijdens de compilatie worden uitgevoerd.

Foutafhandeling

De functie is gedeclareerd als noexcept en expliciet geclassificeerd als uitzonderingsveilig (“exception safe”) [SWS_CORE_02166]. Er worden geen exceptions gegenereerd en de specificatie definieert geen specifieke foutcodes of meldingen aan de Development Error Tracer (DET) of Diagnostic Event Manager (DEM).

Gelijktijdigheid en beperkingen

Als constante elementfunctie (const) wijzigt de aanroep de instantie van ara::core::StringView niet [SWS_CORE_02166]. Interpretatie: Parallelle leesaanroepen op hetzelfde object vanuit meerdere threads zijn daarom vermoedelijk re-entrant en veilig bij gelijktijdigheid, zolang de onderliggende tekenbuffer ongewijzigd blijft. Vraag Q-b86dddc1a54a05e1 (open)

Samenspel

De functie maakt deel uit van de zoekinterfaces van ara::core::StringView. Naast het zoeken naar afzonderlijke tekens bestaan er analoge, eveneens als noexcept gespecificeerde overloads voor deelreeksen via StringView [SWS_CORE_02165] en pointerrepresentaties [SWS_CORE_02167], [SWS_CORE_02168]. In tegenstelling hiermee declareert de klasse ara::core::BasicString verwante overloads voor afzonderlijke tekens [SWS_CORE_03332] en pointers [SWS_CORE_03330], [SWS_CORE_03331] zonder noexcept en classificeert deze als niet-uitzonderingsveilig (“not exception safe”), terwijl de stringvarianten met BasicString [SWS_CORE_03329] en StringView [SWS_CORE_03317] uitzonderingsveilig blijven.

De elementfunctie find_first_of van de klasse ara::core::StringView ([SWS_CORE_02167]) uit het headerbestand #include "ara/core/string_view.h" zoekt synchroon naar het eerste voorkomen van een teken uit de tekenreeks s vanaf de positie pos. De parameter n begrenst daarbij het aantal in aanmerking te nemen tekens van de meegegeven pointer. De functie retourneert de gevonden positie als size_type; wordt er geen teken gevonden, dan wordt volgens [string.view] vermoedelijk de waarde npos geretourneerd. Vraag Q-eac57a47043e5b33 (open)

Voor de aanroepcontext en de foutafhandeling gelden de volgende voorschriften:

• Uitzonderingsveiligheid en compile-time-evaluatie: De methode is gedefinieerd als constexpr en const. In afwijking van de standaard [string.view] is zij expliciet gedeclareerd met noexcept en gespecificeerd als uitzonderingsveilig (“exception safe”) ([SWS_CORE_02167]). Er worden geen exceptions gegenereerd en geen foutcodes gemeld.
• Verwante overloads in StringView: Aanvullend zijn er varianten beschikbaar voor tekenreekspointers zonder lengtebegrenzing ([SWS_CORE_02168]), voor ara::core::StringView-objecten ([SWS_CORE_02165]) en voor afzonderlijke tekens ([SWS_CORE_02166]), die eveneens noexcept zijn.
• Onderscheid ten opzichte van BasicString: In tegenstelling tot de overeenkomstige overload in ara::core::BasicString ([SWS_CORE_03330]), die als niet-uitzonderingsveilig (“not exception safe”) en zonder noexcept wordt aangeduid, waarborgt de implementatie van StringView volledige uitzonderingsvrijheid ([SWS_CORE_02167]).

Gebruik

De elementfunctie find_first_of van de klasse ara::core::StringView uit de header ara/core/string_view.h doorzoekt de string-view vanaf de positie pos synchroon naar het eerste voorkomen van een willekeurig teken uit de tekenreeks s [SWS_CORE_02168]. Als retourwaarde levert deze de desbetreffende index op als size_type. Door de specificatie als constexpr kan deze zoekactie reeds tijdens compilatietijd worden uitgevoerd [SWS_CORE_02168].

Foutafhandeling en gelijktijdigheid

De functie is gedeclareerd als noexcept en gespecificeerd als exceptieveilig (exception safe) [SWS_CORE_02168]. Specifieke foutcodes of meldingen aan DET of DEM bestaan niet. Aangezien de methode de toestand van de instantie niet wijzigt (const), is gelijktijdige leestoegang vanuit meerdere threads veilig. Interpretatie: aangezien de signatuur geen lengteparameter bevat, is de aanroeper vermoedelijk verplicht om een geldige nul-getermineerde C-string aan s door te geven om ongedefinieerd gedrag te voorkomen. Vraag Q-6b692ff18063aef5 (open)

Samenspel

Binnen ara::core::StringView vult de functie de overloads aan voor StringView [SWS_CORE_02165], afzonderlijke tekens [SWS_CORE_02166] en tekenreeksen met expliciete lengtebegrenzing n [SWS_CORE_02167], die allemaal gedefinieerd zijn als constexpr en noexcept. In tegenstelling tot de analoge pointerzoekfuncties in ara::core::BasicString, die ingedeeld zijn als niet-exceptieveilig (not exception safe) [SWS_CORE_03330], [SWS_CORE_03331], garandeert de implementatie in ara::core::StringView volledige uitzonderingsvrijheid [SWS_CORE_02168].