klasse ara::core::Vector

Gebruik en aanroepcontext

De template-memberfunctie assign voor ara::core::Vector vervangt de huidige inhoud van de vector door de elementen van het bereik [first, last) conform het overeenkomstige gebruik in std::vector [SWS_CORE_01328]. De functie is gedefinieerd in het headerbestand #include "ara/core/vector.h", accepteert twee invoer-iterators en retourneert geen waarde (void) [SWS_CORE_01328].

Foutafhandeling en uitzonderingsveiligheid

De toewijzingsfunctie is geclassificeerd als niet-uitzonderingsveilig (not exception safe) [SWS_CORE_01328]. Als tijdens de elementverwerking of bij noodzakelijke interne geheugenallocaties een exceptie optreedt, blijft de container mogelijk achter in een onvolledige toestand zonder gedefinieerde veiligheidsgaranties.

Gelijktijdigheid en randvoorwaarden

Voor gelijktijdige aanroepen is bij gelijktijdig gebruik van dezelfde instantie van ara::core::Vector vermoedelijk externe synchronisatie vereist, aangezien de specificatie geen thread-safety garandeert. Vraag Q-5ada879738b3856d (open) Voorwaarde voor een foutloos verloop is bovendien dat first en last een geldig iteratorbereik overspannen.

Interactie in de module core

Naast bereiktoewijzing via iterators zijn in ara::core::Vector overloads met aantal en referentiewaarde [SWS_CORE_01329] evenals voor std::initializer_list<T> [SWS_CORE_01330] beschikbaar, die eveneens als niet-uitzonderingsveilig zijn gedeclareerd. Vergelijkbare toewijzingspatronen bestaan ook in de modulecontext van ara::core::BasicString [SWS_CORE_03091].

Gebruik

De functie assign behoort tot de containerklasse ara::core::Vector en wordt via het headerbestand #include "ara/core/vector.h" beschikbaar gesteld [SWS_CORE_01329]. Met de signatuur void assign (size_type n, const T &u); vervangt ze de huidige inhoud van de vector volledig door n elementen met de waarde u. De aanroep vindt synchroon plaats en levert geen retourwaarde op (void). Conform de specificatie richt het gedrag zich naar het corresponderende gebruik in de standaardcontainer [vector] [SWS_CORE_01329], waarmee vermoedelijk de semantiek van std::vector::assign wordt bedoeld. Vraag Q-3630162224047ee0 (open)

Foutafhandeling

Met betrekking tot betrouwbaarheid is de functie expliciet geclassificeerd als not exception safe [SWS_CORE_01329]. Er worden geen AUTOSAR-specifieke foutcodes, foutklassen of meldingen aan DET resp. DEM gedefinieerd. Treedt er tijdens de geheugenallocatie of bij het toewijzen van de elementen een uitzondering op, dan biedt de functie vermoedelijk geen garanties voor het herstel van de oorspronkelijke objecttoestand. Vraag Q-f4eb9afa74847bf7 (open)

Gelijktijdigheid en beperkingen

Aangezien assign de toestand en potentieel de capaciteit van de containerinstantie wijzigt, is de aanroep niet re-entrant op dezelfde instantie. Bij gebrek aan afzonderlijke toezeggingen omtrent thread-veiligheid in de specificatie is gelijktijdige lees- of schrijftoegang tot hetzelfde Vector-object zonder externe synchronisatie vermoedelijk niet thread-veilig. Vraag Q-1df95afd2340ec57 (open)

Samenspel

De functie vormt samen met verdere overloads van de klasse ara::core::Vector de interface voor het opnieuw toekennen van vectorinhoud:

• Iterator-gebaseerde toewijzing over een bereik assign(InputIterator first, InputIterator last) conform [SWS_CORE_01328].
• Toewijzing via een initialisatielijst assign(std::initializer_list<T>) conform [SWS_CORE_01330].

Beide alternatieve overloads delen met [SWS_CORE_01329] de eigenschap dat ze als not exception safe zijn gespecificeerd.

De memberfunctie assign van de klasse ara::core::Vector vervangt de volledige eerdere inhoud van een vectorinstantie synchroon door de elementen van de beschikbaar gestelde initialisatielijst std::initializer_list<T> ([SWS_CORE_01330]). Het functionele gedrag volgt daarbij het corresponderende gebruik van de standaardcontainer in [vector] ([SWS_CORE_01330]). De functie heeft geen retourwaarde (void) en wordt via de header ara/core/vector.h gedeclareerd ([SWS_CORE_01330]).

Voor de foutafhandeling is vastgelegd dat de methode is geclassificeerd als not exception safe ([SWS_CORE_01330]). Interpretatie: Treedt er tijdens de geheugenallocatie of bij het kopiëren c.q. verplaatsen van de elementen een uitzondering op, dan biedt de implementatie vermoedelijk geen sterke uitzonderingsveiligheid; de vector zal vermoedelijk in een gewijzigde of onvolledige toestand achterblijven. Vraag Q-ac196ecfba85d821 (open)

In het samenspel met verdere interfaces van ara::core::Vector vult de functie alternatieve toewijzingsoverloads aan, zoals de initialisatie via iterator-bereiken ([SWS_CORE_01328]) en de herhaalde toewijzing van een afzonderlijke waarde ([SWS_CORE_01329]). Al deze assign-varianten delen de eigenschap niet uitzonderingsveilig te zijn. Een vergelijkbare toewijzingssemantiek middels std::initializer_list is binnen de core-bibliotheek ook te vinden bij ara::core::BasicString ([SWS_CORE_03092]).

Gebruik en semantiek

De lidfunctie at biedt synchrone, lezende toegang tot een element van de container ara::core::Vector op de opgegeven index n en retourneert een const_reference naar het element [SWS_CORE_01354]. De declaratie is beschikbaar via de header ara/core/vector.h [SWS_CORE_01354]. De semantiek komt overeen met de standaardfunctie std::vector::at uit de C++-standaard, maar verschilt op het gebied van foutafhandeling [SWS_CORE_01354].

Foutafhandeling en randvoorwaarden

Wordt een index opgevraagd die de containergrootte bereikt of overschrijdt (n >= size()), dan wordt een IsoStdOutOfRangeViolation gegenereerd in plaats van de standaard-uitzondering std::out_of_range [SWS_CORE_01354]. De functie is gedeclareerd als not exception safe [SWS_CORE_01354]. Interpretatie: aangezien er geen C++-uitzondering wordt geworpen, leidt het genereren van de schending vermoedelijk tot een afbreking van de programmastroom, die potentieel kan interageren met afhandelingsmechanismen zoals AddAbortHandler [SWS_CORE_00054]. Vraag Q-2182d648ff4a28b8 (open)

Interactie in de module

Voor modificerende toegang staat de niet-constante overload met de returnwaarde reference ter beschikking, die hetzelfde foutpad volgt [SWS_CORE_01355]. Het identieke afwijkende gedrag met IsoStdOutOfRangeViolation is ook te vinden in andere Core-gegevenstypen zoals ara::core::Array [SWS_CORE_01273] [SWS_CORE_01274] en ara::core::BasicString [SWS_CORE_03063].

De lidfunctie at van de klasse ara::core::Vector ([SWS_CORE_01355]), beschikbaar gesteld via de header #include "ara/core/vector.h", maakt geïndiceerde lees- en schrijftoegang tot afzonderlijke elementen van een vector mogelijk. De functie accepteert een positie-index n van het type size_type en geeft een modificeerbare referentie (reference) terug naar het element op de aangegeven positie. De semantiek volgt de corresponderende implementatie in [vector]. Interpretatie: Aangezien de interface synchroon volgens de C++-standaard is gedeclareerd, vindt de uitvoering vermoedelijk blokkerend direct in de aanroepende threadcontext plaats. Vraag Q-81f43622c244ce91 (open)

In tegenstelling tot de ISO-C++-standaardvector activeert de functie bij indexoverschrijdingen (n >= size()) de overtreding IsoStdOutOfRangeViolation in plaats van de standaard-exceptie std::out_of_range ([SWS_CORE_01355]). In de specificatie is de functie geclassificeerd als niet-uitzonderingsveilig (not exception safe) ([SWS_CORE_01355]). Interpretatie: Aangezien er voor deze vectortoegang geen synchronisatiemechanismen zijn gespecificeerd, is onbeschermde gelijktijdige toegang tot dezelfde instantie vermoedelijk niet thread-safe. Vraag Q-e65ae0c574610719 (open)

Voor constante alleen-lezen-toegang staat de overbelasting const_reference at(size_type n) const ter beschikking, die eveneens IsoStdOutOfRangeViolation meldt en als niet-uitzonderingsveilig geldt ([SWS_CORE_01354]). Dezelfde overtredingssemantiek bij foutieve toegang wordt ook gebruikt door verwante containers en typen van de core-bibliotheek, waaronder ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), ara::core::StringView ([SWS_CORE_02133]) en ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).

Gebruik en semantiek

De methode clear() van de klasse ara::core::Vector dient voor het volledig leegmaken van de vector conform [SWS_CORE_01375]. De functie is gedeclareerd in header ara/core/vector.h, synchroon aanroepbaar, accepteert geen parameters en levert geen retourwaarde (void). Haar functionele semantiek richt zich naar de overeenkomstige specificatie voor [vector]. Interpretatie: Dit betekent vermoedelijk dat alle in de vector aanwezige elementen worden gedestrueerd en het aantal elementen naar 0 daalt, waarbij de toegewezen geheugencapaciteit vermoedelijk ongewijzigd behouden blijft. Vraag Q-ecde315e61455c32 (open)

Foutafhandeling en exception-veiligheid

Voor de aanroep geldt de aanduiding noexcept en de classificatie als uitzonderingsveilig (exception safe) conform [SWS_CORE_01375]. Aangezien de methode gegarandeerd geen uitzonderingen opwerpt, bestaan er geen specifieke foutcodes en worden er in geval van fouten noch DET- noch DEM-foutmeldingen verstuurd.

Interactie met verwante containers

Het concept van een uitzonderingsveilige clear()-functie wordt in ara::core consistent overgedragen op andere datastructuren. Zo stelt ara::core::Map in header ara/core/map.h een identieke clear()-methode conform [map] beschikbaar [SWS_CORE_01485]. Evenzo biedt ara::core::BasicString in header ara/core/string.h een gelijkwaardige clear()-operatie conform [basic.string] aan [SWS_CORE_03057].

De lidfunctie crbegin van ara::core::Vector stelt conform [SWS_CORE_01342] een constante reverse-iterator (const_reverse_iterator) naar het laatste element van de reeks beschikbaar. De aanroep vindt synchroon en parameterloos plaats via de header ara/core/vector.h. Het gedrag komt overeen met de specificatie van de onderliggende standaard C++-bibliotheek voor [vector]. Bij een lege container zal de geretourneerde iterator vermoedelijk overeenkomen met de waarde van crend() (interpretatie gebaseerd op [vector]). Vraag Q-a2badba87f86486c (open)

Wat betreft de foutafhandeling is de interface voorzien van de identifier noexcept en gedeclareerd als uitzonderingsveilig (exception safe) ([SWS_CORE_01342]). Aanroepen werpen geen uitzonderingen en melden geen fouten aan runtime- of diagnosebewakingen.

Wat betreft concurrency en beperkingen is de methode gekwalificeerd als const. Gelijktijdige leestoegang tot dezelfde instantie vanuit meerdere threads is vermoedelijk re-entrant en thread-safe, zolang er geen concurrerende schrijfoperaties op de vector worden uitgevoerd (interpretatie analoog aan het C++-containermodel). Vraag Q-094ba5878c1adc74 (open)

In module core is het concept van constante achterwaartse iteratie consistent geïmplementeerd over verschillende typen heen. Vergelijkbare interfaces zijn te vinden bij ara::core::Array ([SWS_CORE_01260]), ara::core::Map ([SWS_CORE_01450]), ara::core::Span ([SWS_CORE_01978]), ara::core::StringView ([SWS_CORE_02126]) en ara::core::BasicString ([SWS_CORE_03049]).

De lidfunctie crend van de klasse ara::core::Vector stelt een constante reverse-iterator beschikbaar, die verwijst naar het theoretische element vóór het eerste element van de vector [SWS_CORE_01343]. De semantiek volgt het overeenkomstige gebruik in de C++-standaard voor std::vector (“As per corresponding usage in [vector]”) [SWS_CORE_01343].

Gebruik en gedrag

• Aanroepcontext en parameters: De methode is parameterloos en gedeclareerd als const, zodat deze synchroon kan worden aangeroepen op zowel constante als niet-constante instanties van ara::core::Vector [SWS_CORE_01343].
• Retourwaarde: Er wordt een const_reverse_iterator geretourneerd die het logische einde van een achterwaartse iteratie markeert [SWS_CORE_01343].

Foutafhandeling en exception-veiligheid

De functie is gespecificeerd met noexcept en geldt volgens de specificatie als uitzonderingsveilig (“exception safe”) [SWS_CORE_01343]. Er worden geen specifieke foutcodes geretourneerd en er treden geen exceptions op.

Interactie met verwante containers

Het concept van een constante reverse-iterator naar het eindpunt van een achterwaartse iteratie wordt containeroverstijgend uniform beschikbaar gesteld in ara::core. Vergelijkbare interfaces met identieke foutafhandeling (noexcept) bestaan onder andere voor ara::core::Array [SWS_CORE_01261], ara::core::Map [SWS_CORE_01451], ara::core::Span [SWS_CORE_01979], ara::core::StringView [SWS_CORE_02127] en ara::core::BasicString [SWS_CORE_03050].

De functie emplace voegt een element op de opgegeven positie direct in een ara::core::Vector in door meegegeven argumenten door te sturen [SWS_CORE_01366]. De declaratie bevindt zich in de header #include "ara/core/vector.h" en volgt het overeenkomstige gebruik in [vector] [SWS_CORE_01366].

Gebruik

De aanroep van emplace vindt synchroon plaats en accepteert als parameters een positie-iterator position van het type const_iterator en een parameterpakket args van het type Args&&... [SWS_CORE_01366]. Als returnwaarde levert de functie een iterator op naar het nieuw geconstrueerde element [SWS_CORE_01366].

Foutafhandeling en gelijktijdigheid

Voor emplace in ara::core::Vector is de uitzonderingsveiligheid expliciet gespecificeerd als not exception safe [SWS_CORE_01366]. Specifieke foutcodes, DET- of DEM-meldingen zijn in de standaard niet gedefinieerd. Interpretatie: bij gebrek aan interne synchronisatiemechanismen is de gelijktijdige aanroep van emplace op dezelfde instantie zonder externe beveiliging vermoedelijk niet thread-safe. Vraag Q-d72278df37e86c8a (open)

Samenspel

Binnen ara::core varieert de uitzonderingsveiligheid voor emplace afhankelijk van het type:

• In ara::core::Map is emplace eveneens gedefinieerd als not exception safe, maar retourneert std::pair<iterator, bool> [SWS_CORE_01458].
• In ara::core::Optional zijn de varianten voorwaardelijk uitzonderingsveilig ([SWS_CORE_01119], [SWS_CORE_01120]) respectievelijk voor referenties volledig uitzonderingsveilig [SWS_CORE_01164].
• In ara::core::Variant is emplace gedeclareerd als conditionally exception safe met noexcept ([SWS_CORE_01661], [SWS_CORE_01662], [SWS_CORE_01663], [SWS_CORE_01664]).

Gebruik

De templatemethode emplace_back van de klasse ara::core::Vector dient conform [SWS_CORE_01362] om een nieuw element direct aan het einde van de vector te construeren. De doorgegeven parameters Args&&... args worden daarbij overeenkomstig de semantiek van [vector] direct doorgestuurd naar de constructor van het elementtype. Als retourwaarde levert de functie een referentie (reference) naar het nieuw aangemaakte element op. Voor gebruik moet de header #include "ara/core/vector.h" worden geïncludeerd [SWS_CORE_01362].

Foutafhandeling en exception-veiligheid

Wat betreft uitzonderingsveiligheid is de operatie in [SWS_CORE_01362] expliciet gedeclareerd als not exception safe. Specifieke foutcodes, fallback-waarden of meldingen aan foutdiensten zoals DET of DEM worden in de specificatie niet gedefinieerd.

Beperkingen en gedrag

Vanwege de eigenschap not exception safe en het aansluiten bij [vector] bestaat er in geval van een fout, bijvoorbeeld bij een falende geheugenallocatie of constructie, vermoedelijk geen garantie voor het behoud van de eerdere containertoestand (interpretatie). Vraag Q-ca44b2f27d8ae1c8 (open) Aanroepers moeten daarom waarborgen dat mogelijke foutcondities vooraf worden vermeden.

De functie erase van de klasse ara::core::Vector dient conform [SWS_CORE_01372] voor het synchroon verwijderen van een afzonderlijk element op de door de parameter position (const_iterator) aangeduide positie. Als retourwaarde levert deze een iterator naar het volgende element respectievelijk het container-einde op, indien het verwijderde element op de laatste positie stond, overeenkomstig de gerefereerde semantiek in [vector]. De functie is gedeclareerd in het headerbestand #include "ara/core/vector.h".

Met betrekking tot foutafhandeling is de operatie in de specificatie uitdrukkelijk aangeduid als niet uitzonderingsveilig (“not exception safe”) [SWS_CORE_01372]. Er zijn geen specifieke foutretouren, DET- of DEM-meldingen gedefinieerd; ongeldige of niet-derefereerbare iterators zullen daarom vermoedelijk leiden tot ongedefinieerd gedrag. Vraag Q-efa4c40e48a6f98d (open) Door het verschuiven van de elementen in de vector is als interpretatie: aan te nemen dat opvolgende iterators en referenties ongeldig worden, zoals overeenkomt met de standaardsemantiek van [vector].

In de interactie binnen ara::core::Vector bestaat naast het verwijderen op een afzonderlijke positie de overload erase(first, last) voor volledige bereiken conform [SWS_CORE_01373]. Analoge interfaces voor het verwijderen van items zijn te vinden in andere containers van de Adaptive-Core-bibliotheek: ara::core::Map stelt positie- en sleutelgebaseerde overloads beschikbaar ([SWS_CORE_01480], [SWS_CORE_01481], [SWS_CORE_01482], [SWS_CORE_01483]), terwijl ara::core::BasicString index- en iteratorgebaseerde varianten omvat ([SWS_CORE_03102], [SWS_CORE_03103], [SWS_CORE_03104]).

De lidfunctie erase van de klasse ara::core::Vector dient voor het verwijderen van een bereik van elementen uit de vector conform de specificatie [SWS_CORE_01373]. De declaratie is beschikbaar via de header ara/core/vector.h. De semantiek volgt het overeenkomstige gebruik in de standaardvector (“As per corresponding usage in [vector]”). Als parameters worden twee iterators first en last doorgegeven, die het te verwijderen bereik afbakenen; er wordt een iterator naar het volgende element geretourneerd.

Wat betreft foutafhandeling en uitzonderingsveiligheid is de operatie in de specificatie expliciet geclassificeerd als “not exception safe” [SWS_CORE_01373]. Specifieke foutcodes of foutschendingen (violations) zijn voor deze functie, in tegenstelling tot andere containeroperaties, niet gedefinieerd. Mocht er tijdens de uitvoering een fout optreden, dan laat dit de container vermoedelijk achter in een inconsistente toestand. Vraag (open)

Wat betreft concurrency en beperkingen zwijgt de specificatie; modificerende operaties op ara::core::Vector zijn echter vermoedelijk niet re-entrant en vereisen bij multithreaded werking naar verwachting een externe beveiliging. Vraag Q-07fc291a523a82f1 (open)

In de interactie met andere interfaces van de Core-module vormt deze functie een aanvulling op de overload voor het verwijderen van een afzonderlijk element op een bepaalde positie met iterator erase(const_iterator position) [SWS_CORE_01372]. Overeenkomstige bereikverwijderingen volgens hetzelfde patroon zijn ook gedefinieerd voor associatieve containers zoals ara::core::Map via [SWS_CORE_01483] en tekenreeksen in ara::core::BasicString via [SWS_CORE_03104].

Gebruik

De lidfunctie insert van de klasse ara::core::Vector dient voor het synchroon invoegen van een element op een vooraf opgegeven positie [SWS_CORE_01367]. Deze is gedefinieerd in de header #include "ara/core/vector.h" [SWS_CORE_01367]. De functie accepteert als parameter een iterator position van het type const_iterator, die de doelpositie markeert, evenals een constante referentie x naar het in te voegen object van het type const T & [SWS_CORE_01367]. De retourwaarde is een iterator, die verwijst naar het nieuw ingevoegde element [SWS_CORE_01367]. Het functionele gedrag richt zich daarbij naar het gebruik in de standaardvector („As per corresponding usage in [vector]”) [SWS_CORE_01367].

Foutafhandeling en beperkingen

De specificatie classificeert de functie uitdrukkelijk als niet-uitzonderingsveilig („not exception safe”) [SWS_CORE_01367]. Specifieke foutcodes, retourwaarden voor foutgevallen of meldingen aan DET of DEM zijn niet gedefinieerd. Interpretatie: mislukt een interne geheugenallocatie of het kopiëren van het element, dan geldt vermoedelijk geen garantie voor het behoud van de containertoestand of de geldigheid van iterators. Vraag Q-d2b5552bb124d16e (open)

Samenspel

Binnen ara::core::Vector bestaan meerdere overbelastingen van insert die alternatieve invoegoperaties mogelijk maken:

• Invoegen van een element via een rvalue-referentie T &&x [SWS_CORE_01368],
• Invoegen van een bepaald aantal identieke elementen met size_type n, const T &x [SWS_CORE_01369],
• Invoegen van een sequentie via een iteratorbereik [first, last) [SWS_CORE_01370],
• Invoegen via een initialisatielijst std::initializer_list<T> [SWS_CORE_01371].

Analoge insert-methoden worden in de module core ook gedefinieerd door associatieve containers zoals ara::core::Map [SWS_CORE_01460] en tekenreeksklassen zoals ara::core::BasicString [SWS_CORE_03093].

Gebruik

De methode insert conform [SWS_CORE_01368] is in de header #include "ara/core/vector.h" gedefinieerd als lidfunctie van de klasse ara::core::Vector. Deze dient voor het synchroon invoegen van een element via een rvalue-referentie (T&& x) op de positie vóór de iterator position. Conform de verwijzing naar [vector] draagt de functie vermoedelijk de inhoud van x via move-semantiek over naar de vector en retourneert deze een iterator naar het nieuw ingevoegde element. Vraag Q-97f2551da8fd303f (open)

Foutafhandeling en beperkingen

De specificatie classificeert de functie in [SWS_CORE_01368] als not exception safe. Specifieke foutcodes, returnwaarden voor foutindicatie of meldingen aan DET of DEM zijn niet gedefinieerd. Interpretatie: als een interne geheugenallocatie of het verplaatsen van de elementen mislukt, is uitzonderingsveiligheid vermoedelijk niet gegarandeerd, wat de container in een inconsistente toestand kan achterlaten of tot afbreking kan leiden. Vraag Q-297ef8ff6f6eb76b (open) Bovendien bestaat er vermoedelijk geen interne bescherming tegen concurrency, waardoor gelijktijdige toegangen extern moeten worden gesynchroniseerd.

Samenspel

De rvalue-variant [SWS_CORE_01368] vormt samen met andere insert-overloads van ara::core::Vector een samenhangende interface:

• [SWS_CORE_01367]: Kopiërend invoegen van een waarde door middel van een lvalue-referentie (const T& x).
• [SWS_CORE_01369]: Invoegen van n kopieën van een waarde (size_type n, const T& x).
• [SWS_CORE_01370]: Invoegen van een sequentie via een iteratorbereik (InputIterator first, InputIterator last).
• [SWS_CORE_01371]: Invoegen van een lijst door middel van std::initializer_list<T>.

De elementfunctie insert uit [SWS_CORE_01369] behoort tot de klasse ara::core::Vector en wordt beschikbaar gesteld via het headerbestand #include "ara/core/vector.h". De synchrone bewerking dient voor het invoegen van meerdere identieke elementen. Interpretatie: conform de gespecificeerde verwijzing „As per corresponding usage in [vector]” voegt de aanroep vermoedelijk precies n kopieën van de overgedragen waarde x direct vóór de iteratorpositie position in de vector in en retourneert deze een iterator naar het eerste nieuw ingevoegde element. Vraag Q-c92add148c490868 (open)

Wat betreft de foutafhandeling en robuustheid is de functie in [SWS_CORE_01369] uitdrukkelijk geclassificeerd als „not exception safe”. Specifieke AUTOSAR-foutcodes of meldingen aan DET of DEM zijn voor deze methode-aanroep niet voorzien.

Over de concurrency- en aanroepvoorwaarden bevat de specificatie geen afzonderlijke garanties. Vermoedelijk vereist de wijziging van de container net als bij standaardvectoren een externe synchronisatie, aangezien gelijktijdige schrijf- of leestoegangen niet thread-safe zijn. Vraag (open)

Binnen ara::core::Vector bestaan naast deze overbelasting voor herhaalde waarden nog andere varianten van insert:

• invoegen van een enkele waarde per kopie ([SWS_CORE_01367]) of per move-semantiek ([SWS_CORE_01368]).
• invoegen van een waardebereik via input-iterators ([SWS_CORE_01370]) of via een std::initializer_list ([SWS_CORE_01371]).

De template-elementfunctie insert van de sequentiële container ara::core::Vector ([SWS_CORE_01370]) uit de header #include "ara/core/vector.h" voegt een reeks elementen synchroon in de vector in. Het in te voegen bereik wordt bepaald via de invoer-iterators first en last en direct vóór de door position (type const_iterator) aangeduide positie geplaatst. Als retourwaarde levert de functie een iterator op, die verwijst naar het eerste ingevoegde element. De functionele semantiek wordt specificatiezijdig beschreven met „As per corresponding usage in [vector]” ([SWS_CORE_01370]); Interpretatie: dit komt vermoedelijk overeen met het gestandaardiseerde bereik-invoeggedrag van std::vector. Vraag Q-c6cd06fb1964ead6 (open)

Wat betreft foutafhandeling en robuustheid is de functie uitdrukkelijk gespecificeerd als not exception safe ([SWS_CORE_01370]). Bijzondere foutcodes, uitzonderingen of meldingen aan fout- en diagnosemonitoren (zoals DET of DEM) zijn in de specificatieomvang niet voorzien.

Binnen de interface van ara::core::Vector vormt deze bereikoverbelasting een aanvulling op de overige invoegmethoden:

• het invoegen van een enkele waarde per kopie ([SWS_CORE_01367]) of per move-semantiek ([SWS_CORE_01368]),
• het invoegen van een vastgelegd aantal identieke waarden ([SWS_CORE_01369]),
• evenals het invoegen vanuit een initialisatielijst via std::initializer_list ([SWS_CORE_01371]).

Alle genoemde overbelastingen binnen de vector delen de beperking niet-uitzonderingsveilig te zijn ([SWS_CORE_01367], [SWS_CORE_01371]).

De synchrone memberfunctie insert van de klasse ara::core::Vector voegt de elementen van een initialisatielijst op een vooraf bepaalde positie in de container in [SWS_CORE_01371]. Deze is gedeclareerd in het headerbestand ara/core/vector.h [SWS_CORE_01371]. Als parameter verwacht de functie een iterator position van het type const_iterator, die de invoegpositie markeert, alsmede il van het type std::initializer_list<T> [SWS_CORE_01371]. De retourwaarde is een iterator naar het eerste ingevoegde element respectievelijk naar position als de lijst leeg is [SWS_CORE_01371].

Wat betreft de foutafhandeling en robuustheid classificeert de specificatie deze operatie expliciet als „not exception safe” [SWS_CORE_01371]. Specifieke AUTOSAR-foutcodes of foutmeldingen (DET/DEM) zijn niet voorzien. Interpretatie: door de verwijzing „As per corresponding usage in [vector]” komt het runtimegedrag, inclusief mogelijke herallocaties en het daarmee gepaard gaande ongeldig worden van bestaande iterators, vermoedelijk overeen met de semantiek van std::vector::insert [SWS_CORE_01371]. Vraag Q-67ac8e3de4d4ce7a (open) Bijzondere synchronisatiemechanismen voor gelijktijdige toegangen zijn niet gespecificeerd.

In de module core staat de functie in de context van verdere invoegbewerkingen van ara::core::Vector:

• Invoegen van een enkel element door kopiëren [SWS_CORE_01367] of move-semantiek [SWS_CORE_01368],
• Invoegen van n kopieën van een waarde [SWS_CORE_01369],
• Bereikgebaseerd invoegen via twee invoer-iterators [SWS_CORE_01370].

Alle overbelastingen in ara::core::Vector delen de eigenschap niet uitzonderingsveilig te zijn [SWS_CORE_01367], [SWS_CORE_01368], [SWS_CORE_01369], [SWS_CORE_01370].

Gebruik en semantiek

De memberfunctie pop_back van de container ara::core::Vector dient voor het synchroon verwijderen van het laatste element [SWS_CORE_01365]. De functie is gedeclareerd in het headerbestand ara/core/vector.h en heeft de signatuur void pop_back () [SWS_CORE_01365]. AUTOSAR verwijst voor het functionele gedrag expliciet naar het overeenkomstige gebruik in [vector], zodat er geen parameters worden meegegeven en er geen retourwaarde bestaat [SWS_CORE_01365].

Foutafhandeling en exception-veiligheid

Wat betreft foutafhandeling kent de specificatie de eigenschap not exception safe toe [SWS_CORE_01365]. Omdat er geen specifieke foutcodes, retourwaarden of controlemechanismen in de payload zijn gedefinieerd, bestaat er geen geïntegreerde foutafhandeling bij ongeoorloofde aanroepen [SWS_CORE_01365]. Interpretatie: Vóór de aanroep moet de aanroeper verifiëren dat de vector niet leeg is; een aanroep op een lege instantie leidt analoog aan [vector] vermoedelijk tot ongedefinieerd gedrag. Vraag Q-add313a489db4726 (open)

Samenspel en verwante eisen

Een corresponderend patroon is te vinden in de klasse ara::core::BasicString uit ara/core/string.h, waarvan de functie pop_back het laatste teken conform [basic.string] verwijdert en eveneens is gespecificeerd als not exception safe [SWS_CORE_03105]. Beide definities harmoniseren de modificatie van sequentiële datastructuren in de module core [SWS_CORE_01365], [SWS_CORE_03105].

Gebruik

De memberfunctie push_back in de scope van ara::core::Vector voegt een meegegeven element door kopiëren in aan het einde van de container [SWS_CORE_01363]. Deze is gedefinieerd via de header #include "ara/core/vector.h", accepteert een referentie naar een constante waarde const T &x en heeft geen retourwaarde (void) [SWS_CORE_01363]. De aanroep geschiedt synchroon in de context van de aanroeper.

Foutafhandeling en uitzonderingsveiligheid

De specificatie wijkt af van [vector] doordat de functie als voorwaardelijk noexcept is gedeclareerd: deze is dan en slechts dan gegarandeerd niet-werpend wanneer std::is_nothrow_copy_assignable<T>::value van toepassing is [SWS_CORE_01363]. Dienovereenkomstig is de uitzonderingsveiligheid gedefinieerd als „conditionally exception safe” [SWS_CORE_01363]. Specifieke foutcodes en foutmeldingen via DET of DEM zijn voor deze functie niet gedefinieerd.

Samenspel en verwante eisen

Voor verplaatsbare objecten stelt ara::core::Vector de overload void push_back(T &&x) beschikbaar, waarvan de noexcept-eigenschap analoog is gekoppeld aan std::is_nothrow_move_assignable<T>::value [SWS_CORE_01364]. Daarentegen heeft push_back in ara::core::BasicString geen noexcept-garantie en is deze geclassificeerd als „not exception safe” [SWS_CORE_03083].

Interpretatie: Het interne geheugen- en herallocatiegedrag bij het invoegen zal zich, afgezien van de specifieke noexcept-declaratie, naar verwachting oriënteren op de vereisten van de C++-standaard voor [vector]. Vraag Q-202fb07b334cde64 (open)

De memberfunctie push_back van ara::core::Vector dient voor het synchroon toevoegen van een element aan het einde van de vector met gebruikmaking van move-semantiek ([SWS_CORE_01364]). Deze wordt beschikbaar gesteld via de header #include "ara/core/vector.h", accepteert een rvalue-referentie T &&x en heeft geen retourwaarde (void) ([SWS_CORE_01364]).

Wat betreft foutafhandeling en uitzonderingsgedrag gelden de volgende eigenschappen:

• De methode is geclassificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) ([SWS_CORE_01364]).
• De noexcept-garantie is gebonden aan het type: noexcept(std::is_nothrow_move_assignable<T>::value) ([SWS_CORE_01364]). Als de move-toekenningsoperator van T niet als uitzonderingsvrij is gedeclareerd, treden vermoedelijk bij geheugenallocaties of elementverplaatsingen uitzonderingen op. Vraag Q-3b8b58d0b218fe21 (open)

De werking volgt de gebruikelijke semantiek in [vector], maar wijkt af door de voorwaardelijke noexcept-declaratie ([SWS_CORE_01364]). Aangezien de operatie de container muteert, zijn gelijktijdige toegangen tot dezelfde instantie zonder externe synchronisatie vermoedelijk niet thread-safe. Vraag (open)

In het samenspel van de interfaces vult deze move-variant de copy-overload push_back(const T &x) ([SWS_CORE_01363]) aan, die analoog is gekoppeld aan is_nothrow_copy_assignable. Hiervan moet de gelijknamige memberfunctie in ara::core::BasicString ([SWS_CORE_03083]) worden onderscheiden, die individuele tekens toevoegt en is gedefinieerd als niet-uitzonderingsveilig.