Modul ara::core — Adaptive Platform Core
Modul-GuideKI-GENERIERT
Stellt plattformweite C++-Basistypen, fehlersichere Ergebnistypen und deterministische Speicherpools bereit.
Stellt plattformweite C++-Basistypen, fehlersichere Ergebnistypen und deterministische Speicherpools bereit.
Das Modul core stellt die plattformweiten Basistypen, PMR-Speicherpools und asynchronen Synchronisationsprimitive Future und Promise für die AUTOSAR Adaptive Platform bereit (SWArchitecture S. 60, [SWS_CORE_00326]). Zur Erfüllung strenger Sicherheits- und Echtzeitanforderungen ersetzt der Summentyp Result<T, E> klassische Exceptions durch deterministische Rückgabewerte ([SWS_CORE_00751]). Bei irreparablen Systemfehlern gewährleistet die Fail-Fast-Funktion Abort() den unverzüglichen, kontrollierten Prozessabbruch ([SWS_CORE_00052]).
Das Modul core fungiert als Basis-Funktionscluster der AUTOSAR Adaptive Platform und stellt einheitliche Datenstrukturen, asynchrone Kommunikationsprimitive und Speichermanagement-Mechanismen für alle Plattformdienste und Anwendungen bereit (SWArchitecture S. 60). Um deterministische Abläufe und funktionale Sicherheit in POSIX-Betriebssystemumgebungen zu garantieren, ersetzt core konventionelle C++-Exceptions durch den typensicheren Ergebnistyp Result<T, E> und kontrolliert dynamische Speicherzuweisungen über polymorphe Allokatoren ([SWS_CORE_00041], [SWS_CORE_00751]).
Kontextdiagramm: Einbettung des Funktionsclusters ara::core und seiner Schnittstellenbereiche in die Adaptive Platform. Quellen: SWArchitecture S. 60, SWArchitecture S. 36
Für die nebenläufige Synchronisation implementiert core das Zusammenspiel von Future und Promise ([SWS_CORE_00326], [SWS_CORE_00344]). Während der Erzeuger den Berechnungsstatus oder Fehler über das Promise bereitstellt, erlaubt Future dem Konsumenten sowohl zeitüberwachte Abfragen via wait_for() als auch reaktive Weiterleitungen mittels then() ([SWS_CORE_00329], [SWS_CORE_00331], TimeSynchronization S. 90).
Aktivitätsdiagramm: Deterministischer Auswertungspfad eines Result-Objekts im fehlerfreien Fall und im Fehlerfall. Quellen: [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]
Zur Vermeidung von Fragmentierung stellt das Modul Pool-Ressourcen wie SynchronizedPoolResource und UnsynchronizedPoolResource bereit, die Allokationen auf Chunks fester Größe beschränken ([SWS_CORE_00030], [SWS_CORE_00067], SWArchitecture S. 61). Tritt ein unüberwindbarer Fehlerzustand ein, erzwingt die Plattform über Abort() unter vorangehender Ausführung eines registrierten AbortHandler die sofortige Fail-Fast-Terminierung des Prozesses ([SWS_CORE_00051], [SWS_CORE_00052]).
Systemrolle und architektonische Basis von ara::core
Das Modul core bildet das fundamentale Fundament der AUTOSAR Adaptive Platform und stellt grundlegende Typdefinitionen, Speicherverwaltungsmechanismen sowie Basisschnittstellen für alle funktionalen Cluster und Adaptive Applications bereit (SWArchitecture S. 60). Im Gegensatz zu anwendungsspezifischen Diensten ist core prozesslokal ausgelegt und definiert die wesentlichen Abstraktionen, um portable, deterministische und ressourceneffiziente C++-Software innerhalb von POSIX-Betriebssystemumgebungen zu realisieren (SWArchitecture S. 36).
Architektonisch fungiert das Modul als standardisierte Schnittstelle zwischen den hardwarenahen Betriebssystemfunktionen und den höheren Schichten der Adaptive Platform (SWArchitecture S. 60). Hierbei adressiert core zentrale Anforderungen an funktionale Sicherheit (ASIL) und Echtzeitfähigkeit, indem es dynamische Speicherallokationen kontrollierbar macht und auf den flächendeckenden Einsatz von C++-Exceptions im regulären Kontrollfluss verzichtet ([SWS_CORE_00052], [SWS_CORE_00751]). Die Bereitstellung plattformweiter Basistypen verhindert proprietäre Insellösungen zwischen Middleware-Komponenten wie ara::com oder ara::ts (ARAComAPI S. 46, TimeSynchronization S. 90).
Kontextdiagramm: Einbettung des Funktionsclusters ara::core und seiner Schnittstellenbereiche in die Adaptive Platform. Quellen: SWArchitecture S. 60, SWArchitecture S. 36
Asynchrone Kontroll- und Datenflüsse über Future und Promise
Für die nebenläufige und entkoppelte Interaktion implementiert ara::core das Erzeuger-Verbraucher-Muster mittels Promise und Future ([SWS_CORE_00326], [SWS_CORE_00341]). Ein Promise repräsentiert die schreibende Schnittstelle, über die ein asynchroner Worker oder ein Kommunikations-Skeleton das Ergebnis oder einen Fehler hinterlegt ([SWS_CORE_00345], [SWS_CORE_00353]). Das konsumierende Gegenstück bildet Future, welches den gemeinsamen Zustand (Shared State) überwacht und den typsicheren Zugriff auf den Rückgabewert kapselt (ARAComAPI S. 46, ARAComAPI S. 59).
Um ein Blockieren von Client-Threads zu vermeiden, stellt Future neben der synchronen, blockierenden Abfragefunktion get() ([SWS_CORE_00326]) zeitbeschränkte Warteoperationen bereit: wait_for() und wait_until() liefern einen Statusindikator vom Typ FutureStatus zurück ([SWS_CORE_00329], [SWS_CORE_00330], ARAComAPI S. 1). Über die Methode then() können Callbacks registriert werden, die bei Eintreffen des Ergebnisses automatisch ausgeführt werden; wahlweise lässt sich hierbei ein anwenderspezifischer Executor einbinden, um die Ausführung auf bestimmte Thread-Pools zu steuern ([SWS_CORE_00024], [SWS_CORE_00331], [SWS_CORE_00337]). Kopiervorgänge sind für Future und Promise explizit unterbunden, um exklusive Besitzverhältnisse sicherzustellen ([SWS_CORE_00334], [SWS_CORE_00350]).
Sequenzdiagramm: Asynchrone Wert- und Fehlerübertragung zwischen Worker und Anwendung über Promise und Future. Quellen: [SWS_CORE_00326], [SWS_CORE_00329], [SWS_CORE_00344], [SWS_CORE_00345], TimeSynchronization S. 90
Deterministisches Fehlermanagement: Result, ErrorCode und ErrorDomain
Ein Kernaspekt der sicherheitsgerichteten Programmierung in der Adaptive Platform ist die strikte Vermeidung unkontrollierter Exceptions im regulären Betrieb. ara::core::Result<T, E> fungiert als typensichere Summentyp-Kapselung, die entweder einen Erfolgs-Nutzlastwert vom Typ T oder ein Fehlerobjekt vom Typ E enthält ([SWS_CORE_00721], [SWS_CORE_00723], [SWS_CORE_00751]). Spezialisierungen existieren sowohl für Referenztypen Result<T&, E> als auch für rückgabewertlose Operationen Result<void, E> ([SWS_CORE_00821], [SWS_CORE_00908]).
Der enthaltene Zustand wird über HasValue() oder den expliziten Konvertierungsoperator operator bool() geprüft ([SWS_CORE_00751], [SWS_CORE_00752]). Der Zugriff auf Nutzdaten erfolgt über Value() oder operator*(), während Fehler über Error() abgefragt werden ([SWS_CORE_00755], [SWS_CORE_00757]). Zur funktionalen Weiterverarbeitung und Fehlerfortpflanzung stellt Result Methoden wie Bind(), ValueOr() und Resolve() bereit ([SWS_CORE_00761], [SWS_CORE_00768]). Fehler werden über ErrorCode modelliert, welcher einen numerischen Fehlercode CodeType mit einer eindeutigen Domänenkennung ErrorDomain sowie optionalen Diagnose-Zusatzdaten SupportDataType verknüpft ([SWS_CORE_00121], [SWS_CORE_00122], [SWS_CORE_00512]). Die Methode ValueOrThrow() existiert als Brücke für Umgebungen mit aktivierter Ausnahmebehandlung, löst jedoch im Fehlerfall die mit der Domäne verknüpfte Exception aus ([SWS_CORE_00154], [SWS_CORE_00766]).
Aktivitätsdiagramm: Deterministischer Auswertungspfad eines Result-Objekts im fehlerfreien Fall und im Fehlerfall. Quellen: [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]
Polymorphe Speicherverwaltung über Pool-Ressourcen
Dynamische Allokation auf dem Standard-Heap birgt Risiken bezüglich Nicht-Determinismus und Speicherfragmentierung. ara::core integriert daher ein Speichermanagement auf Basis polymorpher Speicherressourcen (PMR), angelehnt an das C++-NVI-Muster (Non-Virtual Interface) (SWArchitecture S. 61). Die Basisklasse MemoryResource deklariert die öffentlichen Schnittstellen allocate() und deallocate(), welche intern die rein virtuellen Methoden do_allocate() und do_deallocate() ansteuern ([SWS_CORE_00041], [SWS_CORE_00061]).
Für echtzeitkritische Allokationsmuster stehen spezialisierte Pool-Ressourcen zur Verfügung: SynchronizedPoolResource bietet threadsichere Allokationen aus vorkonfigurierten Chunks und Blockgrößen über PoolOptions ([SWS_CORE_00027], [SWS_CORE_00030]). Für strikt thread-lokale Verarbeitungsphasen ohne Synchronisations-Overhead dient UnsynchronizedPoolResource ([SWS_CORE_00046], [SWS_CORE_00067]). Über release() kann der gesamte allokierte Speicherbereich in einem einzigen Schritt an die vorgeschaltete upstream_resource() zurückgegeben werden, was Speicherlecks bei phasenorientierten Arbeitsabläufen wirksam unterbindet ([SWS_CORE_00037], [SWS_CORE_00038], [SWS_CORE_00065]).
Klassendiagramm: Hierarchie der polymorphen Speicherressourcen nach dem Non-Virtual Interface (NVI)-Muster. Quellen: SWArchitecture S. 61, [SWS_CORE_00030], [SWS_CORE_00041], [SWS_CORE_00061]
Fundamentale Utility- und Container-Typen (Optional, Array, Vector, Map)
Zur Vermeidung von undefiniertem Verhalten und zur Sicherstellung klarer Semantik normiert core elementare Container und Hilfstypen. ara::core::Optional<T> repräsentiert Werte, die vorhanden sein können oder nicht, ohne auf unsichere Null-Pointer zurückgreifen zu müssen ([SWS_CORE_01103], [SWS_CORE_01104], ARAComAPI S. 1). Der Zustand wird über has_value() oder operator bool() abgefragt, während Zugriffe über value(), value_or() oder operator*() erfolgen ([SWS_CORE_01128], [SWS_CORE_01129], [SWS_CORE_01130], [SWS_CORE_01134]). Spezielle Referenzüberladungen Optional<T&> gestatten das sichere Halten optionaler Referenzen ([SWS_CORE_01151], [SWS_CORE_01167]).
Für Datenstrukturen mit fester Größe stellt das Modul Array<T, N> bereit, das direkte Indizierung über operator[], bereichsüberprüften Zugriff mittels at() sowie Standard-Iteratoren unterstützt ([SWS_CORE_01250], [SWS_CORE_01265], [SWS_CORE_01273]). Vergleichsoperatoren sind nach strikten Codierrichtlinien mit bool-Rückgaben und Exception-Sicherheit implementiert ([SWS_CORE_01290], CPP14Guidelines S. 241). Dynamisch wachsende Sequenzen und assoziative Container werden durch Vector<T, Allocator> und Map<Key, T, Compare, Allocator> abgedeckt ([SWS_CORE_01318], [SWS_CORE_01428]). Beide Typen akzeptieren konfigurierbare Allokatoren, sodass Allokationen nahtlos über die polymorphen MemoryResource-Pools abgewickelt werden können ([SWS_CORE_00066], [SWS_CORE_01303], [SWS_CORE_01406]).
Verhalten im Fehlerfall und Fail-Fast-Terminierung
Kann ein Prozess einen schwerwiegenden Fehlerzustand nicht sicher kompensieren, greift das Fail-Fast-Prinzip der Adaptive Platform (SWArchitecture S. 60). Über die Schnittstelle Abort() wird die unmittelbare, unkonditionierte Terminierung des laufenden Prozesses herbeigeführt ([SWS_CORE_00052]). Die Funktion ist als [[noreturn]] und noexcept deklariert, um sicherzustellen, dass keine Stack-Unwinding-Routinen oder Destruktoren inkorrekte Folgezustände erzeugen ([SWS_CORE_00052], SWArchitecture S. 36).
Um vor dem Beenden flüchtige Diagnoseinformationen zu sichern oder letzte Notfall-Logging-Aktionen auszuführen, können Anwendungen über SetAbortHandler() oder AddAbortHandler() anwenderspezifische Rückruffunktionen registrieren ([SWS_CORE_00050], [SWS_CORE_00051], [SWS_CORE_00054]). Ein registrierter Abort-Handler muss der Signatur void() noexcept genügen ([SWS_CORE_00053]). Nach Ausführung des Handlers erzwingt die Plattform die endgültige Beendigung des Prozesses, sodass kein Weiterlaufen in undefiniertem Speicherzustand möglich ist (SWArchitecture S. 60).
Aktivitätsdiagramm: Kontrollfluss des Fail-Fast-Abbruchs über Abort() mit Ausführung des AbortHandlers. Quellen: SWArchitecture S. 60, [SWS_CORE_00051], [SWS_CORE_00052]
Weiterführende Detailbelege
Die Spezifikation von core im Release R25-11 stützt sich auf eine Reihe normativer Festlegungen und Architekturmodelle. Für das Prozess-Lifecycle- und Notaus-Verhalten sind Initialize(), Deinitialize() sowie Abort() und SetAbortHandler() konstitutiv ([SWS_CORE_00051], [SWS_CORE_00052], SWArchitecture S. 60). Das asynchrone Kommunikationsmodell stützt sich maßgeblich auf Future ([SWS_CORE_00326], [SWS_CORE_00329]) und Promise ([SWS_CORE_00344], [SWS_CORE_00345]), deren Zusammenspiel in anwendungsnahen Clustern wie ara::com und ara::ts verifiziert wird (ARAComAPI S. 46, TimeSynchronization S. 90).
Das fehlerfreie Daten- und Speichermanagement wird durch die Spezifikationen zu Result ([SWS_CORE_00751], [SWS_CORE_00766]), ErrorCode ([SWS_CORE_00512]) und den PMR-Speicherklassen SynchronizedPoolResource sowie UnsynchronizedPoolResource normiert ([SWS_CORE_00030], [SWS_CORE_00046], SWArchitecture S. 61). Ergänzend definieren Container- und Vergleichsrichtlinien die deterministische Datenhaltung in sicherheitskritischen Gesamtsystemen ([SWS_CORE_01103], [SWS_CORE_01250], [SWS_CORE_01318], CPP14Guidelines S. 241).
Dieser Leitfaden wurde durch einen KI-Kurations-Assistenten auf Basis der AUTOSAR-Spezifikation für R25-11 generiert.
function: 1060 type alias: 101 class: 34 struct: 26 variable: 13 enumeration: 3
Themenkarte
ara::core
67Für dieses Release liegen keine Elementdaten vor
ara::core
Implementation of std::array type from [array.syn] The implicitly-declared special member functions specified in [array.cons] are not expli ≙ std::array
Zugriff get 4
template <std::size_t I, typename T, std::size_t N> constexpr T & get (Array< T, N > &a) noexcept; SWS_CORE_01282template <std::size_t I, typename T, std::size_t N> constexpr T && get (Array< T, N > &&a) noexcept; SWS_CORE_01283template <std::size_t I, typename T, std::size_t N> constexpr T const & get (const Array< T, N > &a) noexcept; SWS_CORE_01284template <size_t I, class T, size_t N> constexpr const T && get (const Array< T, N > &&) noexcept; SWS_CORE_01286Vergleich != < <= == > >= 6
template <typename T, std::size_t N> bool operator!= (const Array< T, N > &lhs, const Array< T, N > &rhs) noexcept(noexcept(std::declval< T & >()==std::declval< T & >())); SWS_CORE_01291template <typename T, std::size_t N> bool operator< (const Array< T, N > &lhs, const Array< T, N > &rhs) noexcept(noexcept(std::declval< T & >()==std::declval< T & >())); SWS_CORE_01292template <typename T, std::size_t N> bool operator<= (const Array< T, N > &lhs, const Array< T, N > &rhs) noexcept(noexcept(std::declval< T & >()==std::declval< T & >())); SWS_CORE_01294template <typename T, std::size_t N> bool operator== (const Array< T, N > &lhs, const Array< T, N > &rhs) noexcept(noexcept(std::declval< T & >()==std::declval< T & >())); SWS_CORE_01290template <typename T, std::size_t N> bool operator> (const Array< T, N > &lhs, const Array< T, N > &rhs) noexcept(noexcept(std::declval< T & >()==std::declval< T & >())); SWS_CORE_01293template <typename T, std::size_t N> bool operator>= (const Array< T, N > &lhs, const Array< T, N > &rhs) noexcept(noexcept(std::declval< T & >()==std::declval< T & >())); SWS_CORE_01295Tausch swap 1
template <typename T, std::size_t N> void swap (Array< T, N > &lhs, Array< T, N > &rhs) noexcept(noexcept(lhs.swap(rhs))); SWS_CORE_01296Implementation of std::pmr::basic_string type from [basic.string] ≙ std::pmr::basic_string
Vergleich != < <= == > >= 18
template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator!= (const BasicString< Allocator > &lhs, const Basic String< Allocator > &rhs) noexcept; SWS_CORE_03367template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator!= (const charT *lhs, const BasicString< Allocator > &rhs); SWS_CORE_03368template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator!= (const BasicString< Allocator > &lhs, const charT *rhs); SWS_CORE_03369template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator< (const BasicString< Allocator > &lhs, const Basic String< Allocator > &rhs) noexcept; SWS_CORE_03370template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator< (const BasicString< Allocator > &lhs, const charT *rhs); SWS_CORE_03371template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator< (const charT *lhs, const BasicString< Allocator > &rhs); SWS_CORE_03372template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator<= (const BasicString< Allocator > &lhs, const Basic String< Allocator > &rhs) noexcept; SWS_CORE_03376template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator<= (const BasicString< Allocator > &lhs, const charT *rhs); SWS_CORE_03377template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator<= (const charT *lhs, const BasicString< Allocator > &rhs); SWS_CORE_03378template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator== (const BasicString< Allocator > &lhs, const Basic String< Allocator > &rhs) noexcept; SWS_CORE_03364template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator== (const charT *lhs, const BasicString< Allocator > &rhs); SWS_CORE_03365template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator== (const BasicString< Allocator > &lhs, const charT *rhs); SWS_CORE_03366template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator> (const BasicString< Allocator > &lhs, const Basic String< Allocator > &rhs) noexcept; SWS_CORE_03373template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator> (const BasicString< Allocator > &lhs, const charT *rhs); SWS_CORE_03374template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator> (const charT *lhs, const BasicString< Allocator > &rhs); SWS_CORE_03375template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator>= (const BasicString< Allocator > &lhs, const Basic String< Allocator > &rhs) noexcept; SWS_CORE_03379template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator>= (const BasicString< Allocator > &lhs, const charT *rhs); SWS_CORE_03380template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> bool operator>= (const charT *lhs, const BasicString< Allocator > &rhs); SWS_CORE_03381Verkettung + 12
template <typename Allocator> BasicString< Allocator > operator+ (const BasicString< Allocator > &lhs, const BasicString< Allocator > &rhs); SWS_CORE_03352template <typename Allocator> BasicString< Allocator > operator+ (BasicString< Allocator > &&lhs, const BasicString< Allocator > &rhs); SWS_CORE_03353template <typename Allocator> BasicString< Allocator > operator+ (const BasicString< Allocator > &lhs, BasicString< Allocator > &&rhs); SWS_CORE_03354template <typename Allocator> BasicString< Allocator > operator+ (BasicString< Allocator > &&lhs, BasicString< Allocator > &&rhs); SWS_CORE_03355template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (const charT *lhs, const Basic String< Allocator > &rhs); SWS_CORE_03356template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (const charT *lhs, BasicString< Allocator > &&rhs); SWS_CORE_03357template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (charT lhs, const BasicString< Allocator > &rhs); SWS_CORE_03358template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (charT lhs, BasicString< Allocator > &&rhs); SWS_CORE_03359template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (const BasicString< Allocator > &lhs, const charT *rhs); SWS_CORE_03360template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (BasicString< Allocator > &&lhs, const charT *rhs); SWS_CORE_03361template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (const BasicString< Allocator > &lhs, charT rhs); SWS_CORE_03362template <typename Allocator, typename charT = typename std::allocator_traits<Allocator>::value_type> BasicString< Allocator > operator+ (BasicString< Allocator > &&lhs, charT rhs); SWS_CORE_03363Ein-/Ausgabe getline << >> 6
template <class charT = char, class traits = std::char_traits<char>, class Allocator = ara::core::PolymorphicAllocator<char>> std::basic_istream< charT, traits > & getline (std::basic_istream< charT, traits > &is, BasicString< Allocator > &str, charT delim); SWS_CORE_03401template <class charT = char, class traits = std::char_traits<char>, class Allocator = ara::core::PolymorphicAllocator<char>> std::basic_istream< charT, traits > & getline (std::basic_istream< charT, traits > &&is, BasicString< Allocator > &str, charT delim); SWS_CORE_03402template <class charT = char, class traits = std::char_traits<char>, class Allocator = ara::core::PolymorphicAllocator<char>> std::basic_istream< charT, traits > & getline (std::basic_istream< charT, traits > &is, BasicString< Allocator > &str); SWS_CORE_03403template <class charT = char, class traits = std::char_traits<char>, class Allocator = ara::core::PolymorphicAllocator<char>> std::basic_istream< charT, traits > & getline (std::basic_istream< charT, traits > &&is, BasicString< Allocator > &str); SWS_CORE_03404template <class charT = char, class traits = std::char_traits<char>, class Allocator = ara::core::PolymorphicAllocator<char>> std::basic_ostream< charT, traits > & operator<< (std::basic_ostream< charT, traits > &os, const BasicString< Allocator > &str); SWS_CORE_03400template <class charT = char, class traits = std::char_traits<char>, class Allocator = ara::core::PolymorphicAllocator<char>> std::basic_istream< charT, traits > & operator>> (std::basic_istream< charT, traits > &is, BasicString< Allocator > &str); SWS_CORE_03399Konvertierung to_string 9
String to_string (int val); SWS_CORE_03382String to_string (unsigned val); SWS_CORE_03383String to_string (long val); SWS_CORE_03384String to_string (unsigned long val); SWS_CORE_03385String to_string (long long val); SWS_CORE_03386String to_string (unsigned long long val); SWS_CORE_03387String to_string (float val); SWS_CORE_03388String to_string (double val); SWS_CORE_03389String to_string (long double val); SWS_CORE_03390Tausch swap 1
template <typename Allocator> void swap (BasicString< Allocator > &lhs, BasicString< Allocator > &rhs); SWS_CORE_03296Weitere stod stof stoi stol stold stoll stoul stoull 8
double stod (const ara::core::String &str, size_t *idx=nullptr); SWS_CORE_03397float stof (const ara::core::String &str, size_t *idx=nullptr); SWS_CORE_03396int stoi (const ara::core::String &str, size_t *idx=nullptr, int base=10); SWS_CORE_03391long stol (const ara::core::String &str, size_t *idx=nullptr, int base=10); SWS_CORE_03392long double stold (const ara::core::String &str, size_t *idx=nullptr); SWS_CORE_03398long long stoll (const ara::core::String &str, size_t *idx=nullptr, int base=10); SWS_CORE_03394unsigned long stoul (const ara::core::String &str, size_t *idx=nullptr, int base=10); SWS_CORE_03393unsigned long long stoull (const ara::core::String &str, size_t *idx=nullptr, int base=10); SWS_CORE_03395Implementation of std::bitset type from [bitset] ≙ std::bitset
Ein-/Ausgabe << >> 2
template <class CharT = char, class Traits = std::char_traits<CharT>, std::size_t N> std::basic_ostream< CharT, Traits > & operator<< (std::basic_ostream< CharT, Traits > &os, const Bitset< N > &x); SWS_CORE_01756template <class CharT, class Traits, std::size_t N> std::basic_istream< CharT, Traits > & operator>> (std::basic_istream< CharT, Traits > &is, Bitset< N > &x); SWS_CORE_01755Weitere & | ˆ 3
template <std::size_t N> Bitset< N > operator& (const Bitset< N > &, const Bitset< N > &) noexcept; SWS_CORE_01752template <std::size_t N> Bitset< N > operator| (const Bitset< N > &, const Bitset< N > &) noexcept; SWS_CORE_01753template <std::size_t N> Bitset< N > operatorˆ (const Bitset< N > &, const Bitset< N > &) noexcept; SWS_CORE_01754An error domain for errors originating from the ara::core Functional Cluster.
erbt von ErrorDomain
Exception type thrown for ara::core errors.
erbt von Exception
Encapsulation of an error code
Erzeugung MakeErrorCode 2
constexpr ErrorCode MakeErrorCode (FutureErrc code, Error Domain::SupportDataType data) noexcept; SWS_CORE_00490constexpr ErrorCode MakeErrorCode (CoreErrc code, ErrorDomain::Support DataType data) noexcept; SWS_CORE_05290Vergleich != == 2
constexpr bool operator!= (const ErrorCode &lhs, const ErrorCode &rhs) noexcept; SWS_CORE_00572constexpr bool operator== (const ErrorCode &lhs, const ErrorCode &rhs) noexcept; SWS_CORE_00571Encapsulation of an ErrorDomain
Basis für CoreErrorDomain, FutureErrorDomain
Base type for all ARA exception types
erbt von std::exception
Basis für CoreException, FutureException
Provides an interface for a executing context, which asynchronously invokes Callable ([4] [func.wrap.func]) objects in a guaranteed thread-s
Implementation of std::future from [future.syn] in [11] ≙ std::future
Spezialisierungen Future< void, E >
Error domain for errors originating from ara::core::Future and ara::core::Promise
erbt von ErrorDomain
Exception type thrown by ara::core::Future and ara::core::Promise
erbt von Exception
≙ [bitset]
Denote an index-distinguishing operation to be performed in-place
Denote an operation to be performed in-place
Denote a type-distinguishing operation to be performed in-place
Representation of an AUTOSAR Instance Specifier, which is basically an AUTOSAR shortName path wrapper.
Vergleich != == 2
bool operator!= (ara::core::StringView lhs, const InstanceSpecifier &rhs) noexcept; SWS_CORE_08082bool operator== (ara::core::StringView lhs, const InstanceSpecifier &rhs) noexcept; SWS_CORE_08081As per std::is_nothrow_swappable, see [meta.unary.prop] in [11] ≙ std::is_nothrow_swappable
Implementation of std::pmr::map container from [map] ≙ std::pmr::map
Tausch swap 1
template <class Key, class T, class Compare, class Allocator> void swap (Map< Key, T, Compare, Allocator > &lhs, Map< Key, T, Compare, Allocator > &rhs) noexcept(noexcept(lhs.swap(rhs))); SWS_CORE_01496Implementation of std::pmr::memory_resource type from [mem.res.class] ≙ std::pmr::memory_resource
Basis für MonotonicBufferResource, SynchronizedPoolResource, UnsynchronizedPoolResource
Vergleich == 1
bool operator== (const MemoryResource &a, const MemoryResource &b) noexcept; SWS_CORE_06561≙ [variant]
Zugriff get get_if holds_alternative visit 15
template <std::size_t I, typename... Types> constexpr variant_alternative_t< I, Variant< Types... > > & get ( Variant< Types... > &variant) noexcept; SWS_CORE_01613template <std::size_t I, typename... Types> constexpr variant_alternative_t< I, Variant< Types... > > && get ( Variant< Types... > &&variant) noexcept; SWS_CORE_01614template <std::size_t I, typename... Types> constexpr const variant_alternative_t< I, Variant< Types... > > & get (const Variant< Types... > &variant) noexcept; SWS_CORE_01615template <std::size_t I, typename... Types> constexpr const variant_alternative_t< I, Variant< Types... > > && get (const Variant< Types... > &&variant) noexcept; SWS_CORE_01616template <typename T, typename... Types> constexpr T & get (Variant< Types... > &variant) noexcept; SWS_CORE_01617template <typename T, typename... Types> constexpr T && get (Variant< Types... > &&variant) noexcept; SWS_CORE_01618template <typename T, typename... Types> constexpr const T & get (const Variant< Types... > &variant) noexcept; SWS_CORE_01619template <typename T, typename... Types> constexpr const T && get (const Variant< Types... > &&variant) noexcept; SWS_CORE_01620template <std::size_t I, typename... Types> std::add_pointer_t< variant_alternative_t< I, Variant< Types... > > > get_if (Variant< Types... > *variant) noexcept; SWS_CORE_01621template <std::size_t I, typename... Types> std::add_pointer_t< const variant_alternative_t< I, Variant< Types... > > > get_if (const Variant< Types... > *variant) noexcept; SWS_CORE_01622template <typename T, typename... Types> std::add_pointer_t< T > get_if (Variant< Types... > *variant) noexcept; SWS_CORE_01623template <typename T, typename... Types> std::add_pointer_t< const T > get_if (const Variant< Types... > *variant) noexcept; SWS_CORE_01624template <typename T, typename... Types> constexpr bool holds_alternative (const Variant< Types... > &variant) noexcept; SWS_CORE_01626template <typename ReturnType, typename Visitor, typename... Variants> constexpr {<invoke-result-decltype-1>} visit (Visitor &&visitor, Variants &&... variants); SWS_CORE_01633template <typename Visitor, typename... Variants> constexpr {<invoke-result-decltype-2>} visit (Visitor &&visitor, Variants &&... variants); SWS_CORE_01634Vergleich != < <= == > >= 12
template <typename... Types> constexpr bool operator!= (const Variant< Types... > &lhs, const Variant< Types... > &rhs); SWS_CORE_01628constexpr bool operator!= (Monostate lhs, Monostate rhs) noexcept; SWS_CORE_01642template <typename... Types> constexpr bool operator< (const Variant< Types... > &lhs, const Variant< Types... > &rhs); SWS_CORE_01629constexpr bool operator< (Monostate lhs, Monostate rhs) noexcept; SWS_CORE_01643template <typename... Types> constexpr bool operator<= (const Variant< Types... > &lhs, const Variant< Types... > &rhs); SWS_CORE_01631constexpr bool operator<= (Monostate lhs, Monostate rhs) noexcept; SWS_CORE_01645template <typename... Types> constexpr bool operator== (const Variant< Types... > &lhs, const Variant< Types... > &rhs); SWS_CORE_01627constexpr bool operator== (Monostate lhs, Monostate rhs) noexcept; SWS_CORE_01641template <typename... Types> constexpr bool operator> (const Variant< Types... > &lhs, const Variant< Types... > &rhs); SWS_CORE_01630constexpr bool operator> (Monostate lhs, Monostate rhs) noexcept; SWS_CORE_01644template <typename... Types> constexpr bool operator>= (const Variant< Types... > &lhs, const Variant< Types... > &rhs); SWS_CORE_01632constexpr bool operator>= (Monostate lhs, Monostate rhs) noexcept; SWS_CORE_01646Tausch swap 1
template <typename... Types> void swap (Variant< Types... > &lhs, Variant< Types... > &rhs) noexcept(noexcept(lhs.swap(rhs))); SWS_CORE_01696Implementation of std::pmr::monotonic_buffer_resource type from [mem.res.monotonic.buffer] ≙ std::pmr::monotonic_buffer_resource
erbt von MemoryResource
Shall implement std::nullopt_t ≙ std::nullopt_t
Implementation of std::optional
Spezialisierungen Optional< T & >
Erzeugung make_optional 3
template <typename T> constexpr Optional< std::decay_t< T > > make_optional (T &&) noexcept(std::is_nothrow_move_constructible< T >::value); SWS_CORE_01138template <typename T, typename... Args> constexpr Optional< T > make_optional (Args &&... args) noexcept(std::is_nothrow_constructible< T, Args... >::value); SWS_CORE_01139template <typename T, typename U, typename... Args> constexpr Optional< T > make_optional (std::initializer_list< U > il, Args &&... args) noexcept(std::is_nothrow_constructible< T, std::initializer_list< U > &, Args &&... >::value); SWS_CORE_01140Vergleich != < <= == > >= 30
template <typename T, typename U> constexpr bool operator!= (const Optional< T > &, const Optional< U > &); SWS_CORE_01143template <typename T, typename U> constexpr bool operator!= (const Optional< T > &, const U &); SWS_CORE_01176template <typename T, typename U> constexpr bool operator!= (const U &, const Optional< T > &); SWS_CORE_01177template <typename T> constexpr bool operator!= (const Optional< T > &, nullopt_t) noexcept; SWS_CORE_01188template <typename T> constexpr bool operator!= (nullopt_t, const Optional< T > &) noexcept; SWS_CORE_01189template <typename T, typename U> constexpr bool operator< (const Optional< T > &, const Optional< U > &); SWS_CORE_01144template <typename T, typename U> constexpr bool operator< (const Optional< T > &, const U &); SWS_CORE_01178template <typename T, typename U> constexpr bool operator< (const U &, const Optional< T > &); SWS_CORE_01179template <typename T> constexpr bool operator< (const Optional< T > &, nullopt_t) noexcept; SWS_CORE_01190template <typename T> constexpr bool operator< (nullopt_t, const Optional< T > &) noexcept; SWS_CORE_01191template <typename T, typename U> constexpr bool operator<= (const Optional< T > &, const Optional< U > &); SWS_CORE_01146template <typename T, typename U> constexpr bool operator<= (const Optional< T > &, const U &); SWS_CORE_01180template <typename T, typename U> constexpr bool operator<= (const U &, const Optional< T > &); SWS_CORE_01181template <typename T> constexpr bool operator<= (const Optional< T > &, nullopt_t) noexcept; SWS_CORE_01192template <typename T> constexpr bool operator<= (nullopt_t, const Optional< T > &) noexcept; SWS_CORE_01193template <typename T, typename U> constexpr bool operator== (const Optional< T > &, const Optional< U > &); SWS_CORE_01142template <typename T, typename U> constexpr bool operator== (const Optional< T > &, const U &); SWS_CORE_01148template <typename T, typename U> constexpr bool operator== (const U &, const Optional< T > &); SWS_CORE_01149template <typename T> constexpr bool operator== (const Optional< T > &, nullopt_t) noexcept; SWS_CORE_01186template <typename T> constexpr bool operator== (nullopt_t, const Optional< T > &) noexcept; SWS_CORE_01187template <typename T, typename U> constexpr bool operator> (const Optional< T > &, const Optional< U > &); SWS_CORE_01145template <typename T, typename U> constexpr bool operator> (const Optional< T > &, const U &); SWS_CORE_01182template <typename T, typename U> constexpr bool operator> (const U &, const Optional< T > &); SWS_CORE_01183template <typename T> constexpr bool operator> (const Optional< T > &, nullopt_t) noexcept; SWS_CORE_01194template <typename T> constexpr bool operator> (nullopt_t, const Optional< T > &) noexcept; SWS_CORE_01195template <typename T, typename U> constexpr bool operator>= (const Optional< T > &, const Optional< U > &); SWS_CORE_01147template <typename T, typename U> constexpr bool operator>= (const Optional< T > &, const U &); SWS_CORE_01184template <typename T, typename U> constexpr bool operator>= (const U &, const Optional< T > &); SWS_CORE_01185template <typename T> constexpr bool operator>= (const Optional< T > &, nullopt_t) noexcept; SWS_CORE_01196template <typename T> constexpr bool operator>= (nullopt_t, const Optional< T > &) noexcept; SWS_CORE_01197Tausch swap 1
template <typename T> void swap (Optional< T > &lhs, Optional< T > &rhs) noexcept(std::is_ nothrow_move_constructible< T >::value &&std::is_nothrow_move_ assignable< T >::value); SWS_CORE_01096Implementation of std::pmr::polymorphic_allocator from [mem.poly.allocator.class] ≙ std::pmr::polymorphic_allocator
Vergleich == 1
template <class T1, class T2> bool operator== (const PolymorphicAllocator< T1 > &a, const PolymorphicAllocator< T2 > &b) noexcept; SWS_CORE_06560Implementation of std::pmr::pool_options from [mem.poly.pool_options.class] ≙ std::pmr::pool_options
ara::core specific variant of std::promise class The implementation shall flag the condition E!=ara::core::ErrorCode as a compile error. ≙ std::promise
Spezialisierungen Promise< void, E >
This class is a type that contains either a value or an error
Spezialisierungen Result< T &, E > Result< void, E >
Vergleich != == 10
template <typename T, typename E> bool operator!= (const Result< T, E > &lhs, const Result< T, E > &rhs); SWS_CORE_00781template <typename T, typename E> bool operator!= (const Result< T, E > &lhs, const T &rhs); SWS_CORE_00784template <typename T, typename E> bool operator!= (const T &lhs, const Result< T, E > &rhs); SWS_CORE_00785template <typename T, typename E> bool operator!= (const Result< T, E > &lhs, const E &rhs); SWS_CORE_00788template <typename T, typename E> bool operator!= (const E &lhs, const Result< T, E > &rhs); SWS_CORE_00789template <typename T, typename E> bool operator== (const Result< T, E > &lhs, const Result< T, E > &rhs); SWS_CORE_00780template <typename T, typename E> bool operator== (const Result< T, E > &lhs, const T &rhs); SWS_CORE_00782template <typename T, typename E> bool operator== (const T &lhs, const Result< T, E > &rhs); SWS_CORE_00783template <typename T, typename E> bool operator== (const Result< T, E > &lhs, const E &rhs); SWS_CORE_00786template <typename T, typename E> bool operator== (const E &lhs, const Result< T, E > &rhs); SWS_CORE_00787Tausch swap 1
template <typename T, typename E> void swap (Result< T, E > &lhs, Result< T, E > &rhs) noexcept(noexcept(lhs.Swap(rhs))); SWS_CORE_00796Implementation of std::span container from [views.span] ≙ std::span
Erzeugung MakeSpan 5
template <typename T> constexpr Span< T > MakeSpan (T *ptr, typename Span< T >::size_type count) noexcept; SWS_CORE_01990template <typename T> constexpr Span< T > MakeSpan (T *firstElem, T *lastElem) noexcept; SWS_CORE_01991template <typename T, std::size_t N> constexpr Span< T, N > MakeSpan (T(&arr)[N]) noexcept; SWS_CORE_01992template <typename Container> constexpr Span< typename Container::value_type > MakeSpan (Container &cont) noexcept; SWS_CORE_01993template <typename Container> constexpr Span< typename Container::value_type const > MakeSpan (const Container &cont) noexcept; SWS_CORE_01994This clock represents a monotonic clock
Implementation of std::basic_string_view type from [string.view] ≙ std::basic_string_view
Vergleich != < <= == > >= 6
constexpr bool operator!= (StringView lhs, StringView rhs) noexcept; SWS_CORE_02182constexpr bool operator< (StringView lhs, StringView rhs) noexcept; SWS_CORE_02183constexpr bool operator<= (StringView lhs, StringView rhs) noexcept; SWS_CORE_02185constexpr bool operator== (StringView lhs, StringView rhs) noexcept; SWS_CORE_02181constexpr bool operator> (StringView lhs, StringView rhs) noexcept; SWS_CORE_02184constexpr bool operator>= (StringView lhs, StringView rhs) noexcept; SWS_CORE_02186Ein-/Ausgabe << 1
std::ostream & operator<< (std::ostream &os, StringView sv); SWS_CORE_02187Implementation of std::pmr::synchronized_pool_resource from [mem.res.pool] ≙ std::pmr::synchronized_pool_resource
erbt von MemoryResource
Implementation of std::pmr::unsynchronized_pool_resource from [mem.res.pool] ≙ std::pmr::unsynchronized_pool_resource
erbt von MemoryResource
Implementation of std::variant type from [basic.string] ≙ std::variant
≙ [variant]
Spezialisierungen variant_size< Variant< Types... > > variant_size< const volatile T > variant_size< const T > variant_size< volatile T >
Implementation of std::pmr::vector container from [vector] ≙ std::pmr::vector
Vergleich != < <= == > >= 6
template <typename T, typename Allocator> bool operator!= (const Vector< T, Allocator > &lhs, const Vector< T, Allocator > &rhs); SWS_CORE_01391template <typename T, typename Allocator> bool operator< (const Vector< T, Allocator > &lhs, const Vector< T, Allocator > &rhs); SWS_CORE_01392template <typename T, typename Allocator> bool operator<= (const Vector< T, Allocator > &lhs, const Vector< T, Allocator > &rhs); SWS_CORE_01393template <typename T, typename Allocator> bool operator== (const Vector< T, Allocator > &lhs, const Vector< T, Allocator > &rhs); SWS_CORE_01390template <typename T, typename Allocator> bool operator> (const Vector< T, Allocator > &lhs, const Vector< T, Allocator > &rhs); SWS_CORE_01394template <typename T, typename Allocator> bool operator>= (const Vector< T, Allocator > &lhs, const Vector< T, Allocator > &rhs); SWS_CORE_01395Tausch swap 1
template <typename T, typename Allocator> void swap (Vector< T, Allocator > &lhs, Vector< T, Allocator > &rhs) noexcept(noexcept(lhs.swap(rhs))); SWS_CORE_01396Abort the current operation This function will never return to its caller. The stack is not unwound: destructors of variables with automatic storage duration are not called. Calling this function is ill-formed if any of the arguments is not convertible to ara::core:: StringView.
template <typename... Args> [[noreturn]] void Abort (const Args &... args) noexcept;A function declaration with the correct prototype for ara::core::SetAbortHandler This declaration exists only for providing a function type that includes noexcept and that acts as base type for a type alias, which is defined in [SWS_CORE_00050]. This compensates for the fact that the C++ standard (up to and including C++14) prohibits that noexcept appears in an alias-declaration. There is no implementation of this function.
void AbortHandlerPrototype () noexcept;Add a custom Abort handler function. Implementations support at least 8 AbortHandlers. Implementation false is returned when either the implementation-defined limit for number of abort handlers
bool AddAbortHandler (AbortHandler handler) noexcept;≙ [views.span]
template <typename ElementType, std::size_t Extent> Span< const Byte, Extent==dynamic_extent ? dynamic_extent :sizeof(ElementType) *Extent > as_bytes (Span< ElementType, Extent > s) noexcept;≙ [views.span]
template <typename ElementType, std::size_t Extent> Span< Byte, Extent==dynamic_extent ? dynamic_extent :sizeof(Element Type) *Extent > as_writable_bytes (Span< ElementType, Extent > s) noexcept;Return a pointer to the block of memory that contains the elements of a container.
Überladungen data 4
template <typename Container> constexpr auto data (Container &c) noexcept(noexcept(c.data())) -> decltype(c.data()); SWS_CORE_04110template <typename Container> constexpr auto data (const Container &c) noexcept(noexcept(c.data())) -> decltype(c.data()); SWS_CORE_04111template <typename T, std::size_t N> constexpr T * data (T(&array)[N]) noexcept; SWS_CORE_04112template <typename E> constexpr const E * data (std::initializer_list< E > il) noexcept; SWS_CORE_04113Shutdown of the ARA Framework After this call, no interaction with the ARA is allowed with the exception of types intended to be used independently of initialization as defined in [SWS_CORE_15002]. As a prerequisite to calling this API it is expected that the use of ARA interfaces has completed (with the given exceptions). It is strongly recommended to make this call in a place where it is guaranteed that the static initialization has completed and destruction of statically initialized data has not yet started.
Result< void > Deinitialize () noexcept;Return whether the given container is empty
Überladungen empty 3
template <typename Container> constexpr auto empty (const Container &c) noexcept(noexcept(c.empty())) -> decltype(c.empty()); SWS_CORE_04130template <typename T, std::size_t N> constexpr bool empty (const T(&array)[N]) noexcept; SWS_CORE_04131template <typename E> constexpr bool empty (std::initializer_list< E > il) noexcept; SWS_CORE_04132Return a reference to the global ara::core::CoreErrorDomain
constexpr const ErrorDomain & GetCoreErrorDomain () noexcept;except for the following deviations: 1. Description references to std::pmr::new_delete_resource() are replaced by ara:: core::NewDeleteResource() 2. Description references to std::pmr::set_default_resource() are replaced by ara:: core::SetDefaultResource() 3. Return type std::pmr::memory_resource is replaced with ara::core:: MemoryResource ≙ std::pmr::new_delete_resource
MemoryResource * GetDefaultResource () noexcept;Obtain the reference to the single global ara::core::FutureErrorDomain instance.
constexpr const ErrorDomain & GetFutureErrorDomain () noexcept;Initialization of the ARA framework. Prior to this call, interaction with the ARA is not allowed with the exception of types intended to be used independently of initialization as defined in [SWS_CORE_15002]. It is strongly recommended to make this call in a place where it is guaranteed that static initialization has completed.
Result< void > Initialize (int &argc, char **argv) noexcept;except for the following deviations: 1. Return type std::pmr::memory_resource is replaced with ara::core:: MemoryResource ≙ std::pmr::memory_resource
MemoryResource * NewDeleteResource () noexcept;except for the following deviations: 1. Return type std::pmr::memory_resource is replaced with ara::core:: MemoryResource 2. It’s allocate() function returns nullptr instead of throwing std::bad_alloc ≙ std::pmr::memory_resource
MemoryResource * NullMemoryResource () noexcept;Add a custom Abort handler function and return the most recently added one. By setting nullptr, the implementation may restore the default handler instead; this will remove all previously installed handlers. Implementation This function can be called from multiple threads simultaneously; these calls are performed in an
AbortHandler SetAbortHandler (AbortHandler handler) noexcept;except for the following deviations: 1. Description references to std::pmr::new_delete_resource() are replaced by ara:: core::NewDeleteResource() 2. Description references to std::pmr::get_default_resource() are replaced by ara:: core::GetDefaultResource() 3. Return type std::pmr::memory_resource is replaced with ara::core:: MemoryResource ≙ std::pmr::new_delete_resource
MemoryResource * SetDefaultResource (MemoryResource *r) noexcept;Return the size of a container
Überladungen size 2
template <typename Container> constexpr auto size (const Container &c) noexcept(noexcept(c.size())) -> decltype(c.size()); SWS_CORE_04120template <typename T, std::size_t N> constexpr std::size_t size (const T(&array)[N]) noexcept; SWS_CORE_04121Defines all errors of the ara::core Functional Cluster
enum class CoreErrc : ErrorDomain::CodeType {...};Specifies the errors that can occur upon calling Future::get() or Future::GetResult().
enum class FutureErrc : ara::core::ErrorDomain::CodeType {...};Specifies the status of a ara::core::Future as returned by: • Future<T,E>::wait_for() • Future<void,E>::wait_for() • Future<T,E>::wait_until() • Future<void,E>::wait_until() These definitions are equivalent to the ones from std::future_status. However, no item equivalent to std::future_status::deferred is available here. Implementation The numerical values of the enum literals are implementation-defined ≙ std::future_status
enum class FutureStatus : std::uint8_t {...};The type of a handler for ara::core::SetAbortHandler
using AbortHandler = decltype(&AbortHandlerPrototype);A non-integral binary type. The requirements on this type are stated in "See also:" Implementation {<byte-type>} shall be an implementation-defined type
using Byte = {<byte-type>};≙ [basic.string]
using String = BasicString<>;≙ [variant]
using variant_alternative_t = typename variant_alternative<I, T>::type;≙ [views.span]
constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_ t>::max();The singleton instance of ara::core::in_place_t
constexpr in_place_t in_place;The singleton instances (one for each I of ara::core::in_place_index_t
template <std::size_t Index> constexpr in_place_index_t<Index> in_place_index {};The singleton instances (one for each T) of ara::core::in_place_type_t
template <typename T> constexpr in_place_type_t<T> in_place_type;≙ [variant]
template <typename T> constexpr std::size_t variant_size_v = variant_size<T>::value;ara::core::literals::string_view_literals
≙ [string.view]
constexpr StringView operator""_SV (const char *str, std::size_t len) noexcept;std
Specialization of std::hash (hashing function for ara::core::Monostate) ≙ std::hash
Spezialisierungen hash< ara::core::Optional< T > hash< ara::core::String > hash< ara::core::StringView > hash< ara::core::Variant< hash< ara::core::Vector< T, Allocator > >
≙ [array]
≙ [array]
Namespaces
- ara::core 50 Klassen, 194 freie Funktionen
- ara::core::literals::string_view_literals 0 Klassen, 1 freie Funktionen
- std 8 Klassen, 0 freie Funktionen
UML-Klassendiagramm des Moduls
Abgerundete Rahmen = Namespaces; hohle Dreieckspfeile = Vererbung (zeigt zur Basisklasse); graue Boxen = modulfremde bzw. externe Basisklassen. Klicken öffnet die Klassenseite.
gemini-3.8-flash-medium· 2026-10-13