klasse ara::core::Map

Gebruik

De synchrone elementtoegangsfunctie at van de klasse ara::core::Map ([SWS_CORE_01456]) dient voor het gecontroleerd opvragen van een waarde bij een aanwezige sleutel. Deze wordt beschikbaar gesteld via de header ara/core/map.h. Als invoerparameter accepteert deze een sleutelreferentie const key_type &x en retourneert een modificeerbare referentie mapped_type & naar de bijbehorende waarde ([SWS_CORE_01456]). De semantiek komt in principe overeen met het gebruikelijke gebruik van std::map; voor constante instanties is de afzonderlijke overload [SWS_CORE_01457] beschikbaar.

Foutafhandeling en randvoorwaarden

In geval van een fout wijkt de functie doelbewust af van het ISO-standaardgedrag: als het opgegeven element x niet aanwezig is in de container, wordt een IsoStdOutOfRangeViolation geactiveerd in plaats van een klassieke C++-uitzondering van het type std::out_of_range ([SWS_CORE_01456]). De signatuur is expliciet gedeclareerd als noexcept en geclassificeerd als uitzonderingsveilig (exception safe) ([SWS_CORE_01456]).

Samenspel

Het concept om overschrijdingen van het bereik via IsoStdOutOfRangeViolation te signaleren, wordt modulebreed uniform toegepast:

• Binnen ara::core::Map heeft de lezende overload met const hetzelfde foutgedrag ([SWS_CORE_01457]).
• Overeenkomstige at-functies met IsoStdOutOfRangeViolation bestaan voor ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]), ara::core::StringView ([SWS_CORE_02133]) en ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).
• De gegenereerde violation hangt in het totale systeem vermoedelijk samen met afbreek- en beëindigingsmechanismen zoals AddAbortHandler ([SWS_CORE_00054]). Vraag Q-9427d214713f7508 (open)

Gebruik

De elementfunctie at conform [SWS_CORE_01457] maakt synchrone, lezende toegang tot een element binnen een instantie van ara::core::Map via de header #include "ara/core/map.h" mogelijk. Als parameter wordt de gezochte sleutel x als const key_type & doorgegeven. Bij een succesvolle zoekopdracht retourneert de methode een constante referentie naar de bijbehorende waarde (const mapped_type &).

Foutafhandeling en uitzonderingsgedrag

Het gedrag komt in principe overeen met het standaardgedrag van std::map::at, maar vertoont een specifieke afwijking: als de sleutel x niet in de container wordt gevonden, wordt conform [SWS_CORE_01457] een IsoStdOutOfRangeViolation in plaats van std::out_of_range gegenereerd. Aangezien de functie is gespecificeerd met noexcept, leidt deze schending niet tot een reguliere C++-exceptie; vermoedelijk heeft dit het gecontroleerd afbreken van het proces tot gevolg via de foutafhandelingsmechanismen zoals deze in de context van [SWS_CORE_00054] kunnen worden geregistreerd. Vraag Q-d7dd2c332f88ed14 (open)

Gelijktijdigheid en wisselwerking

Als constante methode kwalificeert de aanroep zich voor gelijktijdige leestoegang, mits er geen gelijktijdige modificerende toegangen tot dezelfde map-instantie plaatsvinden. Naast deze constante interface bestaat er met [SWS_CORE_01456] een niet-constante overload die een modificeerbare referentie retourneert. Dezelfde strategie voor het signaleren van bereikschendingen via IsoStdOutOfRangeViolation wordt consistent ook in andere adaptieve core-containers toegepast, bijvoorbeeld bij ara::core::Array ([SWS_CORE_01274]) en ara::core::Vector ([SWS_CORE_01354]).

De lidfunctie clear van de klasse ara::core::Map dient voor het volledig leegmaken van de containerinhoud conform de specificatie in [SWS_CORE_01485]. De functie vereist de opname van het headerbestand #include "ara/core/map.h". Aanroepsemantiek en gedrag zijn daarbij gebaseerd op het corresponderende gebruik van de ISO-C++-standaard voor associatieve standaard-maps ([map]).

Wat betreft interface en foutafhandeling vertoont de functie de volgende eigenschappen:

• Parameters en retourwaarde: De bewerking heeft de signatuur void clear () noexcept;, accepteert geen parameters en levert geen retourwaarde op [SWS_CORE_01485].
• Uitzonderingsveiligheid: De functie is expliciet gedeclareerd als noexcept en gespecificeerd als exception safe [SWS_CORE_01485]. Ze gooit bijgevolg geen C++-exceptions in geval van een fout.
• Synchrone uitvoering: De aanroep wordt synchroon op de instantie uitgevoerd; na terugkeer is de container vermoedelijk leeg (grootte 0). Vraag Q-1d0cf2a1a33d818e (open)

In de module core volgt het opschonen van standaardcontainers een uniform paradigma. Analoge clear-functies met identieke signatuur en uitzonderingsveiligheid zijn bijvoorbeeld te vinden voor sequentiële containers in ara::core::Vector conform [SWS_CORE_01375] (ara/core/vector.h) en voor tekenreeksen in ara::core::BasicString conform [SWS_CORE_03057] (ara/core/string.h). Ontwikkelaars kunnen containeroverstijgend vertrouwen op de vertrouwde C++-standaardsemantiek en de gegarandeerde uitzonderingsvrijheid.

De template-methode contains van de klasse ara::core::Map dient voor de synchrone controle of een gezochte sleutel in een associatieve container bestaat [SWS_CORE_01497]. Deze wordt beschikbaar gesteld via de header #include "ara/core/map.h" en als constante lidfunctie (const) op een instantie van ara::core::Map aangeroepen [SWS_CORE_01497]. Als aanroepparameter accepteert deze een constante referentie const K &x naar de te zoeken sleutel en levert een retourwaarde van het type bool op [SWS_CORE_01497].

Wat betreft haar semantiek verwijst de specificatie naar het overeenkomstige gebruik in [map] [SWS_CORE_01497]. Dit moet vermoedelijk worden geïnterpreteerd als overname van het gedrag van std::map::contains, volgens hetwelk de methode dan en slechts dan true teruggeeft wanneer een equivalente sleutel in de map aanwezig is, en anders false. Vraag Q-664d5a3d099db549 (open)

Met betrekking tot robuustheid en foutafhandeling is de functie expliciet geclassificeerd als not exception safe [SWS_CORE_01497]. Specifieke AUTOSAR-foutcodes of meldingen aan DET of DEM bestaan voor deze operatie niet. Aanroepers moeten er rekening mee houden dat tijdens de uitvoering, vermoedelijk getriggerd door sleutelvergelijkingen of conversies van het type K, excepties kunnen worden opgeworpen en naar buiten kunnen propageren. Vraag (open)

Aangezien contains als lezende const-operatie de toestand van de map niet wijzigt, zijn gelijktijdige leestoegangen op dezelfde instantie over het algemeen niet kritisch, terwijl parallelle schrijvende modificaties aan de container vermoedelijk externe synchronisatie vereisen. Vraag Q-f3ca0e3d094f8f0a (open)

Gebruik en semantiek

De lidfunctie contains behoort tot de scope van de klasse ara::core::Map en wordt beschikbaar gesteld via het headerbestand ara/core/map.h [SWS_CORE_01510]. De functie heeft de signatuur bool contains (const key_type &x) const; en wordt synchroon uitgevoerd. Deze dient ter controle of een element met de sleutel x in de container aanwezig is. De specificatie verwijst naar het overeenkomstige gedrag in [map], waarmee vermoedelijk de semantiek van de C++-standaardcontainer std::map::contains wordt bedoeld, die bij aanwezige sleutel true en anders false oplevert. Vraag Q-fea394bd408bf925 (open)

Foutafhandeling en uitzonderingsveiligheid

Het gedrag van contains is in de specificatie uitdrukkelijk geclassificeerd als not exception safe [SWS_CORE_01510]. Specifieke foutcodes, foutdomeinen evenals DET- of DEM-meldingen zijn binnen de specificatieomvang niet gedefinieerd. Aanroepers moeten er daarom rekening mee houden dat bij het zoeken geen garanties voor uitzonderingsveiligheid worden geboden en dat optredende excepties moeten worden afgehandeld.

Gelijktijdigheid en beperkingen

Over thread-safety doet de specificatie in [SWS_CORE_01510] geen expliciete uitspraak. Aangezien het om een constante lidfunctie (const) gaat, wordt de containertoestand niet gemodificeerd. Interpretatie: parallelle leestoegangen zijn vermoedelijk toegestaan, terwijl gelijktijdige schrijvende modificaties op dezelfde instantie externe synchronisatie vereisen. Vraag Q-7d8ce1efc81ec781 (open)

Interactie in de module core

In vergelijking met andere statuscontrolerende functies van de module core — zoals bijvoorbeeld HasValue [SWS_CORE_00751] of CheckError [SWS_CORE_00765] in ara::core::Result, die gedefinieerd zijn als exception safe en noexcept — biedt contains in ara::core::Map geen noexcept-garantie en is deze gedeclareerd als niet-uitzonderingsveilig [SWS_CORE_01510].

De synchrone lidfunctie count van de klasse ara::core::Map bepaalt aan de hand van de doorgegeven sleutel x van het type const key_type& hoe vaak deze sleutel in de container voorkomt, en levert het resultaat terug als size_type [SWS_CORE_01494]. De declaratie vindt plaats via de header #include "ara/core/map.h" [SWS_CORE_01494]. Interpretatie: Overeenkomstig de verwijzing naar het standaardgedrag in [map] bedraagt de retourwaarde bij unieke sleutels vermoedelijk ofwel 0 ofwel 1. Vraag Q-a713cfc1019b40d0 (open)

Wat betreft de foutafhandeling is de functie conform de specificatie uitdrukkelijk geclassificeerd als „not exception safe” [SWS_CORE_01494]. Er worden geen specifieke foutcodes of DET-/DEM-meldingen gedefinieerd; als de sleutelvergelijkingsbewerking een exceptie genereert, wordt deze vermoedelijk direct naar de aanroeper gepropageerd. Vraag (open)

Wat betreft gelijktijdigheid en beperkingen betreft het een constante bewerking (const) [SWS_CORE_01494]. Interpretatie: Gelijktijdige leestoegangen tot dezelfde instantie van ara::core::Map zijn vermoedelijk mogelijk zonder dataraces, terwijl gelijktijdige modificerende bewerkingen moeten worden beveiligd door externe synchronisatie. Vraag (open)

In samenspel met verwante eisen bestaat er met [SWS_CORE_01495] een template-overbelasting template <class K> size_type count (const K &x) const binnen ara::core::Map. Deze maakt heterogene zoekopdrachten met compatibele vergelijkingstypes K mogelijk, zonder vooraf verplicht een tijdelijk object van het type key_type te moeten aanmaken, maar is onderworpen aan dezelfde classificatie wat betreft de uitzonderingsveiligheid [SWS_CORE_01495].

De template-memberfunctie count van de klasse ara::core::Map controleert synchroon het voorkomen van elementen aan de hand van een sleutel en bepaalt het aantal daarvan [SWS_CORE_01495]. De functie is gedeclareerd in de header ara/core/map.h en retourneert het aantal gevonden elementen als size_type [SWS_CORE_01495]. Conform de gespecificeerde referentie naar het gebruik in [map] levert de aanroep bij unieke sleutels de waarde 1 op als er een passend element bestaat, en anders 0 [SWS_CORE_01495].

In direct samenspel met de overload count(const key_type&) [SWS_CORE_01494] staat deze variant de doorgifte van een willekeurig compatibel sleuteltype toe const K& [SWS_CORE_01495]. Interpretatie: De templatisering is vermoedelijk ontworpen voor heterogene zoekoperaties om vergelijkingen uit te voeren zonder voorafgaande conversie naar een tijdelijk key_type-object [SWS_CORE_01495]. Vraag Q-e2572768e5600da7 (open) Hierdoor kunnen onnodige allocaties en conversiekosten bij zoekopdrachten worden vermeden.

Met betrekking tot de uitzonderingsveiligheid is de methode gedeclareerd als niet-uitzonderingsveilig (not exception safe) [SWS_CORE_01495], analoog aan de verwante overload [SWS_CORE_01494]. Specifieke foutkanalen zoals DET of DEM bestaan voor deze containeroperatie niet [SWS_CORE_01495]; eventuele uitzonderingen van de onderliggende vergelijkingsoperator slaan door naar de aanroeper. Aangezien de methode const-gekwalificeerd is, modificeert deze de container niet [SWS_CORE_01495]; gelijktijdige leestoegangen zijn veilig, concurrerende schrijftoegangen vereisen echter externe synchronisatie.

Gebruik

De memberfunctie crbegin van de klasse ara::core::Map wordt beschikbaar gesteld via het headerbestand #include "ara/core/map.h" [SWS_CORE_01450]. Deze accepteert geen parameters en levert synchroon een const_reverse_iterator op naar het eerste element van de omgekeerde volgorde [SWS_CORE_01450]. De functionele semantiek volgt de specificatieopgave “As per corresponding usage in [map]” [SWS_CORE_01450]; dit komt vermoedelijk overeen met de semantiek van std::map::crbegin uit de C++-standaard. Vraag Q-0ad5de7dada37aa8 (open)

Foutafhandeling en uitzonderingsveiligheid

Specifieke foutcodes, DET- of DEM-meldingen zijn voor deze aanroep niet voorzien. Volgens de specificatie is de functie gedeclareerd met noexcept en geclassificeerd als uitzonderingsveilig (“exception safe”) [SWS_CORE_01450], zodat bij de uitvoering geen excepties optreden.

Gelijktijdigheid en beperkingen

Als const-gekwalificeerde methode wijzigt crbegin het ara::core::Map-object niet [SWS_CORE_01450]. De resulterende iterator staat uitsluitend leestoegang toe tot de elementen in de container.

Samenspel

Het iteratieconcept is in AUTOSAR Adaptive Core over containers heen geharmoniseerd:

• ara::core::Vector [SWS_CORE_01342] en ara::core::BasicString [SWS_CORE_03049] bieden functioneel identieke const noexcept-methoden.
• Voor ara::core::Array [SWS_CORE_01260], ara::core::Span [SWS_CORE_01978] en ara::core::StringView [SWS_CORE_02126] is crbegin bovendien gedefinieerd als constexpr.

Gebruik

De methode crend van de template-klasse ara::core::Map ([SWS_CORE_01451]) is beschikbaar via de header ara/core/map.h. Deze levert synchroon een constante reverse-iterator (const_reverse_iterator) op, die volgens het standaardgedrag van std::map het bereiken van het einde van een achterwaartse iteratie over de elementen markeert.

Foutafhandeling en exception-veiligheid

De functie heeft de specificatie noexcept en is geclassificeerd als “exception safe” ([SWS_CORE_01451]). De aanroep werpt geen excepties en vereist geen controle van foutcodes.

Gelijktijdigheid en randvoorwaarden

Als const-gekwalificeerde methode wijzigt crend de onderliggende map-instantie niet. Gelijktijdige leestoegangen via meerdere threads zijn daarom vermoedelijk veilig, zolang de instantie niet gelijktijdig schrijvend wordt gewijzigd (interpretatie). Vraag Q-5593deafcef41be3 (open)

Samenspel

De signatuur en semantiek passen binnen de uniforme iterator-interfaces van de ara::core-bibliotheek. Analoge crend-functies bestaan voor:

• ara::core::Vector ([SWS_CORE_01343]) en ara::core::BasicString ([SWS_CORE_03050]), telkens met identieke const noexcept-declaratie, evenals
• de containers en views ara::core::Array ([SWS_CORE_01261]), ara::core::Span ([SWS_CORE_01979]) en ara::core::StringView ([SWS_CORE_02127]), die bovendien als constexpr zijn gedeclareerd.

Gebruik van emplace in ara::core::Map

De template-lidfunctie emplace van de klasse ara::core::Map dient voor het direct construeren en invoegen van een nieuw sleutel-waardepaar in het associatieve geheugen [SWS_CORE_01458]. De functie is gedefinieerd in de header #include "ara/core/map.h" en accepteert de constructorargumenten via het parameterpakket Args&&... args [SWS_CORE_01458]. Als resultaat levert de synchrone aanroep een std::pair<iterator, bool> op [SWS_CORE_01458]. Interpretatie: de verwijzing naar [map] betekent vermoedelijk dat het gedrag de C++-standaardcontainer std::map volgt, zodat de iterator naar het element verwijst en de booleaanse waarde aangeeft of het item nieuw is ingevoegd. Vraag Q-fa496892c1e5e15d (open)

Wat betreft foutafhandeling en robuustheid is emplace in de specificatie uitdrukkelijk geclassificeerd als not exception safe [SWS_CORE_01458]. Mislukt de geheugenallocatie of de constructie van het object, dan garandeert de implementatie geen consistentie van de container. Specifieke AUTOSAR-foutcodes of meldingen aan DET of DEM zijn voor deze fundamentele interface niet voorzien.

In de module core bestaan analoge emplace-operaties voor andere gegevenstypen, die echter afwijkende garanties hebben: terwijl ara::core::Vector::emplace eveneens als niet-uitzonderingsveilig is gespecificeerd [SWS_CORE_01366], bieden de implementaties in ara::core::Optional [SWS_CORE_01119] alsook ara::core::Variant [SWS_CORE_01661] voorwaardelijke uitzonderingsveiligheid (conditionally exception safe).

Gebruik

De template-lidfunctie emplace_hint van de containerklasse ara::core::Map dient voor het invoegen van een nieuw element met behulp van een voorgestelde positie als zoekhint ([SWS_CORE_01459]). Deze wordt beschikbaar gesteld via de header ara/core/map.h en accepteert de iterator position evenals een parameterpakket args voor forwarding ([SWS_CORE_01459]). De werking komt overeen met het gebruik in [map] ([SWS_CORE_01459]). Vermoedelijk worden de meegegeven argumenten direct gebruikt voor in-place constructie van het item, waardoor bij een passende positionering een versnelde invoeging bereikt zou moeten worden. Vraag Q-564dd9bab5c0293f (open)

Foutafhandeling en exception-veiligheid

Wat betreft de fouttolerantie is de operatie expliciet geclassificeerd als not exception safe ([SWS_CORE_01459]). Mocht er tijdens de geheugenallocatie of de constructie van het sleutel-waardepaar een fout optreden, dan gelden vermoedelijk geen enkele garanties met betrekking tot de containerstatus. Vraag (open) Bijzondere foutcodes of diagnosemeldingen zoals DET of DEM zijn voor deze interface niet gedefinieerd ([SWS_CORE_01459]).

Gelijktijdigheid en beperkingen

Over gelijktijdigheid en aanroepcontexten doet de specificatie geen uitspraak ([SWS_CORE_01459]). Interpretatie: Als statuswijzigende operatie op ara::core::Map vereist emplace_hint bij gelijktijdige toegang door meerdere threads externe synchronisatie om inconsistenties in gegevens te voorkomen. Vraag Q-04b3ab58544ceba4 (open)

Gebruik

De synchrone elementfunctie equal_range van de klasse ara::core::Map wordt beschikbaar gesteld via de header #include "ara/core/map.h" [SWS_CORE_01506]. Deze accepteert een sleutel x van het type const key_type & en levert een paar modificeerbare iterators (std::pair<iterator, iterator>) op dat het bereik van alle passende items begrenst [SWS_CORE_01506]. Het gedrag volgt de gebruikelijke semantiek in [map] [SWS_CORE_01506]; aangezien Map gewoonlijk unieke sleutels heeft, omvat het resultaatbereik vermoedelijk hoogstens één element (interpretatie). Vraag Q-d26df1f3ac3b6232 (open)

Foutafhandeling en uitzonderingsveiligheid

De specificatie classificeert de functie uitdrukkelijk als not exception safe [SWS_CORE_01506]. Specifieke foutcodes, retourwaarden voor foutsignalering of rapportages aan DET of DEM zijn niet gedefinieerd. Wordt de gezochte sleutel niet gevonden, dan zijn beide iterators van het paar vermoedelijk identiek en wijzen zij naar de potentiële invoegpositie (interpretatie conform [map]). Vraag (open)

Gelijktijdigheid en beperkingen

De operatie is niet-constant en retourneert niet-constante iterators [SWS_CORE_01506]. Aangezien er geen synchronisatiemechanismen zijn gedocumenteerd, zijn gelijktijdige lees- of schrijftoegangen tot dezelfde instantie van ara::core::Map vermoedelijk niet thread-safe (interpretatie) en vereisen deze externe synchronisatie. Vraag Q-3fb76368d9de336f (open)

Samenspel

Voor lezende toegangen tot constante instanties is de overload met const_iterator-paren beschikbaar [SWS_CORE_01507]. Daarnaast bestaan er template-varianten voor heterogene zoekacties met een willekeurig sleuteltype K, zowel voor niet-constante aanroepen [SWS_CORE_01508] als voor constante aanroepen [SWS_CORE_01509].

Gebruik

De lidfunctie equal_range van de klasse ara::core::Map bepaalt op een constante instantie het bereik van alle invoeren die overeenkomen met een opgegeven sleutel [SWS_CORE_01507]. Zij accepteert de parameter const key_type &x en retourneert een std::pair<const_iterator, const_iterator>, die de grenzen van het bereik voorstelt [SWS_CORE_01507]. De functie wordt via het headerbestand ara/core/map.h beschikbaar gesteld en synchroon uitgevoerd [SWS_CORE_01507]. De semantiek komt overeen met de specificatie van [map] [SWS_CORE_01507]; dienovereenkomstig omvat het geretourneerde bereik bij een map met unieke sleutels vermoedelijk een spanne van hoogstens één invoer. Vraag Q-f2bdc3bf2c17948e (open)

Foutafhandeling en randvoorwaarden

Met betrekking tot het fout- en exceptiegedrag is de methode gespecificeerd als niet exceptieveilig („not exception safe”) [SWS_CORE_01507]. Er zijn geen specifieke foutcodes, DET-meldingen of DEM-gebeurtenissen vastgelegd. Aangezien de methode gedeclareerd is als const, wijzigt zij de toestand van het aanroepende object niet.

Samenspel

De operatie is ingebed in een reeks verwante overloads binnen ara::core::Map:

• Voor niet-constante instanties biedt [SWS_CORE_01506] dezelfde zoekactie aan, maar levert modificeerbare iterators.
• Via de templatefuncties [SWS_CORE_01508] en [SWS_CORE_01509] kan de zoekactie ook met compatibele sleutels van het type K voor veranderlijke en constante maps worden uitgevoerd.

Gebruik en semantiek

De template-lidfunctie equal_range van de klasse ara::core::Map ([SWS_CORE_01508]) wordt via de header ara/core/map.h beschikbaar gesteld. Zij dient voor het vinden van het bereik van alle elementen waarvan de sleutel overeenkomt met de doorgegeven waarde. Het gedrag richt zich daarbij naar het corresponderende gebruik in [map] ([SWS_CORE_01508]). De synchrone aanroep accepteert een sleutelparameter x van het generieke type const K& en levert als retourwaarde een std::pair<iterator, iterator> ([SWS_CORE_01508]). Interpretatie: Door het generieke parametertype K ondersteunt de functie vermoedelijk een heterogene lookup, zodat vergelijkingen zonder voorafgaande omzetting naar key_type mogelijk zijn. Vraag Q-19f39bf5b68f9a3c (open)

Foutafhandeling en randvoorwaarden

Volgens de specificatie is de functie geclassificeerd als niet-uitzonderingsveilig (not exception safe) ([SWS_CORE_01508]). Er zijn geen specifieke foutcodes, retourwaarden voor foutindicatie of meldingen aan DET of DEM voorzien. Aangezien de functie niet als const is gekwalificeerd, retourneert deze modificeerbare iterators die schrijftoegang tot de aanwezige waarden toestaan.

Samenspel

De lidfunctie maakt deel uit van een groep verwante equal_range-overloadings binnen ara::core::Map:

• [SWS_CORE_01506]: Niet-constante variant voor directe sleutels van het type const key_type&.
• [SWS_CORE_01507]: Constante variant voor directe sleutels van het type const key_type&, die const_iterator retourneert.
• [SWS_CORE_01509]: Constante template-overloading voor generieke sleutels van het type const K&.

Gebruik

De template-lidfunctie equal_range van de klasse ara::core::Map uit de header ara/core/map.h bepaalt het bereik van elementen die overeenkomen met een doorgegeven zoeksleutel x van het type K [SWS_CORE_01509]. Als constante methode retourneert deze een waardepaar van constante iterators std::pair<const_iterator, const_iterator> en wijzigt de onderliggende container niet [SWS_CORE_01509]. Volgens de specificatie richt de semantiek zich naar het overeenkomstige gebruik in [map] [SWS_CORE_01509]. Interpretatie: De templateparameter K maakt vermoedelijk een heterogeen zoeken naar sleutels mogelijk, zodat er geen tijdelijk object van het sleuteltype hoeft te worden geconstrueerd. Vraag Q-7f7a93cef3cf7d8f (open)

Foutafhandeling en uitzonderingsveiligheid

Wat betreft uitzonderingsveiligheid is de functie uitdrukkelijk geclassificeerd als niet-uitzonderingsveilig („not exception safe”) [SWS_CORE_01509]. Specifieke foutcodes of terugmeldingen aan diagnose- of foutinterfaces (zoals DET of DEM) zijn in de specificatieomvang voor deze functie niet voorzien [SWS_CORE_01509].

Interactie en overbelastingen

De functie staat in direct verband met de overige varianten van equal_range in ara::core::Map:

• De niet-constante template-overloading [SWS_CORE_01508], die een paar modificeerbare iterators retourneert.
• De niet op templates gebaseerde overloadings voor const key_type &x in niet-constante vorm [SWS_CORE_01506] en in constante vorm [SWS_CORE_01507].

De functie erase van de klasse ara::core::Map verwijdert synchroon het element uit de container dat wordt gerefereerd door de meegegeven parameter position [SWS_CORE_01480]. De definitie wordt ingevoegd via de header <ara/core/map.h> [SWS_CORE_01480]. Als retourwaarde levert de functie een iterator op naar het element in de map dat direct volgt op het verwijderde element [SWS_CORE_01480]. De semantiek volgt de specificatie conform het corresponderende gebruik in [map] [SWS_CORE_01480].

Wat betreft foutafhandeling is de operatie geclassificeerd als niet-uitzonderingsveilig (not exception safe) [SWS_CORE_01480]. Specifieke foutcodes, fallback-kanalen of foutmeldingen via DET of DEM zijn voor deze aanroep niet gespecificeerd [SWS_CORE_01480]. Aangezien het gedrag zich oriënteert op [map], wordt de meegegeven iterator door het verwijderingsproces vermoedelijk ongeldig, terwijl iterators naar overblijvende elementen vermoedelijk intact blijven [SWS_CORE_01480]. Het meegeven van een ongeldige of niet-derefereerbare iterator leidt wegens het ontbreken van validatie vermoedelijk tot ongedefinieerd gedrag (interpretatie). Vraag Q-1a4a3eae317fc52e (open)

In het samenspel binnen ara::core::Map bestaan alternatieve overbelastingen: Naast verwijdering via een wijzigbare iterator is er een overbelasting voor const_iterator beschikbaar [SWS_CORE_01481]. Evenzo kunnen elementen sleutelgebaseerd via key_type [SWS_CORE_01482] of als een geheel iteratorbereik worden verwijderd [SWS_CORE_01483].

De memberfunctie erase van de klasse ara::core::Map dient voor het synchroon wissen van een afzonderlijk element op de door de iterator position aangeduide positie [SWS_CORE_01481]. De declaratie vindt plaats via het headerbestand ara/core/map.h [SWS_CORE_01481]. Het gedrag komt overeen met de definitie in [map], waarbij de functie een iterator naar het daaropvolgende element van de map retourneert [SWS_CORE_01481].

Wat betreft exceptieafhandeling is de functie gespecificeerd als “not exception safe” [SWS_CORE_01481]. Specifieke foutcodes, violations of foutmeldingen zijn voor deze operatie niet gedefinieerd [SWS_CORE_01481]. Interpretatie: Het doorgeven van een ongeldige of niet-derefereerbare iterator als position leidt vermoedelijk tot ongedefinieerd gedrag, aangezien de specificatie niet voorziet in foutcontroles. Vraag Q-9a3242ae4773cc0b (open)

In interactie met de container-interface van ara::core::Map zijn er aanvullende overloads beschikbaar:

• Wissen via een wijzigbare iterator iterator position [SWS_CORE_01480],
• Wissen op basis van een sleutel via erase(const key_type &x) met teruggave van het aantal verwijderde elementen [SWS_CORE_01482],
• Bereikwissing via twee iterators first en last [SWS_CORE_01483].

Overeenkomstige overloads voor afzonderlijke const_iterator-posities zijn analoog ook gedefinieerd voor andere containers zoals ara::core::Vector [SWS_CORE_01372] of ara::core::BasicString [SWS_CORE_03103].

Gebruik

De synchrone memberfunctie erase van de klasse ara::core::Map dient voor het verwijderen van items via een opgegeven sleutel x van het type const key_type& ([SWS_CORE_01482]). De interface wordt via de header ara/core/map.h ingevoegd. Het functionele gedrag is gedefinieerd als equivalent aan het gebruik in [map] ([SWS_CORE_01482]). Interpretatie: Overeenkomstig deze C++-standaardreferentie geeft de retourwaarde van het type size_type vermoedelijk het aantal succesvol uit de container gewiste elementen aan. Vraag Q-03637eb7e5efe502 (open)

Foutafhandeling en randvoorwaarden

In de specificatie is de functie geclassificeerd als not exception safe ([SWS_CORE_01482]). Specifieke retourcodes voor foutsituaties of rapportagetrajecten via DET of DEM zijn voor deze containeraanroep niet gedefinieerd. Interpretatie: Vanwege het ontbreken van uitzonderingsveiligheid gelden er bij fouten vermoedelijk geen garanties met betrekking tot de toestand van de container, waardoor de aanroeper vóór uitvoering moet zorgen voor consistente data en geldige aanroepparameters. Vraag (open)

Samenspel

De methode vormt de op sleutels gebaseerde tegenhanger van de op iterators gebaseerde wisoperaties van ara::core::Map, die afzonderlijke posities ([SWS_CORE_01480], [SWS_CORE_01481]) of gesloten iteratorbereiken ([SWS_CORE_01483]) opschonen. Het patroon van gestandaardiseerde erase-functies komt in ara::core over meerdere containers voor, zoals voor ara::core::Vector ([SWS_CORE_01372]) of voor ara::core::BasicString ([SWS_CORE_03102]).

Gebruik

De lidfunctie erase van de container ara::core::Map dient voor het verwijderen van een door twee iterators begrensd waardebereik [SWS_CORE_01483]. Deze is gedefinieerd in de header #include "ara/core/map.h" en heeft de signatuur iterator erase (const_iterator first, const_iterator last); [SWS_CORE_01483]. Functioneel volgt het gedrag de gebruikelijke semantiek in [map] [SWS_CORE_01483]. Als returnwaarde levert deze een iterator op naar het element dat direct volgt op het verwijderde bereik, of het einde van de container [SWS_CORE_01483].

Foutafhandeling en beperkingen

De operatie is in de specificatie expliciet geclassificeerd als not exception safe [SWS_CORE_01483]. Specifieke AUTOSAR-foutcodes of meldingen aan DET of DEM zijn voor deze functie niet gedefinieerd. De aanroeper moet daarom vermoedelijk onder eigen verantwoordelijkheid waarborgen dat first en last een geldig, goedgevormd bereik binnen dezelfde instantie refereren, aangezien er geen afzonderlijke controles zijn voorzien (interpretatie). Vraag Q-69e88ecc6f04bb64 (open)

Samenspel

Binnen ara::core::Map vult deze bereikverwijdering de overloads voor het verwijderen van afzonderlijke elementen via iterator [SWS_CORE_01480], via const_iterator [SWS_CORE_01481] alsook aan de hand van een sleutel key_type [SWS_CORE_01482] aan. Gelijksoortige erase-interfaces voor iteratorbereiken zijn ook te vinden in andere containers van de Adaptive Core Library, met name in ara::core::Vector [SWS_CORE_01373] en ara::core::BasicString [SWS_CORE_03104].

De memberfunctie extract van de klasse ara::core::Map haalt het element op de door de iterator position aangeduide positie weg en levert een node van het type node_type terug [SWS_CORE_01470]. De declaratie en semantiek volgen daarbij het overeenkomstige gebruik in [map], waardoor de node rechtstreeks uit de associatieve container wordt losgemaakt. De functie wordt beschikbaar gesteld via de header ara/core/map.h.

Gebruik en gedrag

De aanroep geschiedt synchroon op een instantie van ara::core::Map. Als parameter wordt een const_iterator position meegegeven, die, interpretatie: moet verwijzen naar een geldig, dereferentieerbaar element binnen de aangeroepen map. Door de extractie wordt het element uit de container verwijderd, terwijl het geretourneerde node_type-object het eigenaarschap over de node overneemt.

Foutafhandeling en exception-veiligheid

Wat betreft de uitzonderingsafhandeling is de functie volgens de specificatie uitdrukkelijk geclassificeerd als not exception safe [SWS_CORE_01470]. Als tijdens de uitvoering een exceptie optreedt, garandeert de operatie geen deterministische containergaranties, waardoor aanroepende code passende voorzorgsmaatregelen moet treffen.

Interactie en alternatieven

Als overload is naast de op positie gebaseerde verwijdering ook de op sleutel gebaseerde variant extract(const key_type &x) beschikbaar [SWS_CORE_01471]. Deze laatste maakt het extraheren van een element rechtstreeks aan de hand van de sleutelwaarde mogelijk, zonder vooraf handmatig een iterator te hoeven bepalen.

Gebruik

De synchrone memberfunctie extract is in het headerbestand #include "ara/core/map.h" gedefinieerd binnen de klasse ara::core::Map [SWS_CORE_01471]. Deze accepteert als parameter een constante sleutelreferentie const key_type &x en levert het gevonden element terug als node_type [SWS_CORE_01471]. De functionele semantiek verwijst naar het overeenkomstige gebruik in [map] [SWS_CORE_01471]; dit komt vermoedelijk overeen met de C++-standaard, volgens welke de knoop direct uit de container wordt gehaald zonder dat sleutel of waarde gekopieerd hoeven te worden. Vraag (open)

Foutafhandeling en beperkingen

De functie is in de specificatie expliciet geclassificeerd als „not exception safe” [SWS_CORE_01471]. Specifieke foutcodes, foutklassen of DET- respectievelijk DEM-meldingen zijn in de payload niet gedefinieerd. In geval van een fout bestaan er daarom vermoedelijk geen garanties met betrekking tot het behoud of de consistentie van de containertoestand, waardoor aanroepende partijen passende beschermingsmaatregelen moeten voorzien. Vraag (open)

Samenspel

Het specificatie-element staat in direct verband met de overbelasting node_type extract(const_iterator position) [SWS_CORE_01470]. Terwijl de onderhavige functie een element identificeert en extraheert via de zoeksleutel [SWS_CORE_01471], maakt de verwante variant de gerichte extractie via een reeds bekende iteratorpositie mogelijk [SWS_CORE_01470]. Beide interfaces behoren tot de scope van ara::core::Map en delen dezelfde eigenschap van ontbrekende uitzonderingsveiligheid [SWS_CORE_01470] [SWS_CORE_01471].

Gebruik

De lidfunctie find van de klasse ara::core::Map dient voor het synchroon vinden van een element aan de hand van de sleutel ervan [SWS_CORE_01490]. De functie is gedeclareerd in het headerbestand ara/core/map.h. Deze accepteert een referentie naar de gezochte sleutel (const key_type &x) en levert een wijzigbare iterator naar het gevonden sleutel-waardepaar terug; wordt er geen passende invoer gevonden, dan komt het geretourneerde resultaat overeen met de end-iterator van de map [SWS_CORE_01490].

Foutafhandeling en uitzonderingsveiligheid

Volgens de specificatie is deze functie geclassificeerd als not exception safe [SWS_CORE_01490]. Foutmeldingen via DET of DEM zijn voor deze containerbasisdienst niet gespecificeerd. Als er tijdens de vergelijking operationele fouten optreden, kunnen excepties van de onderliggende vergelijkingsoperator worden gepropageerd.

Gelijktijdigheid en wisselwerking

Aangezien het om een niet-constante lidfunctie gaat die een schrijfbare iterator oplevert, is gelijktijdige toegang zonder synchronisatie vermoedelijk niet thread-safe. Vraag Q-0f9f56b506cfd318 (open) Voor louter lezende toegang tot constante instanties van ara::core::Map is de overbelasting met const_iterator beschikbaar [SWS_CORE_01491]. Daarnaast ondersteunen getemplateerde overbelastingen een transparante zoekopdracht met compatibele vergelijkingstypen K, zowel modificerend [SWS_CORE_01492] als constant [SWS_CORE_01493]. In tegenstelling tot de tekengebaseerde find-functies in ara::core::StringView [SWS_CORE_02157] of ara::core::BasicString [SWS_CORE_03315], die indices van het type size_type opleveren en deels noexcept zijn, opereert deze functie containergebaseerd via iterators.

De constante lidfunctie find van de klasse ara::core::Map dient voor het synchroon vinden van een vermelding aan de hand van de sleutel [SWS_CORE_01491]. Voor de aanroep moet de header #include "ara/core/map.h" worden opgenomen. Als parameter verwacht de functie een referentie naar de gezochte sleutel const key_type &x. Het gedrag komt overeen met de specificatie van [map] in de C++-standaard, zodat bij een succesvolle zoekactie een const_iterator naar het element wordt teruggegeven en anders vermoedelijk end() wordt geleverd [SWS_CORE_01491]. Vraag Q-dca69a1ec5423a8b (open)

Wat betreft de foutafhandeling is de functie gedeclareerd als not exception safe [SWS_CORE_01491]. Aangezien het zoekproces gebaseerd is op het vergelijken van sleutels, vloeien optredende excepties vermoedelijk primair voort uit de door de gebruiker gedefinieerde vergelijkingsbewerking. Voor deze elementaire container zijn geen DET- of DEM-foutmeldingen gedefinieerd. Omdat het een leesbewerking op een constante instantie betreft, is de gelijktijdige toegang van meerdere threads tot hetzelfde object volgens de gebruikelijke C++-containersemantiek parallelliseerbaar, zolang er geen gelijktijdige modificaties plaatsvinden (interpretatie). Vraag Q-a8ec748711885418 (open)

In wisselwerking met andere interfaces vult de methode de niet-constante variant [SWS_CORE_01490] aan, die een modificeerbare iterator levert. Voor heterogene zoekbewerkingen zonder typeconversie staan in ara::core::Map bovendien template-overbelastingen voor modificeerbare [SWS_CORE_01492] evenals constante instanties [SWS_CORE_01493] ter beschikking. Zoekfuncties met dezelfde naam bestaan in de core-module bovendien voor tekenreeksklassen zoals ara::core::BasicString [SWS_CORE_03407] en ara::core::StringView [SWS_CORE_02157].

De template-lidfunctie find conform [SWS_CORE_01492] dient voor het synchroon vinden van een element binnen een instantie van ara::core::Map via het headerbestand ara/core/map.h. Ze accepteert een referentieparameter const K &x en levert een veranderlijke iterator naar het gevonden sleutel-waardepaar of de end-iterator van de container op. De specificatie verwijst naar het gedrag van [map]; de generieke parametervorm dient hierbij vermoedelijk te worden geïnterpreteerd als heterogene zoekactie naar sleutels, om zoeksleutels van een afwijkend type zonder voorafgaande conversie te vergelijken. Vraag Q-425357890b9ea3fe (open)

Wat betreft foutafhandeling en uitzonderingsveiligheid is de functie expliciet geclassificeerd als not exception safe ([SWS_CORE_01492]). Specifieke foutcodes, retourwaarden voor fouttoestanden of DET-/DEM-meldingen zijn niet gedefinieerd in de payload. Als er tijdens de vergelijking of het interne doorlopen een exceptie optreedt, biedt de aanroep geen uitzonderingsgarantie.

In het samenspel binnen ara::core::Map vormt de functie de niet-constante tegenhanger van de constante heterogene zoekactie [SWS_CORE_01493] evenals van de niet-generieke overbelastingen [SWS_CORE_01490] en [SWS_CORE_01491], die telkens vast gebonden zijn aan const key_type &x. Ze verschilt fundamenteel van de gelijknamige zoekfuncties van andere containers zoals ara::core::StringView ([SWS_CORE_02157]) of ara::core::BasicString ([SWS_CORE_03315]), die positiezoekacties op basis van tekenreeksen uitvoeren en deels zijn gedeclareerd als noexcept.

Gebruik

De template-lidfunctie find in de namespace ara::core::Map dient voor het alleen-lezen vinden van elementen aan de hand van een sleutel x van het type K [SWS_CORE_01493]. De functie is gedefinieerd in de header #include "ara/core/map.h" en wordt synchroon aangeroepen op een constante instantie [SWS_CORE_01493]. Ze levert een const_iterator naar het gevonden element terug; interpretatie: In het geval van een niet-aanwezige sleutel komt de teruggegeven iterator vermoedelijk overeen met de end-iterator van de map, aangezien de semantiek volgens de specificatie het gedrag van [map] volgt [SWS_CORE_01493]. Vraag Q-3fa354022f0bca9b (open)

Foutafhandeling en randvoorwaarden

Wat betreft de fouttolerantie is de functie expliciet geclassificeerd als not exception safe [SWS_CORE_01493]. Specifieke foutcodes, retourwaarden voor foutweergave of meldingen aan DET of DEM zijn niet gedefinieerd in de specificatie. Aanroepers moeten er rekening mee houden dat bij optredende excepties tijdens het zoek- of vergelijkingsproces geen garanties voor exceptieveiligheid worden gegeven [SWS_CORE_01493].

Samenspel

Binnen ara::core::Map voltooit deze overbelasting de zoekbewerkingen:

• Ze vult de niet-constante template-variant iterator find(const K &x) aan [SWS_CORE_01492].
• Ze vormt de generieke tegenhanger van de overbelastingen met vaste const key_type &x, die gedeclareerd zijn als niet-constant [SWS_CORE_01490] en constant [SWS_CORE_01491].

Ze verschilt daarmee van de gelijknamige bewerkingen in ara::core::StringView (bijv. [SWS_CORE_02157]) en ara::core::BasicString (bijv. [SWS_CORE_03315]), die werken op tekenreeksen, posities van het type size_type opleveren en gedeclareerd zijn als exception safe.

Gebruik

De functie insert in de context van ara::core::Map dient voor het synchroon toevoegen van een waarde-element door middel van kopiëren via de parameter const value_type &x ([SWS_CORE_01460]). De operatie wordt geïncludeerd via het headerbestand ara/core/map.h. Het retourtype std::pair<iterator, bool> volgt de specificatie „As per corresponding usage in [map]”: Interpretatie: hierbij verwijst de iterator vermoedelijk naar het nieuw ingevoegde of reeds bestaande element, terwijl de booleaanse vlag de succesvolle nieuwe invoer signaleert. Vraag Q-b059c1d0f4dd6665 (open)

Foutafhandeling

In de specificatie zijn geen specifieke AUTOSAR-foutcodes zoals DET- of DEM-meldingen voorzien. De functie is uitdrukkelijk als niet-uitzonderingsveilig („not exception safe”) gedeclareerd ([SWS_CORE_01460]). Mislukt een interne geheugenallocatie of het kopiëren van het element, dan biedt de container geen uitzonderings- of rollback-garanties; een dergelijke fout leidt vermoedelijk tot een afbreking of een ongedefinieerde toestand. Vraag Q-cbe74b301167bcc4 (open)

Gelijktijdigheid en beperkingen

De aanroep geschiedt synchroon in de thread van de aanroeper. De containeroperaties bezitten geen geïntegreerde synchronisatie, waardoor de functie met betrekking tot dezelfde instantie niet-re-entrant is. Parallelle lees- of schrijftoegangen moeten aan de zijde van de aanroeper worden beveiligd.

Samenspel

Voor ara::core::Map bestaan complementaire overbelastingen van insert:

• Op verplaatsing gebaseerde varianten voor tijdelijke waarden ([SWS_CORE_01461], [SWS_CORE_01462]),
• Positiegestuurde invoegoperaties met iterator-hint ([SWS_CORE_01463], [SWS_CORE_01464]),
• Bereik- en initialisatielijsten ([SWS_CORE_01466], [SWS_CORE_01467]) evenals node-handle-overdrachten ([SWS_CORE_01468], [SWS_CORE_01469]).

Analoge invoegoperaties zijn met aangepaste signaturen te vinden in verdere Core-klassen zoals ara::core::Vector ([SWS_CORE_01367]) en ara::core::BasicString ([SWS_CORE_03093]).

De lidfunctie insert van ara::core::Map voegt een element via move-semantiek met behulp van een rvalue-referentie (value_type &&x) synchroon in de associatieve container in ([SWS_CORE_01461]). De declaratie vindt plaats via het headerbestand #include "ara/core/map.h" ([SWS_CORE_01461]). Het functionele gedrag richt zich volgens de specificatie naar het overeenkomstige gebruik in [map] van de C++-standaard ([SWS_CORE_01461]). Als returnwaarde levert de functie een std::pair<iterator, bool> op; interpretatie: hierbij geeft de booleaanse waarde vermoedelijk aan of het element nieuw is ingevoegd, terwijl de iterator naar het element in de container verwijst ([SWS_CORE_01461]). Vraag Q-e1901e26d8be3470 (open)

Wat betreft foutafhandeling en uitzonderingsveiligheid is de functie in de specificatie expliciet geclassificeerd als not exception safe ([SWS_CORE_01461]). Specifieke foutcodes of AUTOSAR-foutmeldingen zoals DET of DEM zijn voor deze aanroep niet gespecificeerd.

In het samenspel binnen ara::core::Map vormt deze overload de op rvalues gebaseerde tegenhanger van de kopieervariant insert(const value_type &) ([SWS_CORE_01460]) en de generieke template-versie insert(P &&) ([SWS_CORE_01462]). Voor invoegbewerkingen met positieaanduiding staan bovendien overloads met hint-iterator zoals insert(const_iterator, value_type &&) ([SWS_CORE_01464]) alsook voor node-handles via insert(node_type &&) ([SWS_CORE_01468]) met gebruikmaking van insert_return_type ([SWS_CORE_01418]) ter beschikking.

De template-lidfunctie insert van de klasse ara::core::Map dient voor het synchroon invoegen van een compatibel sleutel-waardepaar via een forwarding-referentie P&& x in de associatieve containerinstantie [SWS_CORE_01462]. Deze wordt opgenomen via de header #include "ara/core/map.h" en verwijst voor het gedrag naar de semantiek van [map] [SWS_CORE_01462]. Als retourwaarde levert deze een std::pair<iterator, bool> [SWS_CORE_01462] op. Interpretatie: De booleaanse retourwaarde geeft vermoedelijk aan of er een nieuw item is aangemaakt, terwijl de iterator verwijst naar het nieuw ingevoegde of reeds bestaande element. Vraag Q-64d2947d60792374 (open)

Wat betreft de foutafhandeling is de functie in de specificatie uitdrukkelijk aangemerkt als niet uitzonderingsveilig (not exception safe) [SWS_CORE_01462]. Specifieke foutcodes, foutmeldingen of interfaces naar diagnose- en foutgeheugens zoals DET of DEM zijn voor deze aanroep niet gespecificeerd.

Wat betreft concurrency en randvoorwaarden modificeert de aanroep de toestand van de map; daarom is gelijktijdige toegang tot dezelfde instantie vermoedelijk niet re-entrant en vereist deze een externe bescherming tegen dataraces. Vraag (open) De uitvoering vindt synchroon plaats in de context van de aanroepende thread.

In de interactie binnen ara::core::Map vormt deze generieke functie een aanvulling op de directe overloads voor const value_type& [SWS_CORE_01460] en value_type&& [SWS_CORE_01461]. Daarnaast bestaan er positiegebaseerde invoegoperaties met iteratorhint [SWS_CORE_01465], bereikoperaties [SWS_CORE_01466] en het invoegen van node-handles met insert_return_type [SWS_CORE_01418] [SWS_CORE_01468].