मॉड्यूल ara::core — Adaptive Platform Core
मॉड्यूल गाइडएआई जनित
प्लेटफ़ॉर्म-व्यापी C++ आधार प्रकार, दोष-सुरक्षित परिणाम प्रकार और नियतात्मक मेमोरी पूल प्रदान करता है।
प्लेटफ़ॉर्म-व्यापी C++ आधार प्रकार, दोष-सुरक्षित परिणाम प्रकार और नियतात्मक मेमोरी पूल प्रदान करता है।
मॉड्यूल core AUTOSAR Adaptive Platform (SWArchitecture पृ. 60, [SWS_CORE_00326]) के लिए प्लेटफ़ॉर्म-व्यापी आधार प्रकार, PMR मेमोरी पूल और एसिंक्रोनस सिंक्रोनाइज़ेशन प्रिमिटिव Future और Promise प्रदान करता है। सख्त सुरक्षा और वास्तविक समय की आवश्यकताओं को पूरा करने के लिए, सम टाइप (योग प्रकार) Result<T, E> पारंपरिक एक्सेप्शनों को नियतात्मक रिटर्न मानों ([SWS_CORE_00751]) से प्रतिस्थापित करता है। अपूरणीय सिस्टम त्रुटियों के मामले में, फ़ेल-फ़ास्ट फ़ंक्शन Abort() तत्काल, नियंत्रित प्रक्रिया समाप्ति सुनिश्चित करता है ([SWS_CORE_00052])।
मॉड्यूल core AUTOSAR Adaptive Platform के बुनियादी कार्यात्मक क्लस्टर के रूप में कार्य करता है और सभी प्लेटफ़ॉर्म सेवाओं और अनुप्रयोगों के लिए एकीकृत डेटा संरचनाएं, एसिंक्रोनस संचार प्रिमिटिव और मेमोरी प्रबंधन तंत्र प्रदान करता है (SWArchitecture पृ. 60)। POSIX ऑपरेटिंग सिस्टम परिवेशों में नियतात्मक प्रक्रियाओं और कार्यात्मक सुरक्षा की गारंटी के लिए, core पारंपरिक C++ एक्सेप्शनों को टाइप-सुरक्षित परिणाम प्रकार Result<T, E> से प्रतिस्थापित करता है और बहुरूपी एलोकेटरों ([SWS_CORE_00041], [SWS_CORE_00751]) के माध्यम से गतिशील मेमोरी आवंटन को नियंत्रित करता है।
संदर्भ आरेख: Adaptive Platform में कार्यात्मक क्लस्टर ara::core और इसके इंटरफ़ेस क्षेत्रों का समावेश। स्रोत: SWArchitecture पृ. 60, SWArchitecture पृ. 36
समवर्ती सिंक्रोनाइज़ेशन के लिए, core Future और Promise के अंतःक्रिया को लागू करता है ([SWS_CORE_00326], [SWS_CORE_00344])। जबकि निर्माता Promise के माध्यम से गणना स्थिति या त्रुटि प्रदान करता है, Future उपभोक्ता को wait_for() के माध्यम से समय-निगरानी क्वेरी और then() ([SWS_CORE_00329], [SWS_CORE_00331], TimeSynchronization पृ. 90) के माध्यम से प्रतिक्रियाशील अग्रेषण दोनों की अनुमति देता है।
गतिविधि आरेख: त्रुटि-मुक्त मामले में और त्रुटि की स्थिति में Result ऑब्जेक्ट का नियतात्मक मूल्यांकन पथ। स्रोत: [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]
फ़्रैगमेंटेशन से बचने के लिए, मॉड्यूल SynchronizedPoolResource और UnsynchronizedPoolResource जैसे पूल संसाधन प्रदान करता है, जो आवंटन को निश्चित आकार के चंक्स तक सीमित करते हैं ([SWS_CORE_00030], [SWS_CORE_00067], SWArchitecture पृ. 61)। यदि कोई असाध्य त्रुटि स्थिति उत्पन्न होती है, तो प्लेटफ़ॉर्म पंजीकृत AbortHandler के पूर्व निष्पादन के तहत Abort() के माध्यम से प्रक्रिया की तत्काल फ़ेल-फ़ास्ट समाप्ति लागू करता है ([SWS_CORE_00051], [SWS_CORE_00052])।
ara::core की सिस्टम भूमिका और वास्तुकला आधार
मॉड्यूल core AUTOSAR Adaptive Platform की मौलिक नींव बनाता है और सभी कार्यात्मक क्लस्टरों और Adaptive Applications (SWArchitecture पृ. 60) के लिए मौलिक प्रकार परिभाषाएँ, मेमोरी प्रबंधन तंत्र और आधार इंटरफ़ेस प्रदान करता है। अनुप्रयोग-विशिष्ट सेवाओं के विपरीत, core प्रक्रिया-स्थानीय (प्रोसेस-लोकल) रूप से डिज़ाइन किया गया है और POSIX ऑपरेटिंग सिस्टम परिवेशों के भीतर पोर्टेबल, नियतात्मक और संसाधन-कुशल C++ सॉफ़्टवेयर को लागू करने के लिए आवश्यक अमूर्तता को परिभाषित करता है (SWArchitecture पृ. 36)।
वास्तुशिल्प रूप से, यह मॉड्यूल हार्डवेयर-निकट ऑपरेटिंग सिस्टम फ़ंक्शनों और Adaptive Platform की उच्च परतों (SWArchitecture पृ. 60) के बीच एक मानकीकृत इंटरफ़ेस के रूप में कार्य करता है। इस प्रक्रिया में, core कार्यात्मक सुरक्षा (ASIL) और रीयल-टाइम क्षमता के लिए केंद्रीय आवश्यकताओं को संबोधित करता है, गतिशील मेमोरी आवंटन को नियंत्रणीय बनाकर और नियमित नियंत्रण प्रवाह ([SWS_CORE_00052], [SWS_CORE_00751]) में C++ एक्सेप्शनों के व्यापक उपयोग से बचकर। प्लेटफ़ॉर्म-व्यापी आधार प्रकारों का प्रावधान ara::com या ara::ts (ARAComAPI पृ. 46, TimeSynchronization पृ. 90) जैसे मिडलवेयर घटकों के बीच स्वामित्व वाले पृथक समाधानों को रोकता है।
संदर्भ आरेख: Adaptive Platform में कार्यात्मक क्लस्टर ara::core और इसके इंटरफ़ेस क्षेत्रों का समावेश। स्रोत: SWArchitecture पृ. 60, SWArchitecture पृ. 36
Future और Promise के माध्यम से एसिंक्रोनस नियंत्रण और डेटा प्रवाह
समवर्ती और विकेंद्रीकृत (डीकपल्ड) इंटरैक्शन के लिए, ara::core Promise और Future के माध्यम से प्रोड्यूसर-कंज्यूमर पैटर्न को लागू करता है ([SWS_CORE_00326], [SWS_CORE_00341])। एक Promise उस राइटिंग इंटरफ़ेस का प्रतिनिधित्व करता है जिसके माध्यम से एक एसिंक्रोनस वर्कर या एक कम्युनिकेशन स्केलेटन परिणाम अथवा एरर को दर्ज करता है ([SWS_CORE_00345], [SWS_CORE_00353])। इसका उपभोग करने वाला समकक्ष Future बनाता है, जो साझा स्थिति (Shared State) की निगरानी करता है और रिटर्न मान तक टाइप-सुरक्षित एक्सेस को एनकैप्सुलेट करता है (ARAComAPI पृ. 46, ARAComAPI पृ. 59)।
क्लाइंट थ्रेड्स के ब्लॉकिंग से बचने के लिए, Future सिंक्रोनस, ब्लॉकिंग क्वेरी फ़ंक्शन get() ([SWS_CORE_00326]) के अलावा समय-सीमित प्रतीक्षा संचालन प्रदान करता है: wait_for() और wait_until() FutureStatus प्रकार का एक स्टेटस इंडिकेटर लौटाते हैं ([SWS_CORE_00329], [SWS_CORE_00330], ARAComAPI पृ. 1)। then() मेथड के माध्यम से कॉलबैक पंजीकृत किए जा सकते हैं, जो परिणाम प्राप्त होने पर स्वचालित रूप से निष्पादित होते हैं; वैकल्पिक रूप से, निष्पादन को विशिष्ट थ्रेड पूल्स पर निर्देशित करने के लिए एक उपयोगकर्ता-विशिष्ट Executor को एकीकृत किया जा सकता है ([SWS_CORE_00024], [SWS_CORE_00331], [SWS_CORE_00337])। अनन्य स्वामित्व सुनिश्चित करने के लिए Future और Promise के लिए कॉपी ऑपरेशन स्पष्ट रूप से प्रतिबंधित हैं ([SWS_CORE_00334], [SWS_CORE_00350])।
सीक्वेंस आरेख: Promise और Future के माध्यम से वर्कर और एप्लिकेशन के बीच एसिंक्रोनस मान और एरर ट्रांसमिशन। स्रोत: [SWS_CORE_00326], [SWS_CORE_00329], [SWS_CORE_00344], [SWS_CORE_00345], TimeSynchronization पृ. 90
डिटरमिनिस्टिक एरर मैनेजमेंट: Result, ErrorCode और ErrorDomain
Adaptive Platform में सुरक्षा-उन्मुख प्रोग्रामिंग का एक मुख्य पहलू नियमित संचालन में अनियंत्रित एक्सेप्शन से सख्ती से बचना है। ara::core::Result<T, E> एक टाइप-सुरक्षित सम-टाइप एनकैप्सुलेशन के रूप में कार्य करता है, जिसमें या तो T प्रकार का एक सफलता-पेलोड मान या E प्रकार का एक एरर ऑब्जेक्ट होता है ([SWS_CORE_00721], [SWS_CORE_00723], [SWS_CORE_00751])। संदर्भ प्रकारों Result<T&, E> और बिना रिटर्न मान वाले ऑपरेशनों Result<void, E> दोनों के लिए विशिष्टताएँ मौजूद हैं ([SWS_CORE_00821], [SWS_CORE_00908])।
समाविष्ट स्थिति की जाँच HasValue() या स्पष्ट रूपांतरण ऑपरेटर operator bool() के माध्यम से की जाती है ([SWS_CORE_00751], [SWS_CORE_00752])। पेलोड डेटा तक पहुँचना Value() या operator*() के माध्यम से होता है, जबकि एरर की क्वेरी Error() के माध्यम से की जाती है ([SWS_CORE_00755], [SWS_CORE_00757])। कार्यात्मक आगे की प्रोसेसिंग और एरर प्रोगैशन के लिए, Result Bind(), ValueOr() और Resolve() जैसे मेथड्स प्रदान करता है ([SWS_CORE_00761], [SWS_CORE_00768])। एरर को ErrorCode के माध्यम से मॉडल किया जाता है, जो एक संख्यात्मक एरर कोड CodeType को एक विशिष्ट डोमेन पहचानकर्ता ErrorDomain के साथ-साथ वैकल्पिक नैदानिक अतिरिक्त डेटा SupportDataType से जोड़ता है ([SWS_CORE_00121], [SWS_CORE_00122], [SWS_CORE_00512])। मेथड ValueOrThrow() सक्रिय एक्सेप्शन हैंडलिंग वाले परिवेशों के लिए एक ब्रिज के रूप में मौजूद है, लेकिन एरर की स्थिति में यह डोमेन से जुड़े एक्सेप्शन को ट्रिगर करता है ([SWS_CORE_00154], [SWS_CORE_00766])।
गतिविधि आरेख: त्रुटि-मुक्त मामले में और त्रुटि की स्थिति में Result ऑब्जेक्ट का नियतात्मक मूल्यांकन पथ। स्रोत: [SWS_CORE_00751], [SWS_CORE_00755], [SWS_CORE_00757], [SWS_CORE_00766]
पूल संसाधनों के माध्यम से बहुरूपी मेमोरी प्रबंधन
मानक हीप पर डायनेमिक एलोकेशन गैर-नियतात्मकता और मेमोरी विखंडन के संबंध में जोखिम उत्पन्न करता है। इसलिए ara::core C++ NVI पैटर्न (Non-Virtual Interface) के आधार पर पॉलीमॉर्फिक मेमोरी रिसोर्सेज (PMR) पर आधारित मेमोरी प्रबंधन को एकीकृत करता है (SWArchitecture पृ. 61)। बेस क्लास MemoryResource सार्वजनिक इंटरफ़ेस allocate() और deallocate() घोषित करता है, जो आंतरिक रूप से शुद्ध वर्चुअल मेथड्स do_allocate() और do_deallocate() को नियंत्रित करते हैं ([SWS_CORE_00041], [SWS_CORE_00061])।
रीयल-टाइम-महत्वपूर्ण आवंटन पैटर्न के लिए विशेष पूल संसाधन उपलब्ध हैं: SynchronizedPoolResource PoolOptions के माध्यम से पूर्व-कॉन्फ़िगर किए गए चंक्स और ब्लॉक आकारों से थ्रेड-सुरक्षित आवंटन प्रदान करता है ([SWS_CORE_00027], [SWS_CORE_00030])। बिना सिंक्रोनाइज़ेशन ओवरहेड के सख्त थ्रेड-लोकल प्रोसेसिंग चरणों के लिए UnsynchronizedPoolResource काम करता है ([SWS_CORE_00046], [SWS_CORE_00067])। release() के माध्यम से संपूर्ण आवंटित मेमोरी क्षेत्र को एक ही चरण में अपस्ट्रीम upstream_resource() में वापस लौटाया जा सकता है, जो चरण-उन्मुख वर्कफ़्लो में मेमोरी लीक को प्रभावी ढंग से रोकता है ([SWS_CORE_00037], [SWS_CORE_00038], [SWS_CORE_00065])।
क्लास आरेख: Non-Virtual Interface (NVI) पैटर्न के अनुसार पॉलीमॉर्फिक मेमोरी संसाधनों का पदानुक्रम। स्रोत: SWArchitecture पृ. 61, [SWS_CORE_00030], [SWS_CORE_00041], [SWS_CORE_00061]
मौलिक यूटिलिटी और कंटेनर प्रकार (Optional, Array, Vector, Map)
अपरिभाषित व्यवहार से बचने और स्पष्ट सिमेंटिक्स सुनिश्चित करने के लिए, core प्राथमिक कंटेनरों और सहायक प्रकारों को मानकीकृत करता है। ara::core::Optional<T> उन मानों का प्रतिनिधित्व करता है जो मौजूद हो भी सकते हैं या नहीं भी, बिना असुरक्षित नल पॉइंटर्स का सहारा लिए ([SWS_CORE_01103], [SWS_CORE_01104], ARAComAPI पृ. 1)। स्थिति की क्वेरी has_value() या operator bool() के माध्यम से की जाती है, जबकि एक्सेस value(), value_or() या operator*() के माध्यम से होता है ([SWS_CORE_01128], [SWS_CORE_01129], [SWS_CORE_01130], [SWS_CORE_01134])। विशेष संदर्भ ओवरलोड्स Optional<T&> वैकल्पिक संदर्भों को सुरक्षित रूप से बनाए रखने की अनुमति देते हैं ([SWS_CORE_01151], [SWS_CORE_01167])।
निश्चित आकार की डेटा संरचनाओं के लिए, मॉड्यूल Array<T, N> प्रदान करता है, जो operator[] के माध्यम से प्रत्यक्ष अनुक्रमण, at() के माध्यम से सीमा-परीक्षण युक्त एक्सेस और मानक इटरेटर का समर्थन करता है ([SWS_CORE_01250], [SWS_CORE_01265], [SWS_CORE_01273])। तुलना ऑपरेटरों को bool रिटर्न और एक्सेप्शन सुरक्षा के साथ सख्त कोडिंग दिशानिर्देशों के अनुसार लागू किया जाता है ([SWS_CORE_01290], CPP14Guidelines पृ. 241)। गतिशील रूप से बढ़ते अनुक्रम और साहचर्य (एसोसिएटिव) कंटेनर Vector<T, Allocator> और Map<Key, T, Compare, Allocator> द्वारा कवर किए जाते हैं ([SWS_CORE_01318], [SWS_CORE_01428])। दोनों प्रकार कॉन्फ़िगर करने योग्य एलोकेटर स्वीकार करते हैं, जिससे आवंटन पॉलीमॉर्फिक MemoryResource पूल के माध्यम से निर्बाध रूप से संभाले जा सकते हैं ([SWS_CORE_00066], [SWS_CORE_01303], [SWS_CORE_01406])।
त्रुटि की स्थिति में व्यवहार और फेल-फास्ट समाप्ति
यदि कोई प्रक्रिया किसी गंभीर त्रुटि स्थिति की सुरक्षित रूप से क्षतिपूर्ति नहीं कर सकती है, तो Adaptive Platform का फेल-फास्ट सिद्धांत लागू होता है (SWArchitecture पृ. 60)। इंटरफ़ेस Abort() के माध्यम से चल रही प्रक्रिया की तत्काल, बिना शर्त समाप्ति की जाती है ([SWS_CORE_00052])। यह सुनिश्चित करने के लिए कि कोई भी स्टैक-अनवाइंडिंग रूटीन या डिस्ट्रक्टर गलत अनुवर्ती स्थितियाँ उत्पन्न न करें, फ़ंक्शन को [[noreturn]] और noexcept के रूप में घोषित किया गया है ([SWS_CORE_00052], SWArchitecture पृ. 36)।
समाप्त होने से पहले क्षणिक नैदानिक जानकारी को सुरक्षित करने या अंतिम आपातकालीन लॉगिंग क्रियाओं को निष्पादित करने के लिए, एप्लिकेशन SetAbortHandler() या AddAbortHandler() के माध्यम से उपयोगकर्ता-विशिष्ट कॉलबैक फ़ंक्शन पंजीकृत कर सकते हैं ([SWS_CORE_00050], [SWS_CORE_00051], [SWS_CORE_00054])। एक पंजीकृत अबॉर्ट-हैंडलर को void() noexcept हस्ताक्षर को पूरा करना होगा ([SWS_CORE_00053])। हैंडलर के निष्पादन के बाद, प्लेटफ़ॉर्म प्रक्रिया की अंतिम समाप्ति को बाध्य करता है, जिससे अपरिभाषित मेमोरी स्थिति में आगे चलना संभव नहीं होता है (SWArchitecture पृ. 60)।
गतिविधि आरेख: AbortHandler के निष्पादन के साथ Abort() के माध्यम से फेल-फास्ट समाप्ति का नियंत्रण प्रवाह। स्रोत: SWArchitecture पृ. 60, [SWS_CORE_00051], [SWS_CORE_00052]
आगे विस्तृत साक्ष्य
रिलीज़ R25-11 में core का विनिर्देश कई मानक निर्धारणों और वास्तुशिल्प मॉडलों पर आधारित है। प्रक्रिया जीवनचक्र और आपातकालीन स्टॉप व्यवहार के लिए, Initialize(), Deinitialize() के साथ-साथ Abort() और SetAbortHandler() घटक हैं ([SWS_CORE_00051], [SWS_CORE_00052], SWArchitecture पृ. 60)। एसिंक्रोनस संचार मॉडल मुख्य रूप से Future ([SWS_CORE_00326], [SWS_CORE_00329]) और Promise ([SWS_CORE_00344], [SWS_CORE_00345]) पर आधारित है, जिनकी परस्पर क्रिया अनुप्रयोग-उन्मुख क्लस्टरों जैसे कि ara::com और ara::ts में सत्यापित की जाती है (ARAComAPI पृ. 46, TimeSynchronization पृ. 90)।
त्रुटिरहित डेटा और मेमोरी प्रबंधन Result ([SWS_CORE_00751], [SWS_CORE_00766]), ErrorCode ([SWS_CORE_00512]) और PMR मेमोरी क्लास SynchronizedPoolResource तथा UnsynchronizedPoolResource के विनिर्देशों द्वारा मानकीकृत है ([SWS_CORE_00030], [SWS_CORE_00046], SWArchitecture पृ. 61)। इसके अतिरिक्त, कंटेनर और तुलना दिशानिर्देश सुरक्षा-महत्वपूर्ण समग्र प्रणालियों में नियतात्मक डेटा प्रबंधन को परिभाषित करते हैं ([SWS_CORE_01103], [SWS_CORE_01250], [SWS_CORE_01318], CPP14Guidelines पृ. 241)।
यह गाइड R25-11 के लिए AUTOSAR विनिर्देश के आधार पर एक AI क्यूरेशन सहायक द्वारा उत्पन्न की गई थी।
function: 1060 type alias: 101 class: 34 struct: 26 variable: 13 enumeration: 3
विषय मानचित्र
ara::core
67इस रिलीज़ के लिए कोई तत्व डेटा उपलब्ध नहीं
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
एक्सेस 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_01286तुलना != < <= == > >= 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_01295अदला-बदली 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
तुलना != < <= == > >= 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_03381संयोजन + 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_03363इनपुट/आउटपुट 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_03399रूपांतरण 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_03390अदला-बदली swap 1
template <typename Allocator> void swap (BasicString< Allocator > &lhs, BasicString< Allocator > &rhs); SWS_CORE_03296अन्य 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
इनपुट/आउटपुट << >> 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_01755अन्य & | ˆ 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.
से इनहेरिट करता है ErrorDomain
Exception type thrown for ara::core errors.
से इनहेरिट करता है Exception
Encapsulation of an error code
निर्माण 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_05290तुलना != == 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
का आधार CoreErrorDomain, FutureErrorDomain
Base type for all ARA exception types
से इनहेरिट करता है std::exception
का आधार 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
विशेषीकरण Future< void, E >
Error domain for errors originating from ara::core::Future and ara::core::Promise
से इनहेरिट करता है ErrorDomain
Exception type thrown by ara::core::Future and ara::core::Promise
से इनहेरिट करता है 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.
तुलना != == 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
अदला-बदली 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
का आधार MonotonicBufferResource, SynchronizedPoolResource, UnsynchronizedPoolResource
तुलना == 1
bool operator== (const MemoryResource &a, const MemoryResource &b) noexcept; SWS_CORE_06561≙ [variant]
एक्सेस 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_01634तुलना != < <= == > >= 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_01646अदला-बदली 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
से इनहेरिट करता है MemoryResource
Shall implement std::nullopt_t ≙ std::nullopt_t
Implementation of std::optional
विशेषीकरण Optional< T & >
निर्माण 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_01140तुलना != < <= == > >= 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_01197अदला-बदली 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
तुलना == 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
विशेषीकरण Promise< void, E >
This class is a type that contains either a value or an error
विशेषीकरण Result< T &, E > Result< void, E >
तुलना != == 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_00787अदला-बदली 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
निर्माण 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
तुलना != < <= == > >= 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_02186इनपुट/आउटपुट << 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
से इनहेरिट करता है MemoryResource
Implementation of std::pmr::unsynchronized_pool_resource from [mem.res.pool] ≙ std::pmr::unsynchronized_pool_resource
से इनहेरिट करता है MemoryResource
Implementation of std::variant type from [basic.string] ≙ std::variant
Implementation of std::pmr::vector container from [vector] ≙ std::pmr::vector
तुलना != < <= == > >= 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_01395अदला-बदली 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.
ओवरलोड 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
ओवरलोड 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
ओवरलोड 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
विशेषीकरण 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]
नेमस्पेस
- 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 क्लास आरेख
Abgerundete Rahmen = Namespaces; hohle Dreieckspfeile = Vererbung (zeigt zur Basisklasse); graue Boxen = modulfremde bzw. externe Basisklassen. Klicken öffnet die Klassenseite.
gemini-3.8-flash-low· 2026-10-13 · जर्मन मूल