class ara::core::Bitset

Die Elementfunktion [SWS_CORE_01744] gehört zur Klasse ara::core::Bitset und wird über die Header-Datei #include "ara/core/bitset.h" bereitgestellt. Die Funktion besitzt die Signatur bool all () const noexcept;, nimmt keine Parameter entgegen und liefert synchron einen Wahrheitswert zurück. Die Semantik ist laut Spezifikation an die entsprechende Verwendung in [bitset] angelehnt; Interpretation: Die Methode prüft vermutlich, ob alle Bits der Instanz gesetzt sind (den Wert true aufweisen). Frage Q-a4f0f8970bd2c9bb (offen)

Hinsichtlich der Fehlerbehandlung ist die Funktion als noexcept deklariert und als ausnahmesicher (exception safe) spezifiziert [SWS_CORE_01744]. Da keine Fehlerzustände gemeldet werden und die Ausführung garantiert fehlerfrei verläuft, finden Fehlercodes aus ara::core::CoreErrc hier keine Anwendung.

Für den Aufrufkontext und die Nebenläufigkeit gelten folgende Randbedingungen:

• Die Operation ist als const deklariert und modifiziert den Zustand des aufrufenden ara::core::Bitset-Objekts nicht [SWS_CORE_01744].
• Gleichzeitige Lesezugriffe über mehrere Threads dürften ohne Synchronisation zulässig sein, solange kein anderer Thread denselben Speicherbereich schreibend verändert. Frage Q-d9f1f92a120128b5 (offen)

Die Elementfunktion any() von ara::core::Bitset dient der synchronen Abfrage des Belegungszustands der im Bitset verwalteten Bits [SWS_CORE_01745]. Das Verhalten richtet sich laut Spezifikation nach der korrespondierenden Verwendung des ISO-C++-Klassentemplates [bitset] [SWS_CORE_01745]. Interpretation: Die Funktion liefert true zurück, sofern mindestens ein Bit gesetzt ist, und false, wenn alle Bits ungesetzt sind. Frage Q-20c2aaf905d4a338 (offen)

Hinsichtlich Verwendung, Ausführungskontext und Fehlerverhalten gelten die folgenden Festlegungen:

• Aufruf und Parameter: Die Methode wird parameterlos auf einer bestehenden Instanz aufgerufen, die beispielsweise vorab über den Konstruktor initialisiert wurde [SWS_CORE_01749]. Der Aufruf erfolgt synchron und gibt das Prüfergebnis unmittelbar als bool zurück [SWS_CORE_01745].
• Fehlerbehandlung: Die Funktion ist als noexcept deklariert und als ausnahmesicher (exception safe) klassifiziert [SWS_CORE_01745]. Es werden weder Fehlercodes noch DET-/DEM-Meldungen erzeugt; ein Fehlschlagen der Operation ist im AUTOSAR-Standard nicht vorgesehen.
• Nebenläufigkeit: Durch die const-Qualifizierung modifiziert die Methode die Instanz nicht [SWS_CORE_01745]. Vermutlich sind parallele Lesezugriffe auf dieselbe Instanz sicher, während konkurrierende Schreibzugriffe durch den Aufrufer synchronisiert werden müssen. Frage Q-34893675aa85baf1 (offen)

Im Modulkontext von core stellt any() eine grundlegende Inspektionsfunktion für Bitsets bereit, die nahtlos mit den Initialisierungs- und Speicherungsmechanismen von ara::core::Bitset zusammenwirkt [SWS_CORE_01745], [SWS_CORE_01749].

Verwendung und Semantik

Die Elementfunktion count wird synchron und parameterlos auf einer Instanz von ara::core::Bitset aufgerufen ([SWS_CORE_01740]). Sie ist im Header #include "ara/core/bitset.h" deklariert und liefert das Zählergebnis als Rückgabewert vom Typ std::size_t ([SWS_CORE_01740]). Das fachliche Verhalten richtet sich nach der Referenz [bitset] ([SWS_CORE_01740]); der Wert dürfte daher der Gesamtanzahl der gesetzten Bits entsprechen. Frage Q-36c593b234f55695 (offen)

Fehlerbehandlung und Nebenläufigkeit

Die Funktion ist als noexcept spezifiziert und gilt als exception safe ([SWS_CORE_01740]). Es werden weder Exceptions ausgelöst noch Fehlercodes zurückgegeben, und Meldungen an DET oder DEM sind für dieses Element nicht vorgesehen. Da count als konstante Elementfunktion (const) deklariert ist ([SWS_CORE_01740]), modifiziert der Aufruf den Zustand des Objekts nicht. Parallele Lesezugriffe auf dieselbe Instanz dürften demnach nebenläufig ausführbar sein, sofern keine konkurrierenden Schreibzugriffe stattfinden. Frage Q-073bc3bbcb918763 (offen)

Zusammenspiel und Abgrenzung

Im Namensraum ara::core ist die Funktion klar von anderen Elementen zu trennen:

• In ara::core::Map dient count zur Ermittlung vorhandener Schlüssel ([SWS_CORE_01494], [SWS_CORE_01495]), ist jedoch als not exception safe klassifiziert.
• In ara::core::Span sowie der Factory-Funktion ara::core::MakeSpan bezeichnet count keinen Methodennamen, sondern einen formalen Parameter zur Beschränkung von Elementbereichen ([SWS_CORE_01942], [SWS_CORE_01962], [SWS_CORE_01964], [SWS_CORE_01966], [SWS_CORE_01990]).

Verwendung

Die Elementfunktion flip() der Klasse ara::core::Bitset invertiert synchron den Zustand aller Bits der Instanz gemäß dem Verhalten von [bitset] [SWS_CORE_01730]. Die Funktion wird über den Header #include "ara/core/bitset.h" bereitgestellt, nimmt keine Parameter entgegen und gibt eine lvalue-Referenz auf das modifizierte Objekt (Bitset<N>&) zurück, was die Verkettung von Operationen ermöglicht [SWS_CORE_01730].

Fehlerbehandlung und Exception-Sicherheit

Die Funktion ist als noexcept deklariert und als ausnahmesicher („exception safe“) spezifiziert [SWS_CORE_01730]. Es werden weder C++-Exceptions geworfen noch Fehlercodes zurückgegeben; die Ausführung dürfte daher stets fehlerfrei erfolgen. Frage Q-df762b6329a2c0d4 (offen)

Zusammenspiel

Das Modul core definiert verwandte Varianten zur Bitmanipulation:

• Die überladene Methode flip(std::size_t pos) dient dem gezielten Invertieren eines einzelnen Bits an Index pos [SWS_CORE_01731]. Im Unterschied zur parameterlosen Form gibt sie ein Result<Bitset<N>&> zurück und signalisiert ungültige Positionen über IsoStdOutOfRangeViolation [SWS_CORE_01731].
• Über die Referenzklasse ara::core::Bitset<N>::reference steht die Elementfunktion flip() zur Verfügung, um ein einzelnes referenziertes Bit zu invertieren und eine reference& zurückzuliefern [SWS_CORE_01712].

Die Elementfunktion flip der Klasse ara::core::Bitset invertiert synchron den Zustand des Bits an der übergebenen Position pos [SWS_CORE_01731]. Sie ist im Header #include "ara/core/bitset.h" definiert und orientiert sich am Verhalten von std::bitset::flip, weist jedoch spezifische funktionale Abweichungen auf [SWS_CORE_01731].

Die Funktion ist als noexcept sowie exception safe deklariert und gibt bei Erfolg eine Referenz auf das modifizierte Bitset innerhalb eines Result<Bitset<N>&> zurück [SWS_CORE_01731]. Entspricht der Parameter pos keiner gültigen Bitposition, wird anstelle einer C++-Exception wie std::out_of_range die Verletzung IsoStdOutOfRangeViolation ausgelöst [SWS_CORE_01731].

Hinsichtlich der Nebenläufigkeit dürfte gelten, dass gleichzeitige Aufrufe auf derselben Bitset-Instanz mangels dokumentierter Synchronisation nicht threadsicher sind und extern koordiniert werden müssen. Frage Q-de73bb65d6aab12c (offen)

Im Modul core ergänzt die Funktion weitere verwandte Operationen: Zum synchronen Invertieren aller Bits einer Instanz steht die parameterlose Überladung flip() bereit [SWS_CORE_01730], während für Bit-Referenzobjekte die Methode ara::core::Bitset::reference::flip() zur Verfügung steht [SWS_CORE_01712].

Verwendung

Die Elementfunktion none der Klasse ara::core::Bitset dient der Abfrage des Belegungszustands der Bitfolge [SWS_CORE_01746]. Die Methode erfordert das Einbinden des Headers ara/core/bitset.h und besitzt die Signatur bool none () const noexcept; [SWS_CORE_01746]. Der Aufruf erfolgt synchron und parameterlos auf einer bestehenden Instanz. Die Spezifikation verweist bezüglich des Verhaltens auf die entsprechende Nutzung in [bitset] [SWS_CORE_01746]; Interpretation: Die Methode dürfte genau dann true zurückliefern, wenn kein einziges Bit innerhalb der Bitfolge gesetzt ist (also alle Bits false sind), andernfalls false. Frage Q-de8593251c7748d5 (offen)

Fehlerbehandlung und Exception-Sicherheit

Für none sind weder Fehlercodes noch gesonderte Fehlerzustände definiert. Gemäß der Spezifikation ist die Funktion als noexcept deklariert und besitzt die Klassifikation ausnahmesicher (exception safe) [SWS_CORE_01746]. Im Fehlerfall oder während der Ausführung treten somit keine C++-Exceptions auf.

Nebenläufigkeit und Einschränkungen

Da none als const deklariert ist [SWS_CORE_01746], modifiziert der Methodenaufruf den internen Zustand des Objekts nicht. Parallele lesende Aufrufe auf demselben Bitset-Objekt dürften daher nebenläufig unkritisch und reentrant sein, sofern keine nebenläufigen schreibenden Modifikationen auf derselben Instanz erfolgen. Frage Q-cf92e9abf57e9678 (offen)

Die Elementfunktion reset() setzt gemäß Spezifikation [SWS_CORE_01727] den Zustand einer Instanz von ara::core::Bitset zurück. Die Funktion wird über die Header-Datei #include "ara/core/bitset.h" bereitgestellt und besitzt die Signatur Bitset<N>& reset() noexcept;.

Verwendung und Semantik

Die Funktion nimmt keine Parameter entgegen und arbeitet synchron auf dem aufrufenden Objekt. Durch den spezifizierten Verweis auf die übliche Verwendung in [bitset] dürfte der Aufruf sämtliche enthaltenen Bits auf false (bzw. 0) zurücksetzen und eine Referenz auf die eigene Bitset-Instanz (*this) zurückliefern, was Methodenverkettungen ermöglicht. Frage Q-89116316a65e0772 (offen)

Fehlerbehandlung und Ausnahme-Sicherheit

Gemäß [SWS_CORE_01727] ist die Funktion als noexcept deklariert und besitzt die Klassifizierung „exception safe“. Da im Gegensatz zur parametrisierten Überladung keine Indexprüfung erforderlich ist, treten bei der parameterlosen Variante keine Fehlerzustände oder Fehlercodes auf.

Zusammenspiel und Abgrenzung

• Im selben Gültigkeitsbereich ara::core::Bitset existiert die Überladung reset(std::size_t pos) nach [SWS_CORE_01728]. Diese setzt gezielt ein einzelnes Bit zurück, liefert jedoch ein Result<Bitset<N>&> und meldet eine IsoStdOutOfRangeViolation, falls pos ungültig ist.
• Namensgleiche Funktionen existieren im Modul core auch für ara::core::Optional gemäß [SWS_CORE_01136] und ara::core::Optional<T&> gemäß [SWS_CORE_01165] aus #include "ara/core/optional.h", welche den enthaltenen Wert verwerfen und den Rückgabetyp void aufweisen.

Die Elementfunktion reset der Klasse ara::core::Bitset setzt ein einzelnes Bit an der angegebenen Position pos synchron auf den Wert 0 zurück [SWS_CORE_01728]. Die Funktion folgt dem Verhalten von std::bitset, weist jedoch zwei wesentliche Abweichungen auf: Sie ist als noexcept deklariert und gibt das Ergebnis in einem Result<Bitset<N>&> zurück, um Fehlersituationen ohne C++-Ausnahmen abzubilden [SWS_CORE_01728].

Fehlerbehandlung

Falls der übergebene Index pos keiner gültigen Bitposition innerhalb des Bitsets entspricht, wird anstelle von std::out_of_range die Verletzung IsoStdOutOfRangeViolation ausgelöst [SWS_CORE_01728]. Diese wird im Fehlerfall als Fehlerzustand im zurückgegebenen Result-Objekt bereitgestellt, sodass die Operation trotz ungültiger Parameterausprägung ausnahmesicher bleibt [SWS_CORE_01728].

Zusammenspiel und Abgrenzung

Im Modul core existiert für ara::core::Bitset ergänzend die parameterlose Überladung reset(), die sämtliche Bits des Containers auf einmal löscht und direkt eine Referenz auf das Objekt liefert [SWS_CORE_01727]. Zudem definieren die verwandten Anforderungen [SWS_CORE_01136] und [SWS_CORE_01165] eine Methode gleichen Namens für ara::core::Optional, die dort den enthaltenen Wert verwirft.

Nebenläufigkeit

Da reset den internen Zustand des Bitsets verändert, dürfte ein nebenläufiger Aufruf auf derselben Instanz ohne externe Synchronisation nicht threadsicher sein (Interpretation: Übernahme der üblichen C++-Containersemantik). Frage Q-e2e1c041eadedf0f (offen)

Die synchrone Memberfunktion set() der Klasse ara::core::Bitset setzt alle enthaltenen Bits des Objekts auf den Wert true ([SWS_CORE_01725]). Sie entspricht im Verhalten der Funktionsweise von std::bitset aus dem ISO-C++-Standard und ist über den Header ara/core/bitset.h verfügbar ([SWS_CORE_01725]). Der Methodenaufruf erfolgt parameterlos und gibt eine lvalue-Referenz auf das modifizierte Bitset (Bitset<N>&) zurück ([SWS_CORE_01725]), was eine direkte Verkettung weiterer Aufrufe auf derselben Instanz gestattet.

Die Operation ist als noexcept deklariert und besitzt die Eigenschaft exception safe ([SWS_CORE_01725]). Da sie über alle Bits iteriert bzw. den Gesamtzustand setzt, treten im Gegensatz zu positionsbasierten Zugriffen keine Bereichsfehler auf. Zur Thread-Sicherheit trifft die Spezifikation keine Aussage; Interpretation: Da der Objektzustand unmittelbar mutiert wird, dürften parallele Zugriffe auf dieselbe Bitset-Instanz ohne externe Absicherung nicht nebenläufigkeits- bzw. threadsicher sein. Frage Q-f8c1b5721f668193 (offen)

Im Zusammenspiel innerhalb des Moduls core ergänzt die Funktion die überladene Variante set(std::size_t, bool) ([SWS_CORE_01726]). Während die parameterlose Version garantiert erfolgreich das gesamte Feld belegt, modifiziert die parametrisierte Version gezielt ein einzelnes Bit, liefert den Typ Result<Bitset<N>&> und signalisiert über eine IsoStdOutOfRangeViolation, wenn ein ungültiger Positionsindex übergeben wird ([SWS_CORE_01726]).

Die Elementfunktion set der Klasse ara::core::Bitset modifiziert das Bit an der angegebenen Position pos auf den Wert val gemäß [SWS_CORE_01726]. Die Funktion ist im Header #include "ara/core/bitset.h" deklariert und arbeitet synchron sowie ausnahmesicher.

Gegenüber dem Standardverhalten von std::bitset weist die Funktion zwei wesentliche Abweichungen auf ([SWS_CORE_01726]):

• Die Funktion ist als noexcept deklariert und wirft keine C++-Exceptions.
• Wenn pos keiner gültigen Bitposition entspricht, wird IsoStdOutOfRangeViolation anstelle von std::out_of_range ausgelöst.

Als Rückgabewert wird ein Result<Bitset<N>&> geliefert ([SWS_CORE_01726]). Im Erfolgsfall enthält das Result eine Referenz auf das modifizierte Bitset-Objekt. Liegt pos außerhalb des gültigen Bereichs, transportiert das Result die entsprechende Fehlerverletzung.

Im Unterschied zur parameterlosen Variante set() ([SWS_CORE_01725]), welche alle Bits setzt und direkt Bitset<N>& zurückgibt, erfordert diese positionsbasierte Überladung die Auswertung des Result-Objekts zur Behandlung von Bereichsfehlern ([SWS_CORE_01726]).

Verwendung

Die synchrone Elementfunktion test der Klasse ara::core::Bitset prüft den Zustand des Bits an der übergebenen Position pos gemäß [SWS_CORE_01743]. Als Aufrufparameter wird die gewünschte Bitposition pos vom Typ std::size_t übergeben. Die Funktion liefert synchron einen Wert vom Typ bool zurück, wobei true anzeigt, dass das Bit gesetzt ist, und false, dass es nicht gesetzt ist. Für die Einbindung und Verwendung der Funktion im Core-Modul der Adaptive-Plattform muss der Header ara/core/bitset.h inkludiert werden [SWS_CORE_01743].

Fehlerbehandlung und Abweichungen

Das funktionale Verhalten folgt grundsätzlich der Semantik von std::bitset, weist jedoch zwei wesentliche systemspezifische Abweichungen auf [SWS_CORE_01743]:

• Die Signatur ist als noexcept deklariert und garantiert vollständige Ausnahmesicherheit (exception safe) [SWS_CORE_01743].
• Entspricht die Bitposition pos keiner gültigen Bitposition innerhalb des Objekts, wird anstelle einer Ausnahme vom Typ std::out_of_range die Verletzung IsoStdOutOfRangeViolation ausgelöst [SWS_CORE_01743]. Deren Beschreibung orientiert sich an der von std::out_of_range [SWS_CORE_01743].

Nebenläufigkeit und Einschränkungen

Da die Funktion als const spezifiziert ist, modifiziert sie die Instanz nicht. Mehrfache nebenläufige Lesezugriffe auf dieselbe Bitset-Instanz dürften daher im regulären Betrieb ohne Datenkonflikte ausführbar sein (Interpretation). Frage Q-585dbdfefac63391 (offen) Finden zeitgleich schreibende Modifikationen auf derselben Instanz statt, ist vermutlich eine externe Synchronisation durch den Aufrufer erforderlich.

Die Elementfunktion to_uint16t der Klasse ara::core::Bitset konvertiert den Inhalt des Bitsets in einen ganzzahligen Wert vom Typ std::uint16_t ([SWS_CORE_01737], [SWS_APT_00025]). Sie stellt eine AUTOSAR-spezifische Erweiterung dar und ist nicht im ISO-C++-Standard ISO-14882 enthalten ([SWS_CORE_01737]). Der synchrone Aufruf wird über den Header ara/core/bitset.h bereitgestellt ([SWS_CORE_01737]).

Beim erzeugten Rückgabewert entspricht das erste Bit des Bitsets dem niedrigstwertigen Bit (least significant bit) und das letzte Bit dem höchstwertigen Bit (most significant bit) der Zahl ([SWS_CORE_01737]). Da die Methode als constexpr spezifiziert ist, lässt sie sich auch zur Übersetzungszeit auf konstanten Instanzen auswerten ([SWS_CORE_01737]).

Die Operation ist als thread-safe sowie exception safe spezifiziert ([SWS_CORE_01737]). Falls der Bitwert nicht im Wertebereich von std::uint16_t dargestellt werden kann, liegt eine IsoStdOverflowErrorViolation vor ([SWS_CORE_01737]). Interpretation: Wegen der noexcept-Deklaration dürfte diese Verletzung nicht über reguläre C++-Exceptions gemeldet werden, sondern über plattformspezifische Mechanismen für Violations zur Behandlung führen. Frage Q-785057e36fb7e434 (offen)

Verwendung und Semantik

Die Methode to_uint32t ist eine parameterlose, synchrone Elementfunktion der Klasse ara::core::Bitset, die über den Header ara/core/bitset.h bereitgestellt wird [SWS_CORE_01738]. Sie wandelt die Bits der Bitset-Instanz in einen vorzeichenlosen 32-Bit-Ganzzahlwert des Typs std::uint32_t um [SWS_CORE_01738]. Die Funktion ist nicht in ISO-14882 enthalten, sondern als AUTOSAR-spezifischer Alias für ara::core::Bitset::to_ulong definiert, der explizit den Datentyp std::uint32_t aus [SWS_APT_00028] verwendet [SWS_CORE_01738]. Beim Mapping der Bitfolge entspricht das erste Bit des Bitsets dem niederwertigsten Bit (least significant bit) des Rückgabewerts und das letzte Bit dem höchstwertigen Bit (most significant bit) [SWS_CORE_01738].

Fehlerbehandlung und Randbedingungen

Für den Fehlerfall definiert die Spezifikation die Verletzung IsoStdOverflowErrorViolation, die auftritt, wenn der den gesetzten Bits entsprechende ganzzahlige Wert nicht im Wertebereich des Rückgabetyps dargestellt werden kann [SWS_CORE_01738].

Nebenläufigkeit und Ausführungskontext

Die Funktion ist mit constexpr und noexcept deklariert [SWS_CORE_01738]. Hinsichtlich der Ausführungssicherheit ist sie als threadsicher (thread-safe) sowie als ausnahmesicher (exception safe) spezifiziert [SWS_CORE_01738].

Verwendung

Die Elementfunktion to_uint64t der Klasse ara::core::Bitset konvertiert die im Bitset enthaltenen Bits synchron in einen ganzzahligen Wert des Typs std::uint64_t ([SWS_CORE_01739]). Die Operation ist eine AUTOSAR-spezifische Erweiterung und nicht in ISO-14882 definiert ([SWS_CORE_01739]). Sie fungiert als Alias für die Methode ara::core::Bitset::to_ullong, verwendet dabei jedoch verbindlich und explizit den Typ std::uint64_t gemäß [SWS_APT_00031] ([SWS_CORE_01739]). Die Deklaration wird über die Header-Datei #include "ara/core/bitset.h" bereitgestellt ([SWS_CORE_01739]).

Für die bitweise Abbildung des Rückgabewerts gilt, dass das erste Bit des Bitsets dem niederwertigsten Bit (least significant bit) des erzeugten Werts entspricht und das letzte Bit dem höchstwertigen Bit (most significant bit) zugewiesen wird ([SWS_CORE_01739]). Dank der Qualifizierung als constexpr kann die Auswertung sowohl zur Laufzeit als auch zur Übersetzungszeit in konstanten Ausdrücken stattfinden ([SWS_CORE_01739]).

Fehlerbehandlung und Nebenläufigkeit

Hinsichtlich der Ausführungssicherheit ist die Funktion mit noexcept deklariert, als ausnahmesicher (exception safe) eingestuft und uneingeschränkt threadsicher (thread-safe) aufrufbar ([SWS_CORE_01739]). Wenn der den Bits entsprechende ganzzahlige Wert nicht im Zieltyp darstellbar ist, liegt der Fehlerfall IsoStdOverflowErrorViolation vor ([SWS_CORE_01739]). Die Schnittstelle erfüllt die übergeordnete Anforderung [RS_AP_00130].

Verwendung

Die Elementfunktion to_uint8t der Klasse ara::core::Bitset konvertiert den gespeicherten Bitset-Inhalt synchron in einen vorzeichenlosen 8-Bit-Ganzzahlwert vom Typ std::uint8_t gemäß [SWS_CORE_01736] und [SWS_APT_00022]. Es handelt sich um eine AUTOSAR-spezifische Funktionserweiterung, die im Standard ISO-14882 nicht existiert [SWS_CORE_01736]. Die Funktion wird über den Header ara/core/bitset.h bereitgestellt, ist parameterlos sowie als constexpr und noexcept deklariert [SWS_CORE_01736]. Das erste Bit der Bitfolge entspricht dabei dem niederwertigsten Bit (LSB) und das letzte Bit dem höchstwertigen Bit (MSB) des zurückgegebenen Werts [SWS_CORE_01736].

Fehlerbehandlung

Kann der den Bits im Bitset entsprechende ganzzahlige Wert nicht im Zieltyp std::uint8_t dargestellt werden, liegt die Verletzung IsoStdOverflowErrorViolation vor [SWS_CORE_01736]. Trotz der noexcept-Deklaration ist die Funktion in Bezug auf die Exception-Sicherheit als exception safe spezifiziert [SWS_CORE_01736].

Nebenläufigkeit und Zusammenspiel

Als konstante Elementfunktion ist to_uint8t explizit als thread-safe deklariert [SWS_CORE_01736], sodass parallele Lesezugriffe mehrerer Threads auf dieselbe Instanz sicher sind. Die Repräsentation des Zieltyps orientiert sich an der Festlegung aus [SWS_APT_00022].

Die Elementfunktion to_ullong der Klasse ara::core::Bitset wandelt die gespeicherte Bitfolge synchron in einen ganzzahligen Wert des Typs unsigned long long um [SWS_CORE_01735]. Sie ist im Header #include "ara/core/bitset.h" definiert und gegenüber dem ISO-Standard std::bitset als constexpr sowie noexcept deklariert [SWS_CORE_01735].

Hinsichtlich Fehlerbehandlung und Ausnahmeverhalten gelten folgende Festlegungen:

• Überlaufbehandlung: Kann der durch die gesetzten Bits repräsentierte ganzzahlige Wert nicht im Rückgabetyp dargestellt werden, wird anstelle einer std::overflow_error-Exception die Verletzung IsoStdOverflowErrorViolation ausgelöst [SWS_CORE_01735].
• Ausnahmesicherheit: Die Funktion ist als exception safe eingestuft und wirft aufgrund der noexcept-Spezifikation keine C++-Ausnahmen [SWS_CORE_01735].

Im Zusammenspiel mit weiteren Schnittstellen stellt AUTOSAR Adaptive mit to_uint64t eine typisierte Alternative bereit, die als direkter Alias für to_ullong fungiert, jedoch explizit den Festbreitentyp std::uint64_t zurückgibt [SWS_CORE_01739]. Bei beiden Funktionen entspricht das erste Bit des Bitsets dem niedrigstwertigen Bit (LSB) und das letzte Bit dem höchstwertigen Bit (MSB) des resultierenden Zahlenwerts [SWS_CORE_01739]. Da to_ullong eine konstante Elementfunktion ist und das funktionale Äquivalent als thread-safe spezifiziert ist, dürfte ein nebenläufiger lesender Aufruf auf derselben Instanz ebenfalls threadsicher sein [SWS_CORE_01739]. Frage Q-075766fabc193ce8 (offen)

Die Elementfunktion ara::core::Bitset::to_ulong konvertiert die gesetzten Bits einer Bitset-Instanz synchron in einen ganzzahligen Wert vom Typ unsigned long [SWS_CORE_01734]. Die Funktion erfordert die Header-Datei ara/core/bitset.h und gehört zum Scope der Klasse ara::core::Bitset [SWS_CORE_01734]. Durch die Deklaration mit der Signatur constexpr unsigned long to_ulong() const noexcept; kann die Auswertung sowohl zur Laufzeit als auch bereits zur Übersetzungszeit in konstanten Ausdrücken erfolgen [SWS_CORE_01734].

Beim Fehlerverhalten unterscheidet sich die Funktion maßgeblich vom ISO-Standard std::bitset: Kann der den Bits entsprechende ganzzahlige Wert nicht im Rückgabetyp unsigned long abgebildet werden, wird anstelle einer Ausnahme vom Typ std::overflow_error eine IsoStdOverflowErrorViolation ausgelöst [SWS_CORE_01734]. Ungeachtet dieser Verletzungsbedingung ist die Funktion als noexcept deklariert und gilt formal als ausnahmesicher (exception safe) [SWS_CORE_01734].

Im Zusammenspiel mit weiteren Konvertierungsfunktionen stellt AUTOSAR Adaptive mit to_uint32t ein direktes Pendant bereit, das als Alias für to_ulong fungiert, jedoch typgenau einen std::uint32_t zurückliefert [SWS_CORE_01738]. Bezüglich der Nebenläufigkeit dürfte die Methode bei parallelen Lesezugriffen auf denselben Bitset thread-sicher sein (Interpretation), da sie als const definiert ist und das korrespondierende Requirement to_uint32t ausdrücklich als thread-safe gekennzeichnet ist [SWS_CORE_01738]. Frage Q-59f95b86801a697d (offen)