klasse ara::core::Bitset

De memberfunctie [SWS_CORE_01744] behoort tot de klasse ara::core::Bitset en wordt beschikbaar gesteld via het headerbestand #include "ara/core/bitset.h". De functie heeft de signatuur bool all () const noexcept;, accepteert geen parameters en levert synchroon een waarheidswaarde terug. De semantiek is volgens de specificatie ontleend aan het overeenkomstige gebruik in [bitset]; interpretatie: de methode controleert vermoedelijk of alle bits van de instantie gezet zijn (de waarde true hebben). Vraag Q-a4f0f8970bd2c9bb (open)

Wat betreft foutafhandeling is de functie gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_01744]. Aangezien er geen fouttoestanden worden gemeld en de uitvoering gegarandeerd foutloos verloopt, zijn foutcodes uit ara::core::CoreErrc hier niet van toepassing.

Voor de aanroepcontext en gelijktijdigheid gelden de volgende randvoorwaarden:

• De bewerking is gedeclareerd als const en wijzigt de toestand van het aanroepende ara::core::Bitset-object niet [SWS_CORE_01744].
• Gelijktijdige leestoegangen via meerdere threads zijn vermoedelijk zonder synchronisatie toegestaan, zolang geen andere thread hetzelfde geheugengebied schrijvend wijzigt. Vraag Q-d9f1f92a120128b5 (open)

De memberfunctie any() van ara::core::Bitset dient voor het synchroon opvragen van de bezettingstoestand van de in de bitset beheerde bits [SWS_CORE_01745]. Het gedrag richt zich volgens de specificatie naar het corresponderende gebruik van het ISO-C++-klassentemplate [bitset] [SWS_CORE_01745]. Interpretatie: De functie levert true op mits ten minste één bit gezet is, en false wanneer alle bits niet gezet zijn. Vraag Q-20c2aaf905d4a338 (open)

Wat betreft gebruik, uitvoeringscontext en foutgedrag gelden de volgende bepalingen:

• Aanroep en parameters: De methode wordt parameterloos aangeroepen op een bestaande instantie, die bijvoorbeeld vooraf via de constructor is geïnitialiseerd [SWS_CORE_01749]. De aanroep vindt synchroon plaats en geeft het controleresultaat direct terug als bool [SWS_CORE_01745].
• Foutafhandeling: De functie is gedeclareerd als noexcept en geclassificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_01745]. Er worden noch foutcodes noch DET-/DEM-meldingen gegenereerd; het mislukken van de bewerking is in de AUTOSAR-standaard niet voorzien.
• Gelijktijdigheid: Door de const-kwalificatie wijzigt de methode de instantie niet [SWS_CORE_01745]. Vermoedelijk zijn parallelle leestoegangen tot dezelfde instantie veilig, terwijl concurrerende schrijftoegangen door de aanroeper moeten worden gesynchroniseerd. Vraag Q-34893675aa85baf1 (open)

In de modulecontext van core biedt any() een elementaire inspectiefunctie voor bitsets, die naadloos samenwerkt met de initialisatie- en opslagmechanismen van ara::core::Bitset [SWS_CORE_01745], [SWS_CORE_01749].

Gebruik en semantiek

De memberfunctie count wordt synchroon en parameterloos aangeroepen op een instantie van ara::core::Bitset ([SWS_CORE_01740]). Deze is gedeclareerd in de header #include "ara/core/bitset.h" en levert het telresultaat op als retourwaarde van het type std::size_t ([SWS_CORE_01740]). Het functionele gedrag richt zich naar de referentie [bitset] ([SWS_CORE_01740]); de waarde komt daarom vermoedelijk overeen met het totale aantal gezette bits. Vraag Q-36c593b234f55695 (open)

Foutafhandeling en gelijktijdigheid

De functie is gespecificeerd als noexcept en geldt als exception safe ([SWS_CORE_01740]). Er worden geen exceptions geactiveerd noch foutcodes geretourneerd, en meldingen aan DET of DEM zijn voor dit element niet voorzien. Aangezien count is gedeclareerd als constante memberfunctie (const) ([SWS_CORE_01740]), wijzigt de aanroep de toestand van het object niet. Parallelle leestoegangen tot dezelfde instantie zijn derhalve vermoedelijk gelijktijdig uitvoerbaar, mits er geen conflicterende schrijftoegangen plaatsvinden. Vraag Q-073bc3bbcb918763 (open)

Interactie en afbakening

In de namespace ara::core dient de functie duidelijk te worden gescheiden van andere elementen:

• In ara::core::Map dient count voor het bepalen van aanwezige sleutels ([SWS_CORE_01494], [SWS_CORE_01495]), maar is geclassificeerd als not exception safe.
• In ara::core::Span en de factory-functie ara::core::MakeSpan duidt count niet op een methodenaam, maar op een formele parameter voor het beperken van elementbereiken ([SWS_CORE_01942], [SWS_CORE_01962], [SWS_CORE_01964], [SWS_CORE_01966], [SWS_CORE_01990]).

Gebruik

De lidfunctie flip() van de klasse ara::core::Bitset inverteert synchroon de toestand van alle bits van de instantie volgens het gedrag van [bitset] [SWS_CORE_01730]. De functie wordt via de header #include "ara/core/bitset.h" aangeboden, accepteert geen parameters en retourneert een lvalue-referentie naar het gemodificeerde object (Bitset<N>&), wat het aaneenschakelen van bewerkingen mogelijk maakt [SWS_CORE_01730].

Foutafhandeling en exception-veiligheid

De functie is gedeclareerd als noexcept en gespecificeerd als uitzonderingsveilig („exception safe”) [SWS_CORE_01730]. Er worden noch C++-excepties geworpen, noch foutcodes geretourneerd; de uitvoering zal daarom vermoedelijk altijd foutloos verlopen. Vraag Q-df762b6329a2c0d4 (open)

Samenspel

De module core definieert verwante varianten voor bitmanipulatie:

• De overbelaste methode flip(std::size_t pos) dient voor het doelgericht inverteren van een afzonderlijke bit op index pos [SWS_CORE_01731]. In tegenstelling tot de parameterloze vorm retourneert deze een Result<Bitset<N>&> en signaleert ongeldige posities via IsoStdOutOfRangeViolation [SWS_CORE_01731].
• Via de referentieklasse ara::core::Bitset<N>::reference is de lidfunctie flip() beschikbaar om een afzonderlijke gereferentieerde bit te inverteren en een reference& te retourneren [SWS_CORE_01712].

De lidfunctie flip van de klasse ara::core::Bitset inverteert synchroon de toestand van de bit op de doorgegeven positie pos [SWS_CORE_01731]. Deze is gedefinieerd in header #include "ara/core/bitset.h" en baseert zich op het gedrag van std::bitset::flip, maar vertoont specifieke functionele afwijkingen [SWS_CORE_01731].

De functie is gedeclareerd als noexcept alsook exception safe en retourneert bij succes een referentie naar de gemodificeerde bitset binnen een Result<Bitset<N>&> [SWS_CORE_01731]. Als de parameter pos niet overeenkomt met een geldige bitpositie, wordt in plaats van een C++-exceptie zoals std::out_of_range de schending IsoStdOutOfRangeViolation geactiveerd [SWS_CORE_01731].

Met betrekking tot gelijktijdigheid mag worden aangenomen dat gelijktijdige aanroepen op dezelfde bitset-instantie bij gebrek aan gedocumenteerde synchronisatie niet thread-safe zijn en extern moeten worden gecoördineerd. Vraag Q-de73bb65d6aab12c (open)

In de module core vult de functie verdere verwante bewerkingen aan: voor het synchroon inverteren van alle bits van een instantie is de parameterloze overloading flip() beschikbaar [SWS_CORE_01730], terwijl voor bit-referentieobjecten de methode ara::core::Bitset::reference::flip() ter beschikking staat [SWS_CORE_01712].

Gebruik

De memberfunctie none van de klasse ara::core::Bitset dient voor het opvragen van de bezettingstoestand van de bitreeks [SWS_CORE_01746]. De methode vereist het invoegen van de header ara/core/bitset.h en heeft de signatuur bool none () const noexcept; [SWS_CORE_01746]. De aanroep geschiedt synchroon en parameterloos op een bestaande instantie. De specificatie verwijst wat betreft gedrag naar het overeenkomstige gebruik in [bitset] [SWS_CORE_01746]; interpretatie: de methode levert vermoedelijk precies dan true terug wanneer geen enkel bit binnen de bitreeks gezet is (oftewel alle bits false zijn), anders false. Vraag Q-de8593251c7748d5 (open)

Foutafhandeling en exception-veiligheid

Voor none zijn noch foutcodes noch afzonderlijke fouttoestanden gedefinieerd. Volgens de specificatie is de functie gedeclareerd als noexcept en heeft deze de classificatie uitzonderingsveilig (exception safe) [SWS_CORE_01746]. In geval van fouten of tijdens de uitvoering treden zodoende geen C++-exceptions op.

Gelijktijdigheid en beperkingen

Aangezien none gedeclareerd is als const [SWS_CORE_01746], wijzigt de methode-aanroep de interne toestand van het object niet. Parallelle lezende aanroepen op hetzelfde Bitset-object zijn daarom vermoedelijk gelijktijdig niet-kritiek en re-entrant, mits er geen gelijktijdige schrijvende modificaties op dezelfde instantie plaatsvinden. Vraag Q-cf92e9abf57e9678 (open)

De elementfunctie reset() stelt conform specificatie [SWS_CORE_01727] de toestand van een instantie van ara::core::Bitset opnieuw in. De functie wordt beschikbaar gesteld via het headerbestand #include "ara/core/bitset.h" en heeft de signatuur Bitset<N>& reset() noexcept;.

Gebruik en semantiek

De functie accepteert geen parameters en werkt synchroon op het aanroepende object. Door de gespecificeerde verwijzing naar het gebruikelijke gebruik in [bitset] stelt de aanroep vermoedelijk alle aanwezige bits opnieuw in op false (resp. 0) en retourneert deze een referentie naar de eigen bitset-instantie (*this), wat methodeketens mogelijk maakt. Vraag Q-89116316a65e0772 (open)

Foutafhandeling en uitzonderingsveiligheid

Conform [SWS_CORE_01727] is de functie gedeclareerd als noexcept en bezit deze de classificatie „exception safe”. Aangezien er in tegenstelling tot de geparametriseerde overload geen indexcontrole vereist is, treden er bij de parameterloze variant geen fouttoestanden of foutcodes op.

Interactie en afbakening

• Binnen hetzelfde geldigheidsbereik ara::core::Bitset bestaat de overload reset(std::size_t pos) volgens [SWS_CORE_01728]. Deze stelt gericht één enkele bit opnieuw in, maar levert een Result<Bitset<N>&> op en meldt een IsoStdOutOfRangeViolation als pos ongeldig is.
• Functies met dezelfde naam bestaan in de module core ook voor ara::core::Optional conform [SWS_CORE_01136] en ara::core::Optional<T&> conform [SWS_CORE_01165] uit #include "ara/core/optional.h", die de aanwezige waarde verwerpen en het retourtype void vertonen.

De elementfunctie reset van de klasse ara::core::Bitset stelt een enkele bit op de opgegeven positie pos synchroon opnieuw in op de waarde 0 [SWS_CORE_01728]. De functie volgt het gedrag van std::bitset, maar vertoont twee wezenlijke afwijkingen: deze is gedeclareerd als noexcept en retourneert het resultaat in een Result<Bitset<N>&> om foutsituaties zonder C++-excepties weer te geven [SWS_CORE_01728].

Foutafhandeling

Indien de doorgegeven index pos met geen enkele geldige bitpositie binnen de bitset overeenkomt, wordt in plaats van std::out_of_range de schending IsoStdOutOfRangeViolation gegenereerd [SWS_CORE_01728]. Deze wordt in geval van een fout als fouttoestand beschikbaar gesteld in het geretourneerde Result-object, zodat de operatie ondanks een ongeldige parameterwaarde exceptieveilig blijft [SWS_CORE_01728].

Interactie en afbakening

In module core bestaat voor ara::core::Bitset ter aanvulling de parameterloze overload reset(), die alle bits van de container tegelijk wist en direct een referentie naar het object oplevert [SWS_CORE_01727]. Bovendien definiëren de verwante eisen [SWS_CORE_01136] en [SWS_CORE_01165] een methode met dezelfde naam voor ara::core::Optional, die aldaar de aanwezige waarde verwijdert.

Concurrency

Aangezien reset de interne toestand van de bitset wijzigt, is een gelijktijdige aanroep op dezelfde instantie zonder externe synchronisatie vermoedelijk niet thread-safe (interpretatie: overname van de gebruikelijke C++-containersemantiek). Vraag Q-e2e1c041eadedf0f (open)

De synchrone lidfunctie set() van de klasse ara::core::Bitset zet alle aanwezige bits van het object op de waarde true ([SWS_CORE_01725]). Qua gedrag komt zij overeen met de werking van std::bitset uit de ISO-C++-standaard en is beschikbaar via de header ara/core/bitset.h ([SWS_CORE_01725]). De methode-aanroep is parameterloos en retourneert een lvalue-referentie naar de gewijzigde bitset (Bitset<N>&) ([SWS_CORE_01725]), wat een directe ketening van verdere aanroepen op dezelfde instantie mogelijk maakt.

De operatie is gedeclareerd als noexcept en heeft de eigenschap exception safe ([SWS_CORE_01725]). Aangezien zij over alle bits itereert resp. de algehele toestand instelt, treden er in tegenstelling tot positiegebaseerde toegangen geen bereikfouten op. Over thread-safety doet de specificatie geen uitspraak; Interpretatie: aangezien de toestand van het object direct wordt gemuteerd, zijn gelijktijdige toegangen tot dezelfde Bitset-instantie zonder externe beveiliging vermoedelijk niet concurrency- resp. thread-safe. Vraag Q-f8c1b5721f668193 (open)

In de wisselwerking binnen de module core vult de functie de overladen variant set(std::size_t, bool) aan ([SWS_CORE_01726]). Terwijl de parameterloze versie gegarandeerd met succes het gehele veld instelt, wijzigt de geparametriseerde versie gericht een afzonderlijke bit, levert het type Result<Bitset<N>&> op en signaleert via een IsoStdOutOfRangeViolation wanneer een ongeldige positie-index wordt meegegeven ([SWS_CORE_01726]).

De elementfunctie set van de klasse ara::core::Bitset wijzigt de bit op de opgegeven positie pos naar de waarde val conform [SWS_CORE_01726]. De functie is gedeclareerd in de header #include "ara/core/bitset.h" en werkt zowel synchroon als exception-safe.

Ten opzichte van het standaardgedrag van std::bitset vertoont de functie twee wezenlijke afwijkingen ([SWS_CORE_01726]):

• De functie is gedeclareerd als noexcept en werpt geen C++-exceptions.
• Wanneer pos niet overeenkomt met een geldige bitpositie, wordt IsoStdOutOfRangeViolation geactiveerd in plaats van std::out_of_range.

Als retourwaarde wordt een Result<Bitset<N>&> geleverd ([SWS_CORE_01726]). In geval van succes bevat de Result een referentie naar het gewijzigde bitset-object. Ligt pos buiten het geldige bereik, dan transporteert de Result de bijbehorende foutschending.

In tegenstelling tot de parameterloze variant set() ([SWS_CORE_01725]), die alle bits instelt en direct Bitset<N>& retourneert, vereist deze positiegebaseerde overbelasting de evaluatie van het Result-object voor de afhandeling van bereikfouten ([SWS_CORE_01726]).

Gebruik

De synchrone memberfunctie test van de klasse ara::core::Bitset controleert de toestand van het bit op de meegegeven positie pos conform [SWS_CORE_01743]. Als aanroepparameter wordt de gewenste bitpositie pos van het type std::size_t doorgegeven. De functie levert synchroon een waarde van het type bool terug, waarbij true aangeeft dat het bit gezet is, en false dat het niet gezet is. Voor de integratie en het gebruik van de functie in de Core-module van het Adaptive-platform moet de header ara/core/bitset.h worden geïncludeerd [SWS_CORE_01743].

Foutafhandeling en afwijkingen

Het functionele gedrag volgt in principe de semantiek van std::bitset, maar vertoont twee wezenlijke systeemspecifieke afwijkingen [SWS_CORE_01743]:

• De signatuur is gedeclareerd als noexcept en garandeert volledige uitzonderingsveiligheid (exception safe) [SWS_CORE_01743].
• Komt de bitpositie pos niet overeen met een geldige bitpositie binnen het object, dan wordt in plaats van een uitzondering van het type std::out_of_range de schending IsoStdOutOfRangeViolation geactiveerd [SWS_CORE_01743]. De beschrijving daarvan is gebaseerd op die van std::out_of_range [SWS_CORE_01743].

Gelijktijdigheid en beperkingen

Aangezien de functie is gespecificeerd als const, wijzigt deze de instantie niet. Meervoudige gelijktijdige leestoegangen tot dezelfde bitset-instantie zijn daarom vermoedelijk bij normaal gebruik uitvoerbaar zonder dataconflikten (interpretatie). Vraag Q-585dbdfefac63391 (open) Vinden er gelijktijdig schrijvende modificaties op dezelfde instantie plaats, dan is vermoedelijk externe synchronisatie door de aanroeper vereist.

De memberfunctie to_uint16t van de klasse ara::core::Bitset converteert de inhoud van de bitset naar een geheelgetallige waarde van het type std::uint16_t ([SWS_CORE_01737], [SWS_APT_00025]). Deze vormt een AUTOSAR-specifieke uitbreiding en is niet opgenomen in de ISO-C++-standaard ISO-14882 ([SWS_CORE_01737]). De synchrone aanroep wordt aangeboden via de header ara/core/bitset.h ([SWS_CORE_01737]).

Bij de gegenereerde retourwaarde komt het eerste bit van de bitset overeen met het minst significante bit (least significant bit) en het laatste bit met het meest significante bit (most significant bit) van het getal ([SWS_CORE_01737]). Aangezien de methode is gespecificeerd als constexpr, kan deze ook tijdens compile-time op constante instanties worden geëvalueerd ([SWS_CORE_01737]).

De bewerking is gespecificeerd als thread-safe en exception safe ([SWS_CORE_01737]). Indien de bitwaarde niet in het waardebereik van std::uint16_t kan worden weergegeven, is er sprake van een IsoStdOverflowErrorViolation ([SWS_CORE_01737]). Interpretatie: Vanwege de noexcept-declaratie wordt deze schending vermoedelijk niet via reguliere C++-exceptions gemeld, maar leidt deze via platformspecifieke mechanismen voor violations tot afhandeling. Vraag Q-785057e36fb7e434 (open)

Gebruik en semantiek

De methode to_uint32t is een parameterloze, synchrone elementfunctie van de klasse ara::core::Bitset, die ter beschikking wordt gesteld via de header ara/core/bitset.h [SWS_CORE_01738]. Zij zet de bits van de bitset-instantie om in een niet-ondertekende 32-bits geheelgetalwaarde van het type std::uint32_t [SWS_CORE_01738]. De functie is niet opgenomen in ISO-14882, maar gedefinieerd als een AUTOSAR-specifieke alias voor ara::core::Bitset::to_ulong, die expliciet het datatype std::uint32_t uit [SWS_APT_00028] gebruikt [SWS_CORE_01738]. Bij de mapping van de bitreeks komt de eerste bit van de bitset overeen met de minst significante bit (least significant bit) van de retourwaarde en de laatste bit met de meest significante bit (most significant bit) [SWS_CORE_01738].

Foutafhandeling en randvoorwaarden

Voor foutsituaties definieert de specificatie de schending IsoStdOverflowErrorViolation, die optreedt wanneer de met de gezette bits overeenkomende geheelgetalwaarde niet kan worden weergegeven binnen het waardebereik van het retourtype [SWS_CORE_01738].

Gelijktijdigheid en uitvoeringscontext

De functie is gedeclareerd met constexpr en noexcept [SWS_CORE_01738]. Wat betreft de uitvoeringsveiligheid is zij gespecificeerd als thread-safe (thread-safe) en als exception-safe (exception safe) [SWS_CORE_01738].

Gebruik

De elementfunctie to_uint64t van de klasse ara::core::Bitset converteert de in de bitset opgenomen bits synchroon naar een geheelgetalwaarde van het type std::uint64_t ([SWS_CORE_01739]). De operatie is een AUTOSAR-specifieke uitbreiding en niet gedefinieerd in ISO-14882 ([SWS_CORE_01739]). Zij fungeert als alias voor de methode ara::core::Bitset::to_ullong, maar gebruikt daarbij verplicht en expliciet het type std::uint64_t conform [SWS_APT_00031] ([SWS_CORE_01739]). De declaratie wordt bereitgesteld via het headerbestand #include "ara/core/bitset.h" ([SWS_CORE_01739]).

Voor de bitsgewijze afvaardiging van de retourwaarde geldt dat de eerste bit van de bitset overeenkomt met de minst significante bit (least significant bit) van de gegenereerde waarde en de laatste bit wordt toegewezen aan de meest significante bit (most significant bit) ([SWS_CORE_01739]). Dankzij de kwalificatie als constexpr kan de evaluatie zowel tijdens runtime als tijdens compileertijd in constante expressies plaatsvinden ([SWS_CORE_01739]).

Foutafhandeling en gelijktijdigheid

Wat betreft de uitvoeringsveiligheid is de functie gedeclareerd met noexcept, geclassificeerd als exception-safe (exception safe) en onbeperkt aanroepbaar als thread-safe (thread-safe) ([SWS_CORE_01739]). Wanneer de met de bits overeenkomende geheelgetalwaarde niet in het doeltype kan worden weergegeven, doet zich de foutsituatie IsoStdOverflowErrorViolation voor ([SWS_CORE_01739]). De interface voldoet aan de bovenliggende eis [RS_AP_00130].

Gebruik

De memberfunctie to_uint8t van de klasse ara::core::Bitset converteert de opgeslagen bitset-inhoud synchroon naar een niet-ondertekende 8-bits geheelgetallige waarde van het type std::uint8_t conform [SWS_CORE_01736] en [SWS_APT_00022]. Het betreft een AUTOSAR-specifieke functie-uitbreiding die in de standaard ISO-14882 niet bestaat [SWS_CORE_01736]. De functie wordt beschikbaar gesteld via de header ara/core/bitset.h, is parameterloos en gedeclareerd als constexpr en noexcept [SWS_CORE_01736]. Het eerste bit van de bitreeks komt daarbij overeen met het minst significante bit (LSB) en het laatste bit met het meest significante bit (MSB) van de geretourneerde waarde [SWS_CORE_01736].

Foutafhandeling

Indien de met de bits in de bitset overeenkomende geheelgetallige waarde niet in het doeltype std::uint8_t kan worden weergegeven, treedt de schending IsoStdOverflowErrorViolation op [SWS_CORE_01736]. Ondanks de noexcept-declaratie is de functie wat betreft exception-veiligheid gespecificeerd als exception safe [SWS_CORE_01736].

Gelijktijdigheid en wisselwerking

Als constante memberfunctie is to_uint8t expliciet gedeclareerd als thread-safe [SWS_CORE_01736], zodat parallelle leestoegangen van meerdere threads tot dezelfde instantie veilig zijn. De representatie van het doeltype is gebaseerd op de bepaling uit [SWS_APT_00022].

De memberfunctie to_ullong van de klasse ara::core::Bitset zet de opgeslagen bitreeks synchroon om in een geheelgetallige waarde van het type unsigned long long [SWS_CORE_01735]. Deze is gedefinieerd in de header #include "ara/core/bitset.h" en ten opzichte van de ISO-standaard std::bitset gedeclareerd als constexpr en noexcept [SWS_CORE_01735].

Wat betreft foutafhandeling en uitzonderingsgedrag gelden de volgende bepalingen:

• Overloopafhandeling: Als de door de gezette bits gerepresenteerde geheelgetallige waarde niet in het retourtype kan worden weergegeven, wordt in plaats van een std::overflow_error-exception de schending IsoStdOverflowErrorViolation geactiveerd [SWS_CORE_01735].
• Uitzonderingsveiligheid: De functie is geclassificeerd als exception safe en werpt op grond van de noexcept-specificatie geen C++-uitzonderingen [SWS_CORE_01735].

In samenhang met andere interfaces biedt AUTOSAR Adaptive met to_uint64t een getypeerd alternatief dat fungeert als directe alias voor to_ullong, maar expliciet het type met vaste breedte std::uint64_t retourneert [SWS_CORE_01739]. Bij beide functies komt het eerste bit van de bitset overeen met het minst significante bit (LSB) en het laatste bit met het meest significante bit (MSB) van de resulterende getalswaarde [SWS_CORE_01739]. Aangezien to_ullong een constante memberfunctie is en het functionele equivalent als thread-safe is gespecificeerd, is een gelijktijdige lezende aanroep op dezelfde instantie vermoedelijk eveneens thread-safe [SWS_CORE_01739]. Vraag Q-075766fabc193ce8 (open)

De memberfunctie ara::core::Bitset::to_ulong converteert de gezette bits van een Bitset-instantie synchroon naar een geheelgetallige waarde van het type unsigned long [SWS_CORE_01734]. De functie vereist het headerbestand ara/core/bitset.h en behoort tot de scope van de klasse ara::core::Bitset [SWS_CORE_01734]. Door de declaratie met de signatuur constexpr unsigned long to_ulong() const noexcept; kan de evaluatie zowel tijdens runtime als reeds tijdens compile-time in constante expressies plaatsvinden [SWS_CORE_01734].

Qua foutgedrag verschilt de functie wezenlijk van de ISO-standaard std::bitset: als de geheelgetallige waarde die met de bits overeenkomt niet in het retourtype unsigned long kan worden weergegeven, wordt in plaats van een uitzondering van het type std::overflow_error een IsoStdOverflowErrorViolation geactiveerd [SWS_CORE_01734]. Ongeacht deze schendingsvoorwaarde is de functie gedeclareerd als noexcept en geldt deze formeel als uitzonderingsveilig (exception safe) [SWS_CORE_01734].

In samenhang met andere conversiefuncties stelt AUTOSAR Adaptive met to_uint32t een directe tegenhanger beschikbaar, die fungeert als alias voor to_ulong, maar exact getypeerd een std::uint32_t retourneert [SWS_CORE_01738]. Wat betreft gelijktijdigheid is de methode bij parallelle leestoegang tot dezelfde bitset vermoedelijk thread-safe (interpretatie), aangezien deze is gedefinieerd als const en de corresponderende requirement to_uint32t uitdrukkelijk als thread-safe is aangeduid [SWS_CORE_01738]. Vraag Q-59f95b86801a697d (open)