Owned values that cross a DLL without the caller's CRT. More...
Namespaces | |
| namespace | Detail |
| Private helpers. | |
| namespace | Heap |
| Allocate and free raw blocks on Base's heap. | |
| namespace | this_thread |
| Operations on the calling execution. | |
Classes | |
| struct | Hash< StormByte::ByteSize > |
| class | Atomic |
| Atomic word of one, two, four or eight bytes. More... | |
| class | Binary |
Owned contiguous sequence of std::byte, stored in a Vector. More... | |
| struct | Hash< StormByte::Safe::Binary > |
| Cross-module hash of the byte sequence. More... | |
| class | Callback |
| Callback with explicitly cloned context and creator-module release. More... | |
| class | Clonable |
| Polymorphic copy and move through a base. More... | |
| class | ConditionVariable |
| Wakes threads waiting on a Mutex. More... | |
| class | ConditionVariableAny |
| Wakes a thread that waits with any lock it can drop and retake. More... | |
| class | Deque |
| Double-ended sequence stored on Base's heap. More... | |
| class | Exception |
| Base exception for Safe. More... | |
| class | AllocationError |
| Memory allocation failed under Safe. More... | |
| class | ExpiredWeakPointerError |
| A shared owner cannot be obtained from an empty or expired observer. More... | |
| class | OutOfBoundsError |
| An index or range is out of bounds. More... | |
| class | BadOptionalAccess |
| An empty Optional was dereferenced. More... | |
| class | BadVariantAccess |
| A variant was read with the wrong alternative, or while valueless. More... | |
| class | ExclusiveLock |
| Owns at most one exclusive hold of a SharedMutex. More... | |
| class | Function |
| Copyable, creator-context callback with a typed signature. More... | |
| class | Function< void(Args...)> |
| Typed callback specialization for void-returning signatures. More... | |
| class | Function< Return(Args...)> |
| Typed callback specialization for value-returning signatures. More... | |
| class | Hash |
| Cross-module hash. More... | |
| struct | Hash< T > |
| Hash of an integral or enumeration value. More... | |
| struct | Hash< T * > |
| Hash of a pointer identity. More... | |
| class | Iterable |
| Gives a Safe component the iterators of its category. More... | |
| class | List |
| Doubly linked list stored on Base's heap. More... | |
| class | Map |
| Ordered unique-key map stored on Base's heap. More... | |
| struct | DeferLock |
| Do not lock the mutex in the UniqueLock constructor. More... | |
| struct | TryToLock |
| Try to lock the mutex in the UniqueLock constructor. More... | |
| struct | AdoptLock |
| The calling thread already owns the mutex. More... | |
| class | Mutex |
| Non-recursive mutex. More... | |
| class | Optional |
| std::optional stored on Base's heap. More... | |
| struct | Hash< StormByte::Safe::Optional< T > > |
| Cross-module hash of a StormByte::Safe::Optional. More... | |
| class | Pair |
| std::pair whose members keep their own Safe storage. More... | |
| class | PairReference |
| Tuple-like proxy for an immutable first value and callback-backed second value. More... | |
| struct | Hash< StormByte::Safe::Pair< First, Second > > |
| Cross-module hash of a StormByte::Safe::Pair. More... | |
| class | Shared |
| Forward declaration of shared ownership. More... | |
| class | Unique |
| Forward declaration of unique ownership. More... | |
| class | Weak |
| Forward declaration of weak ownership. More... | |
| class | AtomicShared |
| Atomic publication of a Shared. More... | |
| class | EnableSharedFromThis |
| Base that can recover a Shared from an object owned by one. More... | |
| struct | Hash< StormByte::Safe::Shared< T > > |
| struct | Hash< StormByte::Safe::Unique< T > > |
| struct | Hash< StormByte::Safe::Weak< T > > |
| class | Queue |
| FIFO sequence stored on Base's heap. More... | |
| struct | ReplaceTokenSpec |
| One ReplaceToken field. More... | |
| struct | ReplaceTokenPlace |
| Where a field sits in the pattern, and how to render its argument. More... | |
| class | SecureBinary |
| Binary for secrets: every byte it drops or releases is zeroed first. More... | |
| class | Set |
| Ordered unique values stored on Base's heap. More... | |
| class | SharedLock |
| Owns at most one shared hold of a SharedMutex. More... | |
| class | SharedMutex |
| Non-recursive shared mutex. More... | |
| class | String |
| Owned UTF-8 text. More... | |
| struct | Hash< StormByte::Safe::String > |
| class | Thread |
| Execution owned by Base. More... | |
| class | UniqueLock |
| Owns at most one Mutex. More... | |
| class | UnorderedMap |
| Unique-key hash map stored on Base's heap. More... | |
| class | UnorderedSet |
| Unique values stored in a Base-heap hash table. More... | |
| struct | Monostate |
| Empty alternative. More... | |
| class | Variant |
| std::variant stored on Base's heap. More... | |
| struct | Hash< StormByte::Safe::Variant< Ts... > > |
| struct | Hash< StormByte::Safe::Monostate > |
| class | Vector |
| Contiguous sequence stored on Base's heap. More... | |
| class | WString |
| Wide counterpart of String. More... | |
| struct | Hash< StormByte::Safe::WString > |
| struct | Hash< StormByte::Size > |
Concepts | |
| concept | ValidSmartPointer |
true when SmartPointer is StormByte::Safe::Shared<T> or StormByte::Safe::Unique<T>. | |
| concept | ReplaceTokenBuiltin |
True when FormatReplaceToken always writes T and never asks for a string conversion. | |
Typedefs | |
| using | Owner = Detail::Owner |
| Public name for opaque state ownership through provider callbacks. | |
Enumerations | |
| enum class | MemoryOrder : unsigned char { Relaxed , Consume , Acquire , Release , AcqRel , SeqCst } |
| Ordering for a Atomic operation. More... | |
| enum class | CvStatus : unsigned char { NoTimeout , Timeout } |
| Why a timed wait returned. More... | |
| enum class | Status : unsigned char { Success , Missing , Failure } |
| Result of a collection operation; exceptions never leave its owner callback. More... | |
Functions | |
| void | swap (Binary &left, Binary &right) noexcept |
| Exchange two sequences. | |
| bool | operator== (std::span< const std::byte > bytes, const Binary &data) noexcept |
| Equality of a span against a sequence. | |
| bool | operator!= (std::span< const std::byte > bytes, const Binary &data) noexcept |
| Inequality of a span against a sequence. | |
| STORMBYTE_FORCE_INLINE std::strong_ordering | operator<=> (std::span< const std::byte > bytes, const Binary &data) noexcept |
| Three-way comparison of a span against a sequence. | |
| void | ThrowDequeOutOfBounds () |
| Throw the deque out-of-bounds error from Base. | |
| void | ThrowDequeOutOfBounds (const Size &index) |
| template<Type::SafeValue T> | |
| bool | operator== (const Deque< T > &left, const Deque< T > &right) |
| Whether two deques contain equal elements. | |
| template<Type::SafeValue T> | |
| STORMBYTE_FORCE_INLINE std::strong_ordering | operator<=> (const Deque< T > &left, const Deque< T > &right) |
| Order two deques lexicographically. | |
| template<Type::SafeValue T> | |
| void | swap (Deque< T > &left, Deque< T > &right) noexcept |
| Exchange two deques. | |
| void | swap (ExclusiveLock &left, ExclusiveLock &right) noexcept |
| Exchange two exclusive locks. | |
| STORMBYTE_FORCE_INLINE std::size_t | HashBytes (std::span< const std::byte > bytes) noexcept |
| Mix a byte range with FNV-1a. | |
| STORMBYTE_FORCE_INLINE std::size_t | HashCombine (std::size_t seed, std::size_t next) noexcept |
| Mix an existing hash with another. | |
| template<Type::SafeValue T> | |
| void | swap (List< T > &left, List< T > &right) noexcept |
| Exchange two lists. | |
| template<Type::SafeValue K, Type::SafeValue V, class Compare> | |
| void | swap (Map< K, V, Compare > &left, Map< K, V, Compare > &right) noexcept |
| Exchange two maps. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 0) | |
| constexpr First & | get (Pair< First, Second > &pair) noexcept |
| Access the first pair member. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 1) | |
| constexpr Second & | get (Pair< First, Second > &pair) noexcept |
| Access the second pair member. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 0) | |
| constexpr const First & | get (const Pair< First, Second > &pair) noexcept |
| Access the first pair member through a const pair. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 1) | |
| constexpr const Second & | get (const Pair< First, Second > &pair) noexcept |
| Access the second pair member through a const pair. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 0) | |
| constexpr First && | get (Pair< First, Second > &&pair) noexcept |
| Move-access the first pair member. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 1) | |
| constexpr Second && | get (Pair< First, Second > &&pair) noexcept |
| Move-access the second pair member. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 0) | |
| constexpr const First && | get (const Pair< First, Second > &&pair) noexcept |
| Read the first member from a const rvalue pair. | |
| template<std::size_t Index, Type::SafeValue First, Type::SafeValue Second> requires (Index == 1) | |
| constexpr const Second && | get (const Pair< First, Second > &&pair) noexcept |
| Read the second member from a const rvalue pair. | |
| template<class T, class... Args> | |
| Shared< T > | MakeShared (Args &&... args) |
Construct T on Base's heap and share it. | |
| template<class T, class... Args> | |
| Unique< T > | MakeUnique (Args &&... args) |
Construct T on Base's heap and own it. | |
| template<class T, class U> | |
| Shared< T > | StaticPointerCast (const Shared< U > &from) noexcept |
| static_cast of the stored pointer. | |
| template<class T, class U> | |
| Shared< T > | DynamicPointerCast (const Shared< U > &from) noexcept |
| dynamic_cast of the stored pointer. | |
| template<class T, class U> | |
| Shared< T > | ConstPointerCast (const Shared< U > &from) noexcept |
| const_cast of the stored pointer. | |
| template<class T, class U> | |
| Shared< T > | ReinterpretPointerCast (const Shared< U > &from) noexcept |
| reinterpret_cast of the stored pointer. | |
| template<class T, class U> | |
| STORMBYTE_FORCE_INLINE bool | operator== (const Shared< T > &left, const Shared< U > &right) noexcept |
| Same stored pointer. | |
| template<class T, class U> | |
| STORMBYTE_FORCE_INLINE std::strong_ordering | operator<=> (const Shared< T > &left, const Shared< U > &right) noexcept |
| Order of the stored pointers. | |
| template<class T> | |
| STORMBYTE_FORCE_INLINE bool | operator== (const Shared< T > &left, std::nullptr_t null) noexcept |
| Compare an owner with null. | |
| template<class T> | |
| STORMBYTE_FORCE_INLINE std::strong_ordering | operator<=> (const Shared< T > &left, std::nullptr_t null) noexcept |
| Order an owner against null. | |
| template<class T, class U> | |
| STORMBYTE_FORCE_INLINE bool | operator== (const Unique< T > &left, const Unique< U > &right) noexcept |
| Same stored pointer. | |
| template<class T, class U> | |
| STORMBYTE_FORCE_INLINE std::strong_ordering | operator<=> (const Unique< T > &left, const Unique< U > &right) noexcept |
| Order of the stored pointers. | |
| template<class T> | |
| STORMBYTE_FORCE_INLINE bool | operator== (const Unique< T > &left, std::nullptr_t null) noexcept |
| Compare an owner with null. | |
| template<class T> | |
| STORMBYTE_FORCE_INLINE std::strong_ordering | operator<=> (const Unique< T > &left, std::nullptr_t null) noexcept |
| Order an owner against null. | |
| template<class T> | |
| void | swap (Shared< T > &left, Shared< T > &right) noexcept |
| Exchange two owners. | |
| template<class T> | |
| void | swap (Unique< T > &left, Unique< T > &right) noexcept |
| Exchange two owners. | |
| template<class T> | |
| void | swap (Weak< T > &left, Weak< T > &right) noexcept |
| Exchange two observers. | |
| void | ThrowQueueOutOfBounds () |
| Throw the queue out-of-bounds error from Base. | |
| template<Type::SafeValue T> | |
| void | swap (Queue< T > &left, Queue< T > &right) noexcept |
| Exchange two queues. | |
| template<class Char> | |
| constexpr bool | ParseReplaceTokenSpec (const Char *data, std::size_t count, ReplaceTokenSpec &out) noexcept |
| Parse the inside of one {...}. | |
| template<class Char> | |
| std::size_t | FindReplaceTokens (std::basic_string_view< Char > text, ReplaceTokenPlace< Char > *places, std::size_t capacity) noexcept |
Collect up to capacity fields, in order. | |
| template<class Char, class T> | |
| bool | FormatReplaceToken (std::basic_string< Char > &out, T &&value, const ReplaceTokenSpec &spec) |
| Render one argument when it does not need an owned-string conversion. | |
| template<Type::SafeValue K, class Compare> | |
| void | swap (Set< K, Compare > &left, Set< K, Compare > &right) noexcept |
| Exchange two sets. | |
| void | swap (SharedLock &left, SharedLock &right) noexcept |
| Exchange two shared locks. | |
| STORMBYTE_FORCE_INLINE std::ostream & | operator<< (std::ostream &stream, const String &text) |
Writes text to stream. | |
| bool | operator== (const char *str, const String &text) noexcept |
| Content equality. | |
| bool | operator!= (const char *str, const String &text) noexcept |
| Content inequality. | |
| String | operator+ (const String &left, const String &right) |
| Concatenate two texts. | |
| void | swap (String &left, String &right) noexcept |
| Swaps two texts. | |
| void | swap (Thread &left, Thread &right) noexcept |
| Exchange two executions. | |
| void | swap (UniqueLock &left, UniqueLock &right) noexcept |
| Exchange two locks. | |
| template<Type::SafeValue K, Type::SafeValue V, class Hash, class KeyEqual> | |
| void | swap (UnorderedMap< K, V, Hash, KeyEqual > &left, UnorderedMap< K, V, Hash, KeyEqual > &right) noexcept |
| Exchange two maps. | |
| template<Type::SafeValue K, class Hash, class KeyEqual> | |
| void | swap (UnorderedSet< K, Hash, KeyEqual > &left, UnorderedSet< K, Hash, KeyEqual > &right) noexcept |
| Exchange two sets. | |
| template<class T, Type::SafeValue... Ts> | |
| bool | holds_alternative (const Variant< Ts... > &value) noexcept |
Whether value holds T. | |
| template<std::size_t I, Type::SafeValue... Ts> | |
| auto & | get (Variant< Ts... > &value) |
Read the alternative at I. | |
| template<std::size_t I, Type::SafeValue... Ts> | |
| const auto & | get (const Variant< Ts... > &value) |
Read the alternative at I. | |
| template<class T, Type::SafeValue... Ts> | |
| T & | get (Variant< Ts... > &value) |
Read the alternative T. | |
| template<class T, Type::SafeValue... Ts> | |
| const T & | get (const Variant< Ts... > &value) |
Read the alternative T. | |
| template<std::size_t I, Type::SafeValue... Ts> | |
| auto * | get_if (Variant< Ts... > *value) noexcept |
Pointer to the alternative at I, or null. | |
| template<std::size_t I, Type::SafeValue... Ts> | |
| const auto * | get_if (const Variant< Ts... > *value) noexcept |
Pointer to the alternative at I, or null. | |
| template<class T, Type::SafeValue... Ts> | |
| T * | get_if (Variant< Ts... > *value) noexcept |
Pointer to the alternative T, or null. | |
| template<class T, Type::SafeValue... Ts> | |
| const T * | get_if (const Variant< Ts... > *value) noexcept |
Pointer to the alternative T, or null. | |
| template<class Visitor, Type::SafeValue... Ts> | |
| decltype(auto) | visit (Visitor &&visitor, Variant< Ts... > &value) |
Call visitor with the active alternative. | |
| template<class Visitor, Type::SafeValue... Ts> | |
| decltype(auto) | visit (Visitor &&visitor, const Variant< Ts... > &value) |
Call visitor with the active alternative. | |
| template<Type::SafeValue... Ts> | |
| void | swap (Variant< Ts... > &left, Variant< Ts... > &right) noexcept |
| Swaps two variants. | |
| void | ThrowVectorOutOfBounds () |
| Throw the vector out-of-bounds error from Base. | |
| void | ThrowVectorOutOfBounds (const Size &index) |
| template<Type::SafeValue T> | |
| void | swap (Vector< T > &lhs, Vector< T > &rhs) noexcept |
| Exchange two sequences. | |
| STORMBYTE_FORCE_INLINE std::wostream & | operator<< (std::wostream &stream, const WString &text) |
Writes text to stream. | |
| bool | operator== (const wchar_t *str, const WString &text) noexcept |
| Content equality. | |
| bool | operator!= (const wchar_t *str, const WString &text) noexcept |
| Content inequality. | |
| WString | operator+ (const WString &left, const WString &right) |
| Concatenate two texts. | |
| void | swap (WString &left, WString &right) noexcept |
| Swaps two texts. | |
Variables | |
| constexpr DeferLock | defer_lock {} |
| Tag value for DeferLock. | |
| constexpr TryToLock | try_to_lock {} |
| Tag value for TryToLock. | |
| constexpr AdoptLock | adopt_lock {} |
| Tag value for AdoptLock. | |
Owned values that cross a DLL without the caller's CRT.
Unit count. Defined in size.hxx. Forwarded so Type::Sized can name it.
Owned UTF-8 and wide text.
Types that are safe to pass across a DLL boundary: owners and polymorphic clones on Base's heap.
Types safe to pass across a DLL boundary.
Short UTF-8 lives in the object; the long path is Base-owned SDS.
Short wide text lives in the object; the long path is Base-owned.
Suite text types owned by Base.
| using StormByte::Safe::Owner = Detail::Owner |
Public name for opaque state ownership through provider callbacks.
Copy invokes the provider's Clone callback; destruction invokes its Destroy callback. This is conditionally DLL-safe only when the state and callbacks meet the documented MaybeSafe requirements and the provider module remains loaded for every live owner.
|
strong |
|
strong |
Ordering for a Atomic operation.
Same meaning as the standard orders. Not an alias of std::memory_order.
| Enumerator | |
|---|---|
| Relaxed | No inter-thread ordering. |
| Consume | Consume. The implementation promotes it to acquire. |
| Acquire | Acquire. |
| Release | Release. |
| AcqRel | Acquire plus release. |
| SeqCst | Sequentially consistent. |
|
strong |
|
noexcept |
Collect up to capacity fields, in order.
| Char | char or wchar_t. |
| text | Pattern. |
| places | Output. Only the first returned count is written. |
| capacity | Slots available. |
| bool StormByte::Safe::FormatReplaceToken | ( | std::basic_string< Char > & | out, |
| T && | value, | ||
| const ReplaceTokenSpec & | spec ) |
Render one argument when it does not need an owned-string conversion.
| Char | char or wchar_t. |
| T | Argument type, including references. |
| out | Caller scratch. Replaced when this returns true. |
| value | Argument. A view is copied into out. A pointer is not dereferenced. |
| spec | Field spec. A default spec keeps the historical conversion. |
value through std::string / String or the wide equivalents.
|
constexprnoexcept |
Read the second member from a const rvalue pair.
| Index | Member index, which must be one. |
| pair | Pair to access. |
|
constexprnoexcept |
Read the first member from a const rvalue pair.
| Index | Member index, which must be zero. |
| pair | Pair to access. |
|
constexprnoexcept |
Access the second pair member through a const pair.
| Index | Member index, which must be one. |
| pair | Pair to access. |
|
constexprnoexcept |
Access the first pair member through a const pair.
| Index | Member index, which must be zero. |
| pair | Pair to access. |
| const T & StormByte::Safe::get | ( | const Variant< Ts... > & | value | ) |
Read the alternative T.
| T | Alternative. It occurs once. |
| Ts | Alternatives. |
| value | Variant. |
| BadVariantAccess | T is not active. |
| const auto & StormByte::Safe::get | ( | const Variant< Ts... > & | value | ) |
Read the alternative at I.
| I | Alternative index. |
| Ts | Alternatives. |
| value | Variant. |
| BadVariantAccess | The index is not active. |
|
constexprnoexcept |
Move-access the second pair member.
| Index | Member index, which must be one. |
| pair | Pair to access. |
|
constexprnoexcept |
Move-access the first pair member.
| Index | Member index, which must be zero. |
| pair | Pair to access. |
|
constexprnoexcept |
Access the second pair member.
| Index | Member index, which must be one. |
| pair | Pair to access. |
|
constexprnoexcept |
Access the first pair member.
| Index | Member index, which must be zero. |
| pair | Pair to access. |
| T & StormByte::Safe::get | ( | Variant< Ts... > & | value | ) |
Read the alternative T.
| T | Alternative. It occurs once. |
| Ts | Alternatives. |
| value | Variant. |
| BadVariantAccess | T is not active. |
| auto & StormByte::Safe::get | ( | Variant< Ts... > & | value | ) |
Read the alternative at I.
| I | Alternative index. |
| Ts | Alternatives. |
| value | Variant. |
| BadVariantAccess | The index is not active. |
|
noexcept |
Pointer to the alternative T, or null.
| T | Alternative. It occurs once. |
| Ts | Alternatives. |
| value | Variant. |
T is not active.
|
noexcept |
Pointer to the alternative at I, or null.
| I | Alternative index. |
| Ts | Alternatives. |
| value | Variant. |
|
noexcept |
Pointer to the alternative T, or null.
| T | Alternative. It occurs once. |
| Ts | Alternatives. |
| value | Variant. |
T is not active.
|
noexcept |
Pointer to the alternative at I, or null.
| I | Alternative index. |
| Ts | Alternatives. |
| value | Variant. |
|
noexcept |
Mix a byte range with FNV-1a.
Empty is a defined value.
| bytes | Bytes. May be empty. |
|
noexcept |
Mix an existing hash with another.
Order matters.
| seed | Hash so far. |
| next | Next hash. |
|
noexcept |
Whether value holds T.
| T | Alternative. |
| Ts | Alternatives. |
| value | Variant. |
T. | Shared< T > StormByte::Safe::MakeShared | ( | Args &&... | args | ) |
Construct T on Base's heap and share it.
| T | Object type. |
| Args | Constructor argument types. |
| args | Arguments forwarded to T. |
| AllocationError | The block could not be allocated. |
| Unique< T > StormByte::Safe::MakeUnique | ( | Args &&... | args | ) |
Construct T on Base's heap and own it.
| T | Object type. |
| Args | Constructor argument types. |
| args | Arguments forwarded to T. |
| AllocationError | The block could not be allocated. |
|
inlinenoexcept |
Content inequality.
| str | C string; may be null. |
| text | Text. |
|
inlinenoexcept |
Content inequality.
| str | Wide C string; may be null. |
| text | Text. |
|
inlinenoexcept |
Inequality of a span against a sequence.
| bytes | Left view. |
| data | Right sequence. |
data != bytes. Concatenate two texts.
A literal or a view converts to String.
| left | Left text. |
| right | Right text. |
| AllocationError | The long path could not be allocated. |
Concatenate two texts.
A literal or a view converts to WString.
| left | Left text. |
| right | Right text. |
| AllocationError | The long path could not be allocated. |
| STORMBYTE_FORCE_INLINE std::ostream & StormByte::Safe::operator<< | ( | std::ostream & | stream, |
| const String & | text ) |
Writes text to stream.
| stream | Destination. Caller-owned stream. |
| text | Source. |
stream. | STORMBYTE_FORCE_INLINE std::wostream & StormByte::Safe::operator<< | ( | std::wostream & | stream, |
| const WString & | text ) |
Writes text to stream.
Instantiated in the caller.
| stream | Destination. Caller-owned stream. |
| text | Source. |
stream. | STORMBYTE_FORCE_INLINE std::strong_ordering StormByte::Safe::operator<=> | ( | const Deque< T > & | left, |
| const Deque< T > & | right ) |
Order two deques lexicographically.
| T | Element. |
| left | Left deque. |
| right | Right deque. |
|
noexcept |
|
noexcept |
Order an owner against null.
| T | Pointee. |
| left | Owner. |
| null | Null pointer constant. |
|
noexcept |
|
noexcept |
Order an owner against null.
| T | Pointee. |
| left | Owner. |
| null | Null pointer constant. |
|
noexcept |
Three-way comparison of a span against a sequence.
| bytes | Left view. |
| data | Right sequence. |
data <=> bytes.
|
inlinenoexcept |
Content equality.
| str | C string; may be null. |
| text | Text. |
| bool StormByte::Safe::operator== | ( | const Deque< T > & | left, |
| const Deque< T > & | right ) |
Whether two deques contain equal elements.
| T | Element. |
| left | Left deque. |
| right | Right deque. |
|
noexcept |
|
noexcept |
Compare an owner with null.
| T | Pointee. |
| left | Owner. |
| null | Null pointer constant. |
left is empty.
|
noexcept |
|
noexcept |
Compare an owner with null.
| T | Pointee. |
| left | Owner. |
| null | Null pointer constant. |
left is empty.
|
inlinenoexcept |
Content equality.
| str | Wide C string; may be null. |
| text | Text. |
|
inlinenoexcept |
Equality of a span against a sequence.
| bytes | Left view. |
| data | Right sequence. |
data == bytes.
|
constexprnoexcept |
Parse the inside of one {...}.
| Char | char or wchar_t. |
| data | Spec text, without the braces. |
| count | Number of code units. |
| out | Parsed spec. Untouched when this returns false. |
data is empty or a supported spec. Exchange two sequences.
| left | First sequence. |
| right | Second sequence. |
|
noexcept |
Exchange two deques.
| T | Element. |
| left | Left deque. |
| right | Right deque. |
|
inlinenoexcept |
Exchange two exclusive locks.
| left | First lock. |
| right | Second lock. |
|
inlinenoexcept |
Exchange two queues.
Does not allocate.
| T | Safe value. |
| left | First queue. |
| right | Second queue. |
|
inlinenoexcept |
Exchange two sets.
| K | Value type. |
| Compare | Ordering. |
| left | Left set. |
| right | Right set. |
|
inlinenoexcept |
Exchange two shared locks.
| left | First lock. |
| right | Second lock. |
Swaps two texts.
| left | First text. |
| right | Second text. |
Exchange two executions.
| left | Left thread. |
| right | Right thread. |
|
inlinenoexcept |
Exchange two locks.
| left | First lock. |
| right | Second lock. |
|
noexcept |
|
inlinenoexcept |
Exchange two sets.
| K | Value type. |
| Hash | Value hash. |
| KeyEqual | Value equality. |
| left | Left set. |
| right | Right set. |
|
noexcept |
Swaps two variants.
| Ts | Alternatives. |
| left | First variant. |
| right | Second variant. |
|
noexcept |
Exchange two sequences.
| lhs | First sequence. |
| rhs | Second sequence. |
Exchange two observers.
| T | Pointee. |
| left | Observer. |
| right | Observer. |
Swaps two texts.
| left | First text. |
| right | Second text. |
| void StormByte::Safe::ThrowDequeOutOfBounds | ( | ) |
Throw the deque out-of-bounds error from Base.
| OutOfBoundsError | Always. |
| void StormByte::Safe::ThrowDequeOutOfBounds | ( | const Size & | index | ) |
| void StormByte::Safe::ThrowQueueOutOfBounds | ( | ) |
Throw the queue out-of-bounds error from Base.
| OutOfBoundsError | Always. |
| void StormByte::Safe::ThrowVectorOutOfBounds | ( | ) |
Throw the vector out-of-bounds error from Base.
| OutOfBoundsError | Always. |
| void StormByte::Safe::ThrowVectorOutOfBounds | ( | const Size & | index | ) |
| decltype(auto) StormByte::Safe::visit | ( | Visitor && | visitor, |
| const Variant< Ts... > & | value ) |
Call visitor with the active alternative.
| Visitor | Callable. |
| Ts | Alternatives. |
| visitor | Callable. |
| value | Variant. |
visitor returns. | BadVariantAccess | value is valueless. |
| decltype(auto) StormByte::Safe::visit | ( | Visitor && | visitor, |
| Variant< Ts... > & | value ) |
Call visitor with the active alternative.
| Visitor | Callable. |
| Ts | Alternatives. |
| visitor | Callable. |
| value | Variant. |
visitor returns. | BadVariantAccess | value is valueless. |