class ara::core::StringView

use

The member function at of class ara::core::StringView provides synchronous read access to individual characters ([SWS_CORE_02133]). It accepts as parameter the index pos of type size_type and returns a const reference (const_reference) to the character at this position. The function is specified as constexpr and noexcept, which also allows calls to be evaluated at compile time.

Error handling

Contrary to the behavior in standard [string.view], the function does not throw an exception of type std::out_of_range in case of error ([SWS_CORE_02133]). If condition pos >= size() is fulfilled, a IsoStdOutOfRangeViolation is triggered instead. The specification classifies the function as exception safe (exception safe).

Concurrency and Limitations

Since at is declared as const, the call does not modify the underlying instance. The caller must ensure that the referenced string remains valid for the entire lifetime of the StringView object. When out-of-bounds violation IsoStdOutOfRangeViolation occurs, execution is likely terminated in a controlled manner; user-defined abort routines can be registered for this via AddAbortHandler ([SWS_CORE_00054]) (Interpretation). Question Q-0836f4dc6fa946a6 (open)

Interaction

The concept of intercepting out-of-bounds accesses via IsoStdOutOfRangeViolation is applied consistently across multiple containers in ara::core:

• In ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]) and ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), at is likewise declared as noexcept and exception safe.
• In contrast, the corresponding at functions in ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]) as well as in ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]) are classified as not exception safe (not exception safe) and not marked as noexcept.

use

The member function compare of class ara::core::StringView from header #include "ara/core/string_view.h" serves for the synchronous lexicographical comparison of the current string view with a passed instance s of type StringView [SWS_CORE_02142]. The behavior is based on the corresponding usage in [string.view] of the C++ standard [SWS_CORE_02142]. As a return value, the function provides an int, which represents the relational relationship of the character sequences [SWS_CORE_02142].

Error handling

The function is declared with noexcept and specified as exception safe [SWS_CORE_02142]. It does not throw C++ exceptions. Specific error codes, AUTOSAR development errors (DET), or notifications to the Diagnostic Event Manager (DEM) are not provided for this operation [SWS_CORE_02142].

Concurrency and Constraints

Due to the classification as const and constexpr, the call can already be evaluated at compile time [SWS_CORE_02142]. Interpretation: Since the function accesses immutable character sequences in a read-only manner, a concurrent call via the same StringView from multiple threads is expected to be thread-safe, provided that the underlying character data is not modified. Question Q-7489abeeb3fd7124 (open)

Interaction

While basic types in ara::core such as ErrorDomain [SWS_CORE_00137] or ErrorCode [SWS_CORE_00571] primarily provide binary equality operators for checks, compare in StringView offers a three-way comparison value [SWS_CORE_02142].

use

The member function compare of class ara::core::StringView performs a synchronous lexicographical comparison of a substring of the current string view with a passed StringView s [SWS_CORE_02143]. The substring to be compared begins at index pos1 and encompasses a length of at most n1 characters. The return value is an integer int indicating the relational result. Since the function is declared as constexpr, evaluation can already take place at compile time [SWS_CORE_02143].

Error handling

The semantics are based on the requirements of [string.view] from the ISO C++ standard, but define two major deviations [SWS_CORE_02143]:

• The function is specified with noexcept and is considered exception safe (exception safe) [SWS_CORE_02143].
• If the start index exceeds the length of the view (pos1 > size()), no standard exception of type std::out_of_range is thrown, but a IsoStdOutOfRangeViolation is caused [SWS_CORE_02143].

Concurrency and Constraints

Callers must ensure in advance that pos1 does not exceed the value of size() in order to avoid a IsoStdOutOfRangeViolation [SWS_CORE_02143]. Since compare is declared as const and performs no modifications to the instance, concurrent read access from multiple threads is expected to be non-critical (interpretation). Question Q-be4ec80ab2529ed3 (open)

The member function compare of class ara::core::StringView ([SWS_CORE_02144], header file #include "ara/core/string_view.h") serves for the synchronous, lexicographical comparison of two substrings. The fundamental behavior corresponds to the functionality in [string.view] of the ISO C++ standard, but exhibits specific deviations for AUTOSAR Adaptive [SWS_CORE_02144].

The passed parameters determine the sections of both sequences to be compared [SWS_CORE_02144]:

• pos1 and n1: Start index and maximum character count within the calling instance.
• s: The object of type StringView to be compared.
• pos2 and n2: Start index and maximum character count within the passed object s.

As a return value, the function delivers an integer value (int) that is negative if the own subsequence is lexicographically smaller, zero upon match, and positive if it is greater [SWS_CORE_02144].

Regarding error handling, the implementation deviates from the standard: The method is declared as noexcept and is considered exception safe (exception safe) [SWS_CORE_02144]. If one of the start positions lies outside the valid range (pos1 > size() || pos2 > s.size()), no std::out_of_range exception is thrown, but a IsoStdOutOfRangeViolation is raised [SWS_CORE_02144].

Due to the qualifiers constexpr and const, the function can already be evaluated during compilation [SWS_CORE_02144]. Since no internal states are modified, concurrent read accesses to the same instance are expected to be thread-safe. Question Q-a93f872ee88becc9 (open)

The member function compare of class ara::core::StringView (header file #include "ara/core/string_view.h") serves the synchronous, lexicographical comparison of the current string view with a null-terminated C string const char* s [SWS_CORE_02145]. Since the operation is specified as constexpr, evaluation can take place both at runtime and within the context of compile-time expressions. As a return value, the function returns an integer value of type int whose sign reflects the comparison result analogously to [string.view]: a value less than zero means that the instance precedes s lexicographically; the value zero means equality; a value greater than zero indicates that the instance succeeds s [SWS_CORE_02145].

Regarding error handling, the AUTOSAR specification explicitly deviates from the template in [string.view]: The method is declared as noexcept and has the property exception safe [SWS_CORE_02145]. Calls are thus guaranteed not to throw C++ exceptions. Specific error codes, feedback to the Development Error Tracer (DET) or the Diagnostic Event Manager (DEM) are not provided for this basic function.

As a const-qualified method, compare does not modify the state of the ara::core::StringView instance and can be called safely for concurrent reading. When using it, it should be noted that the pointer s presumably must refer to a valid character sequence, since the semantics adopted from [string.view] would likely result in undefined behavior if a null pointer is passed [SWS_CORE_02145]. Question Q-cff1a1f55603dbd4 (open)

use

The method compare of class ara::core::StringView enables a synchronous lexicographical comparison of a substring of the string view with a null-terminated C string s [SWS_CORE_02146]. Passed are the start index pos1, the maximum length n1, and the pointer s to the character sequence to be compared. The return value of type int reflects the relational ordering result analogously to the standard library: a return value less than zero, equal to zero, or greater than zero characterizes the lexicographical relationship [SWS_CORE_02146].

Error Handling and Boundary Conditions

The operation is specified as noexcept and \"exception safe\" [SWS_CORE_02146]. In contrast to the behavior according to C++ standard [string.view], an invalid start index with pos1 > size() does not trigger a std::out_of_range exception, but leads to a IsoStdOutOfRangeViolation [SWS_CORE_02146]. In the AUTOSAR runtime context, this violation is expected to be treated as a programming error and force an immediate platform abort, since regular C++ exceptions cannot escape across noexcept boundaries. Question Q-d4ce6b496b80fdde (open) Furthermore, it must be ensured that s refers to a valid string, since a null pointer presumably causes undefined behavior.

Concurrency

Since compare is defined as const and constexpr, the state of the instance remains unchanged [SWS_CORE_02146]. Concurrent read accesses to the same ara::core::StringView object can thus be executed safely.

use

The member function compare of class ara::core::StringView from header ara/core/string_view.h performs a synchronous lexicographical comparison [SWS_CORE_02147]. In this process, a subsequence of the current instance, starting from index pos1 with a maximum of n1 characters, is compared with the first n2 characters of the external C character array s. The integer return value (int) follows the semantics of [string.view] and indicates via its sign whether the own substring is lexicographically smaller than, equal to, or greater than the reference sequence. As a constexpr and const method, it does not modify the object and can already be evaluated at compile time [SWS_CORE_02147].

Error Handling and Boundary Conditions

Regarding error handling and exception safety, AUTOSAR defines two mandatory deviations from the standard [SWS_CORE_02147]:

• The member function is specified as noexcept and completely classified as exception safe [SWS_CORE_02147].
• If the start position exceeds the length of the instance (pos1 > size()), no std::out_of_range exception is thrown, but a IsoStdOutOfRangeViolation is raised [SWS_CORE_02147].

Interpretation: Due to the combination of the noexcept guarantee and IsoStdOutOfRangeViolation, an out-of-bounds condition is not expected to be catchable by means of classic C++ try-catch blocks, but presumably leads to an immediate abort or error handling by the platform. Question Q-67fb8eda4c594a06 (open)

Usage and Call Context

The member function contains of class ara::core::StringView serves for the synchronous check of whether a string view contains a specified substring [SWS_CORE_02154]. The function is defined in header ara/core/string_view.h according to the semantics of the C++ standard working draft N4950 ([string.view]) [SWS_CORE_02154]. As a parameter, the method takes another instance of StringView (sv) by value and directly returns a boolean value of type bool: true if the subsequence occurs, otherwise false [SWS_CORE_02154].

Due to the specification as constexpr, the call can take place both at runtime and already during translation in the context of compile-time contexts [SWS_CORE_02154].

Error Handling and Exception Safety

For contains, the behavior is stipulated as exception safe and the signature is explicitly designated with noexcept [SWS_CORE_02154]. Consequently, the function never throws C++ exceptions under any circumstances and does not return errors via ara::core::Result or ara::core::ErrorCode. Neither DET nor DEM error messages exist for this basic function.

Concurrency and Limitations

As a const member function (const), contains does not modify the state of the StringView instance [SWS_CORE_02154]. Interpretation: Concurrent, purely reading calls on the same StringView instance or on the underlying character buffer are expected to be fully reentrant and concurrently safe, as long as the referenced memory area is not modified simultaneously by any thread. Question Q-80f1a9989a098913 (open) Special ordering conditions or initialization obligations beyond the provision of a valid StringView do not exist.

The member function contains synchronously checks whether a specific character c is contained within a ara::core::StringView [SWS_CORE_02155]. The function is declared in header ara/core/string_view.h and follows the semantics of [string.view] from the C++ working draft N4950 [SWS_CORE_02155]. It accepts a single character of type char and returns a boolean value of type bool, which presumably yields true if and only if the character is found in the referenced text range [SWS_CORE_02155]. Question Q-3293fccace7af3ab (open)

Regarding error handling, the operation is declared as noexcept and specified as exception-safe (exception safe) [SWS_CORE_02155]. No exceptions are thrown and no error codes are signaled via DET, DEM, or return types; non-existence of the character is regularly reported via the boolean return value.

Since the function is designated as constexpr and const, it can already be evaluated at compile time [SWS_CORE_02155]. Invocations do not modify the underlying ara::core::StringView object, which is why concurrent read accesses to the same instance should presumably be thread-safe. Question Q-298dbc4d080853bc (open)

In the interplay of basic types of the module core, contains serves for direct text inspection on string views [SWS_CORE_02155]. While types like ara::core::Result offer their own check mechanisms for contained values or errors – such as HasValue [SWS_CORE_00751] or CheckError [SWS_CORE_00765] –, contains operates lightweight without allocation or error encapsulation.

The member function contains of class ara::core::StringView checks synchronously whether the referenced string contains the character sequence str passed as a parameter [SWS_CORE_02156]. The function is provided via header file ara/core/string_view.h and returns the test result as a return value of type bool [SWS_CORE_02156]. Due to the declaration as constexpr, the call can be executed both at runtime and in the context of compile-time expressions [SWS_CORE_02156].

The functional semantics follow the definition of [string.view] in the Working Draft of the C++ standard N4950, but exhibit a mandatory deviation: In AUTOSAR Adaptive, the function is declared with identifier noexcept [SWS_CORE_02156]. Accordingly, the operation is specified as exception safe (exception safe), guaranteeing that no C++ exceptions are thrown during execution [SWS_CORE_02156]. Specific AUTOSAR error codes or notifications to development or diagnostic error tracers are not defined for this function [SWS_CORE_02156].

As a const member function (const), contains does not modify the calling instance [SWS_CORE_02156]. Interpretation: For parameter str, passing a valid, null-terminated string is expected to be assumed, since the interface uses const char *str and provides no separate length or error check [SWS_CORE_02156]. Question Q-a2d7cd456a72a792 (open)

use

The synchronous member function copy of class ara::core::StringView ([SWS_CORE_02140]) copies a substring into a provided buffer. Access is provided via header file #include "ara/core/string_view.h":

• Parameters: char *s points to the destination array, n determines the maximum number of characters to copy, and pos defines the starting position (default value 0).
• Return value: A value of type size_type indicating the number of characters actually copied.
• Semantics: The function operates synchronously and is aligned with the ISO C++ specification [string.view] ([SWS_CORE_02140]).

Error handling

In case of an error, when pos > size() holds, an IsoStdOutOfRangeViolation is raised ([SWS_CORE_02140]). This deviates from standard [string.view], which throws std::out_of_range. Since the interface is declared as noexcept, raising the violation presumably leads to immediate termination of the process (interpretation: no C++ exception is propagated). Question Q-4ddbe4dfb002c41f (open)

Concurrency and Limitations

The operation is specified as const as well as noexcept and is considered exception safe ([SWS_CORE_02140]). The caller must ensure that the destination array s provides sufficient memory for at least min(n, size() - pos) characters, as range errors of the destination buffer are not caught.

Interaction

Compared to ara::core::BasicString::copy ([SWS_CORE_03410]), which works with value_type and is classified as not exception safe, the variant in StringView provides an exception-safe noexcept guarantee ([SWS_CORE_02140]).

The member function crbegin of class ara::core::StringView synchronously returns a constant reverse iterator (const_reverse_iterator) to the first character of the reversed string view [SWS_CORE_02126]. The function takes no parameters, is declared via header file ara/core/string_view.h, and follows the standard semantics of [string.view] [SWS_CORE_02126].

Regarding error handling, the operation is defined as noexcept and specified as exception safe (exception safe) [SWS_CORE_02126]. Neither error codes are returned nor error messages via DET or DEM issued, since the call is guaranteed to execute without errors [SWS_CORE_02126].

Thanks to the specification as constexpr and const, the function can also be called within constant expressions at compile time [SWS_CORE_02126]. Interpretation: Parallel calls of crbegin on the same instance should be concurrently thread-safe, since the operation makes no modifications whatsoever to the object. Question Q-ce8bc6d0753d1aa8 (open)

The interface fits seamlessly into the cross-container iterator concept of AUTOSAR Adaptive Core. Equivalent constexpr implementations of crbegin are found in ara::core::Array [SWS_CORE_01260] as well as ara::core::Span [SWS_CORE_01978]. Furthermore, containers such as ara::core::Vector [SWS_CORE_01342], ara::core::Map [SWS_CORE_01450], and ara::core::BasicString [SWS_CORE_03049] also provide corresponding non-constexpr const_reverse_iterator entry points.

The member function crend of class ara::core::StringView returns a constant reverse iterator ([SWS_CORE_02127]). The call executes synchronously and without parameters on an existing instance from header ara/core/string_view.h. The returned const_reverse_iterator marks the logical end of a reverse iteration; according to the C++ reference [string.view], it points as a sentinel position to the theoretical element immediately preceding the first character of the string (interpretation: analogous to the C++ standard). Question Q-5fd666f8d3eaf308 (open)

Error Handling and Concurrency

The function is declared as noexcept and specified as exception safe (“exception safe”) ([SWS_CORE_02127]). Neither exceptions are thrown nor error codes returned or DET/DEM messages issued. Due to the constexpr qualification, the iterator can already be created at compile time. As a pure const method without state effects, concurrent read calls on the same instance should be concurrently safe (interpretation). Question Q-207e2b9561f61d27 (open)

Interaction

The interface follows the uniform iteration concept of ara::core for sequential data structures. Related specifications define analogous crend interfaces:

• ara::core::Array ([SWS_CORE_01261]) and ara::core::Span ([SWS_CORE_01979]), likewise specified as constexpr,
• ara::core::Vector ([SWS_CORE_01343]), ara::core::Map ([SWS_CORE_01451]), and ara::core::BasicString ([SWS_CORE_03050]).

use

The member function ara::core::StringView::ends_with synchronously checks whether the inspected character sequence ends with the passed subsequence sv [SWS_CORE_02151]. It is declared in the header file ara/core/string_view.h and follows the standardized C++ semantics according to [string.view] from ISO/IEC 14882:2020 [SWS_CORE_02151]. Thanks to being marked as constexpr, the comparison can already be evaluated at compile time. Because this is a const method, the calling object is not modified.

Error Handling and Concurrency

The specification assigns property exception safe to ends_with and declares it as noexcept [SWS_CORE_02151]. The function thus does not throw any exceptions and reports failures neither via AUTOSAR error channels such as DET or DEM nor via specific error codes. As a pure read operation on an immutable string view, the function is likely reentrant and safe for concurrent read accesses to the same instance without synchronization mechanisms. Question Q-821d4d0f216694ef (open)

Interaction

The method is part of class ara::core::StringView and is complemented by related overloads: In addition to evaluation against another StringView object, variants for checking against a single character char [SWS_CORE_02152] and against a null-terminated C string const char* [SWS_CORE_02153] are available, which are likewise exception-safe and usable at compile time.

use

The member function ends_with of class ara::core::StringView checks synchronously whether the referenced string ends with the specified character c ([SWS_CORE_02152]). It is declared via header ara/core/string_view.h and follows the standardized behavior from [string.view] according to ISO/IEC 14882:2020 ([SWS_CORE_02152]). Due to the designation as constexpr, the evaluation can be performed both at runtime and beforehand during compilation ([SWS_CORE_02152]).

Error Handling and Runtime Behavior

The interface guarantees complete exception safety ("exception safe") and is provided with the specifier noexcept ([SWS_CORE_02152]). Consequently, it never throws exceptions and uses no error messages via DET or DEM. For an empty string, the check always yields the boolean result false.

Concurrency and Interaction

Since ends_with is defined as a pure const operation without state effects, concurrent read access from multiple threads to the same instance should be uncritical (interpretation). Question Q-b3a5dccbd8ff638a (open) In addition to the single character, ara::core::StringView provides two further overloads for suffix checks: comparison with another StringView ([SWS_CORE_02151]) as well as the check against a null-terminated C string of type const char* ([SWS_CORE_02153]). Both variants are likewise implemented synchronously, constexpr, and noexcept ([SWS_CORE_02151], [SWS_CORE_02153]).

The member function ends_with of class ara::core::StringView synchronously checks whether the inspected character sequence ends with a specific string [SWS_CORE_02153]. The function accepts a pointer const char* str as a parameter and returns a return value of type bool [SWS_CORE_02153]. Due to the declaration as constexpr, evaluation can take place both at runtime and already at compile time [SWS_CORE_02153]. The functional semantics follow the definition of section [string.view] from standard ISO/IEC 14882:2020 [SWS_CORE_02153].

Regarding error handling, the function is declared as noexcept and classified as exception safe, which is why no C++ exceptions are thrown [SWS_CORE_02153]. Specific AUTOSAR error codes or error notifications to DET or DEM are not provided for this helper function.

Interpretation: When called, the parameter str is likely required to point to a valid, null-terminated string, since no additional length parameter is passed [SWS_CORE_02153]. Question Q-d6d076a1a2ab7dce (open) Because the method is qualified as const and does not modify internal state, concurrent read access to the same instance is safe.

The function is provided via the header file #include "ara/core/string_view.h" in the scope of ara::core::StringView [SWS_CORE_02153]. It complements related overloads of ends_with that take a StringView object [SWS_CORE_02151] or a single character char [SWS_CORE_02152] instead of a C string.

The member function find of class ara::core::StringView synchronously searches for the first occurrence of the passed substring s starting from the start position pos according to the behavior in [string.view] [SWS_CORE_02157]. The function is defined as constexpr and const, allowing it to also be called at compile time and on immutable instances [SWS_CORE_02157].

Regarding error handling, the method is declared as noexcept and classified as exception safe [SWS_CORE_02157]; specific error codes as well as DET or DEM messages are not provided. Since execution does not modify the state of the object, concurrent read access by multiple threads of execution to the same StringView instance is likely permissible without additional synchronization. Question Q-e27507133b5a4e20 (open)

Within ara::core::StringView, this function is complemented by further search overloads for single characters of type char [SWS_CORE_02158] and C strings [SWS_CORE_02159], [SWS_CORE_02160]. In interaction with other containers, ara::core::BasicString provides a comparable search function for StringView [SWS_CORE_03315], whereas the function find in ara::core::Map serves to search for keys and returns iterators [SWS_CORE_01490].

Usage and Parameters

The synchronous member function find of class ara::core::StringView searches from index position pos for the first occurrence of character c ([SWS_CORE_02158]). It is included via header file #include "ara/core/string_view.h" and returns the index of the match of type size_type as return value. If the character is not found, the value npos should be returned according to the reference to [string.view]. Question Q-60ea50d6f006004f (open)

Error Handling and Concurrency

The function is declared with noexcept and specified as exception safe (exception safe) ([SWS_CORE_02158]). Due to the designation as constexpr and const, it is suitable for constant expressions at compile time and does not modify the underlying object. Concurrent read accesses to the same instance are presumably reentrant and thread-safe as long as the referenced string in memory remains unchanged. Question (open)

Interaction and Alternatives

The method complements other overloads of find in ara::core::StringView that search for substrings ([SWS_CORE_02157]) or pointer sequences ([SWS_CORE_02159], [SWS_CORE_02160]). In contrast to the character-based search in ara::core::BasicString ([SWS_CORE_03324]), which is classified as not exception safe, this variant guarantees complete freedom from exceptions. It also distinguishes itself from the key-based search in ara::core::Map ([SWS_CORE_01490]).

use

The member function find of class ara::core::StringView ([SWS_CORE_02159]) serves for synchronously searching for a character sequence within the string view. It is provided via the header file ara/core/string_view.h. The function accepts a pointer s to a character array, a start position pos of type size_type, and the count of characters to search for n, and returns the found position as size_type. Interpretation: According to the referenced semantics from [string.view], s is likely to point to an array with at least n characters, and the value npos is likely to be returned in the case of an unsuccessful search. Question Q-e7f54bb1b42a99d8 (open)

Error Handling and Concurrency

The method is declared as noexcept and specified as exception safe ([SWS_CORE_02159]). Error states are thus not signaled via C++ exceptions. Since the function is defined as const and constexpr, it does not modify the instance and is suitable for evaluations at compile time as well as for concurrent read accesses.

Interaction

Within ara::core::StringView, the function complements further search overloads:

• Search for a StringView ([SWS_CORE_02157]) or a single character ([SWS_CORE_02158]),
• Search using a null-terminated C string ([SWS_CORE_02160]), where no explicit length n is specified.

Compared to the corresponding signature in ara::core::BasicString ([SWS_CORE_03409]), which is declared as not exception safe and does not guarantee noexcept, the variant in StringView ([SWS_CORE_02159]) offers strict exception safety without allocation overhead.

use

The synchronous member function find of class ara::core::StringView ([SWS_CORE_02160]) from header #include "ara/core/string_view.h" searches for the first occurrence of the specified C string s starting from the start position pos. The functional behavior complies with the C++ standard [string.view], but deviates by being explicitly designated as noexcept ([SWS_CORE_02160]).

Error handling

The function is defined as exception safe and guarantees the absence of any exceptions ([SWS_CORE_02160]). Specific error codes as well as reports to DET or DEM do not exist. Interpretation: If the searched string is not contained, the failure of the search is likely to be indicated by the return value npos analogously to the standard behavior of [string.view]. Question Q-febde79f1c992c2a (open)

Concurrency and Constraints

Since find is declared as constexpr and const ([SWS_CORE_02160]), the call does not modify the state of the StringView object and can already be evaluated at compile time. Interpretation: Concurrent read accesses across multiple threads are likely to be reentrant and concurrency-safe without additional synchronization measures. Question (open)

Interaction

Within ara::core::StringView, further overloads of find exist for StringView parameters ([SWS_CORE_02157]), single characters ([SWS_CORE_02158]), and substrings with an explicit length limitation n ([SWS_CORE_02159]). In contrast to analogous C-string search operations in ara::core::BasicString ([SWS_CORE_03408], [SWS_CORE_03409]), which are classified as not exception safe, the implementation in ara::core::StringView ensures complete exception safety ([SWS_CORE_02160]).

use

The member function find_first_not_of of class ara::core::StringView ([SWS_CORE_02173]) serves for synchronously searching for the first character within the string view that is not contained in the passed StringView s. As a second parameter, the start position pos can optionally be specified (default value pos=0). The function returns the found index position as size_type. The behavior complies with the corresponding semantics in [string.view]. Interpretation: If no non-matching character is found, the function is likely to return the value npos in accordance with this standard semantics. Question Q-8f55419868615e5a (open)

Error Handling and Concurrency

The function is declared as noexcept and specified as exception safe (“exception safe”) ([SWS_CORE_02173]). No exceptions are thrown and no specific error reports via DET or DEM are defined. Due to the qualifiers const and constexpr, the call can take place side-effect-free at compile time or in parallel on unmodified objects.

Interplay and overloads

Within ara::core::StringView, the function is complemented by further noexcept overloads:

• Search for characters not equal to a single character char c ([SWS_CORE_02174]).
• Search based on a C string const char *s with length limitation n ([SWS_CORE_02175]) or starting from start position ([SWS_CORE_02176]).

A similar search pattern exists for ara::core::BasicString, including with StringView ([SWS_CORE_03319]) and BasicString ([SWS_CORE_03337]). In contrast to StringView, the overloads there for pointers and characters ([SWS_CORE_03338], [SWS_CORE_03339], [SWS_CORE_03340]) are classified as not exception safe.

The member function find_first_not_of of class ara::core::StringView synchronously determines the position of the first character within the character sequence that is not equal to the passed character c [SWS_CORE_02174]. The search starts by default at the beginning of the view or from the optional offset pos. By referencing standard [string.view], the function presumably returns the zero-based index of type size_type of the found character or the value npos if no differing character exists. Question Q-9f3eeedf35e475e7 (open)

With regard to error handling, the function is declared as noexcept and specified as exception safe [SWS_CORE_02174]. It thus throws no exceptions, uses no DET or DEM messages, and reports the non-finding of a character purely via its return value.

As a constexpr and const method, find_first_not_of can already be evaluated at compile time and guarantees stateless, side-effect-free read access to the underlying character array. Concurrent calls on the same StringView instance are therefore reentrant and safe without additional synchronization.

The function is part of a family of search operations in ara::core::StringView and complements the overloads for searching for differing subsequences via StringView [SWS_CORE_02173] as well as pointer-length pairs or null-terminated C strings [SWS_CORE_02175] [SWS_CORE_02176]. A functional equivalent for mutable strings exists in ara::core::BasicString [SWS_CORE_03340], which, in contrast to StringView, is declared as not exception safe.

The member function find_first_not_of of class ara::core::StringView serves according to [SWS_CORE_02175] to synchronously find the first character within the string that does not occur in a predefined character sequence. The behavior basically corresponds to the usage in [string.view] with the documented deviation that the function is declared as noexcept [SWS_CORE_02175]. Interpretation: Via the reference to [string.view], parameters s, pos, and n are likely to limit the search starting from position pos to the first n characters of array s [SWS_CORE_02175]. Question Q-745f5bc9246c11a2 (open)

Usage and Error Handling

The function is defined as constexpr and const, is provided via the header file #include "ara/core/string_view.h", and returns an index of type size_type [SWS_CORE_02175]. The specification classifies the method as exception safe [SWS_CORE_02175]. Since it is specified as noexcept, it throws no exceptions; error codes or messages to DET or DEM are not defined [SWS_CORE_02175].

Interaction and Alternatives

In ara::core::StringView, related overloads are provided for different search patterns:

• Search via another string view StringView according to [SWS_CORE_02173],
• Search for the first deviation from a single character c according to [SWS_CORE_02174], and
• Search using a null-terminated pointer const char *s without explicit length specification according to [SWS_CORE_02176].

In contrast to the structurally similar signature in ara::core::BasicString [SWS_CORE_03338], which is classified as not exception safe and does not feature noexcept, the variant in StringView offers complete exception safety [SWS_CORE_02175].

The member function find_first_not_of of class ara::core::StringView ([SWS_CORE_02176]) from header ara/core/string_view.h searches synchronously starting from start position pos for the first character that does not occur in string s. The behavior corresponds to the definition in [string.view], but deviates by being explicitly designated as noexcept ([SWS_CORE_02176]). Interpretation: From the standard reference to [string.view], it likely follows that s must point to a valid, null-terminated character array and that npos is returned in case of failure. Question Q-aa48a331975274a1 (open)

Regarding error handling, the function is specified as exception safe (exception safe) ([SWS_CORE_02176]). No exceptions are thrown; runtime error notifications via AUTOSAR mechanisms such as DET or DEM are not defined for this function in the payload.

Due to being qualified as constexpr and const ([SWS_CORE_02176]), the search operation does not modify the state of the StringView object. It is reentrant and can be executed in arbitrary threads as well as already at compile time in constant expressions.

In interaction with related interfaces, the function complements further overloads within ara::core::StringView, namely for searching with a StringView ([SWS_CORE_02173]), a single character char ([SWS_CORE_02174]), or a buffer with length restriction n ([SWS_CORE_02175]). In contrast to the pointer-based overloads in ara::core::BasicString ([SWS_CORE_03338], [SWS_CORE_03339]), which are classified as not exception safe, this variant on StringView guarantees complete exception safety.

The member function find_first_of of class ara::core::StringView ([SWS_CORE_02165]) searches a character sequence synchronously starting from index pos for the first occurrence of any character from the passed character view s. The method returns the found position as an index of type size_type.

According to the specification, the function is declared as noexcept and classified as exception-safe (exception safe) ([SWS_CORE_02165]). It throws no exceptions and reports no errors to DET or DEM. Interpretation: If no matching character is found or the start index is outside the valid range, the result is likely to correspond to the value npos, analogous to the standard semantics of [string.view]. Question Q-ad877979579b5bd1 (open)

Since find_first_of is specified as const, calling it performs no state changes ([SWS_CORE_02165]). Concurrent read accesses to the same instance are possible without additional synchronization. Thanks to the designation as constexpr, the search can additionally be evaluated at compile time.

In module core, further overloads exist for ara::core::StringView, including for individual characters ([SWS_CORE_02166]), pointers with an explicit character count ([SWS_CORE_02167]), and null-terminated strings ([SWS_CORE_02168]). In class ara::core::BasicString, a comparable overload for StringView is provided with [SWS_CORE_03317]; in contrast to StringView, however, the pointer-based search functions there are declared as not exception safe ([SWS_CORE_03330]).

use

The member function find_first_of of class ara::core::StringView serves to synchronously search for the first occurrence of a character within the referenced string [SWS_CORE_02166]. It is available via the header ara/core/string_view.h and accepts the sought character c as well as optionally the start position pos, which is set to 0 by default. The function returns the index of the match of type size_type according to the behavior in [string.view] [SWS_CORE_02166]. As a constexpr method, it can be executed both at runtime and during compilation.

Error handling

The function is declared as noexcept and explicitly classified as “exception safe” [SWS_CORE_02166]. No exceptions are thrown, and the specification defines no specific error codes or reports to Development Error Tracer (DET) or Diagnostic Event Manager (DEM).

Concurrency and Limitations

As a const member function (const), calling it does not modify the instance of ara::core::StringView [SWS_CORE_02166]. Interpretation: Parallel, reading invocations on the same object from multiple threads are therefore likely to be reentrant and concurrently safe as long as the underlying character buffer remains unchanged. Question Q-b86dddc1a54a05e1 (open)

Interaction

The function is part of the search interfaces of ara::core::StringView. In addition to searching for single characters, analogous overloads, likewise specified as noexcept, exist for substrings via StringView [SWS_CORE_02165] as well as pointer representations [SWS_CORE_02167], [SWS_CORE_02168]. In contrast, class ara::core::BasicString declares related overloads for single characters [SWS_CORE_03332] and pointers [SWS_CORE_03330], [SWS_CORE_03331] without noexcept and classifies them as “not exception safe”, whereas the string variants with BasicString [SWS_CORE_03329] and StringView [SWS_CORE_03317] remain exception-safe.

The member function find_first_of of class ara::core::StringView ([SWS_CORE_02167]) from the header file #include "ara/core/string_view.h" searches synchronously for the first occurrence of a character from the character sequence s starting from position pos. Parameter n limits the number of characters to consider from the passed pointer. The function returns the found position as size_type; if no character is found, the value npos is likely returned according to [string.view]. Question Q-eac57a47043e5b33 (open)

The following specifications apply to the call context and error handling:

• Exception safety and compile-time evaluation: The method is defined as constexpr and const. As a deviation from standard [string.view], it is explicitly declared with noexcept and specified as “exception safe” ([SWS_CORE_02167]). No exceptions are thrown and no error codes are reported.
• Related overloads in StringView: In addition, variants for string pointers without length limitation ([SWS_CORE_02168]), for ara::core::StringView objects ([SWS_CORE_02165]), and for single characters ([SWS_CORE_02166]) are available, which are likewise noexcept.
• Differentiation from BasicString: In contrast to the corresponding overload in ara::core::BasicString ([SWS_CORE_03330]), which is listed as “not exception safe” and without noexcept, the StringView implementation guarantees complete freedom from exceptions ([SWS_CORE_02167]).

use

The member function find_first_of of class ara::core::StringView from header ara/core/string_view.h searches the character view starting from position pos synchronously for the first occurrence of any character from the string s [SWS_CORE_02168]. As return value, it provides the corresponding index as size_type. Due to the specification as constexpr, this search operation can already be executed at compile time [SWS_CORE_02168].

Error Handling and Concurrency

The function is declared as noexcept and specified as exception safe (exception safe) [SWS_CORE_02168]. Specific error codes or reports to DET or DEM do not exist. Since the method does not modify the state of the instance (const), concurrent read access from multiple threads is safe. Interpretation: Since the signature does not provide a length parameter, the caller is likely required to pass a valid null-terminated C string to s in order to avoid undefined behavior. Question Q-6b692ff18063aef5 (open)

Interaction

Within ara::core::StringView, the function complements the overloads for StringView [SWS_CORE_02165], single characters [SWS_CORE_02166], and character sequences with explicit length limitation n [SWS_CORE_02167], all of which are defined as constexpr and noexcept. In contrast to the analogous pointer search functions in ara::core::BasicString, which are classified as not exception safe (not exception safe) [SWS_CORE_03330], [SWS_CORE_03331], the implementation in ara::core::StringView guarantees complete freedom from exceptions [SWS_CORE_02168].