Named concepts and small type utilities used across the suite. More...
Namespaces | |
| namespace | Detail |
| Private helpers for Safe classification. | |
Classes | |
| struct | IsMaybeSafe< Safe::Callback > |
| Recognizes explicit callback ownership, not a copyable collection value. More... | |
| struct | IsSafe< Safe::Clonable< T, SmartPointer > > |
| Recognizes Safe polymorphic clone interfaces, without certifying derived implementations. More... | |
| struct | IsMaybeSafe< Safe::Clonable< T, SmartPointer > > |
| Propagates conditional pointee or owner safety to Clonable. More... | |
| struct | IsMaybeSafe< Safe::Function< void(Args...)> > |
| Classifies provider-implemented typed callbacks as conditional. More... | |
| struct | IsMaybeSafe< Safe::Function< Return(Args...)> > |
| Classifies provider-implemented value-returning callbacks as conditional. More... | |
| struct | IsSafe< Safe::Iterable< Component > > |
| Recognizes an iterable facade of an already safe component. More... | |
| struct | IsMaybeSafe< Safe::Iterable< Component > > |
| Propagates conditional safety from the wrapped component. More... | |
| struct | IsSafeValue< Safe::Iterable< Component > > |
| Admits an iterable facade as a collection value. More... | |
| struct | IsSafe< Safe::List< T > > |
| A list of a Safe value is Safe. More... | |
| struct | IsMaybeSafe< Safe::List< T > > |
| Propagates conditional safety from the element. More... | |
| struct | IsSafeValue< Safe::List< T > > |
| Admits a Safe list as a collection value. More... | |
| struct | IsSafe< Safe::Map< K, V, Compare > > |
| Recognizes a map of already safe entries. More... | |
| struct | IsMaybeSafe< Safe::Map< K, V, Compare > > |
| Propagates conditional safety from a map entry. More... | |
| struct | IsSafeValue< Safe::Map< K, V, Compare > > |
| Admits a Safe map as a collection value. More... | |
| struct | IsSafe< Safe::Optional< T > > |
| Recognizes an optional of an already safe component. More... | |
| struct | IsMaybeSafe< Safe::Optional< T > > |
| Propagates conditional safety from the contained value. More... | |
| struct | IsSafeOptional< Safe::Optional< T > > |
| Registers a Safe optional for optional-aware generic APIs. More... | |
| struct | IsSafeValue< Safe::Optional< T > > |
| Admits a Safe optional as a collection value. More... | |
| struct | IsMaybeSafe< Safe::Owner > |
| Recognizes opaque owner state whose safety depends on its callbacks. More... | |
| struct | IsSafe< Safe::Pair< First, Second > > |
| Recognizes a pair of already safe values. More... | |
| struct | IsMaybeSafe< Safe::Pair< First, Second > > |
| Propagates conditional safety when either member is conditionally safe. More... | |
| struct | IsSafeValue< Safe::Pair< First, Second > > |
| Admits a pair of safe values as a collection value. More... | |
| struct | IsSafe< Safe::Queue< T > > |
| Recognizes a queue of already safe values. More... | |
| struct | IsMaybeSafe< Safe::Queue< T > > |
| Propagates conditional safety from the element type. More... | |
| struct | IsSafeValue< Safe::Queue< T > > |
| Admits a Safe queue as a collection value. More... | |
| struct | IsSafeQueue< Safe::Queue< T > > |
| Registers a Safe queue for generic queue operations. More... | |
| struct | IsSafe< Safe::UnorderedMap< K, V, Hash, KeyEqual > > |
| A map of Safe entries is Safe. More... | |
| struct | IsMaybeSafe< Safe::UnorderedMap< K, V, Hash, KeyEqual > > |
| Propagates conditional safety from a map entry. More... | |
| struct | IsSafeValue< Safe::UnorderedMap< K, V, Hash, KeyEqual > > |
| Admits a Safe unordered map as a collection value. More... | |
| struct | IsSafe< StormByte::Safe::Monostate > |
| struct | IsSafeValue< StormByte::Safe::Monostate > |
| struct | IsSafe< StormByte::Safe::Variant< Ts... > > |
| struct | IsSafeValue< StormByte::Safe::Variant< Ts... > > |
| struct | IsSafe< Safe::Vector< T > > |
| Recognizes a vector of already safe values. More... | |
| struct | IsMaybeSafe< Safe::Vector< T > > |
| Propagates conditional safety from the element type. More... | |
| struct | IsSafeValue< Safe::Vector< T > > |
| Admits a Safe vector as a collection value. More... | |
| struct | IsSafe< Clock::Values > |
| Coherent clock snapshots contain only fixed-width numeric duration values. More... | |
| struct | IsMaybeSafe< Clock::Sample > |
| Clock samples carry provider-managed shared state and require compatible STL ABI. More... | |
| struct | IsSafe |
| Recognizes Base Safe components, not universal ABI compatibility. More... | |
| struct | IsSafe< T > |
| Arithmetic values cross a DLL boundary by value. More... | |
| struct | IsSafe< StormByte::Exception > |
| Recognizes Base's exception root, whose destructor and message storage are DLL-safe. More... | |
| struct | IsSafe< Safe::Binary > |
| Recognizes Base-owned binary storage. More... | |
| struct | IsSafe< Safe::SecureBinary > |
| Recognizes Base-owned binary storage that zeroes what it drops. More... | |
| struct | IsSafe< Safe::String > |
| Recognizes Base-owned UTF-8 text. More... | |
| struct | IsSafe< Safe::WString > |
| Recognizes Base-owned wide text. More... | |
| struct | IsSafe< Size > |
| Recognizes Base's fixed-width count. More... | |
| struct | IsSafe< ByteSize > |
| Recognizes Base's fixed-width byte count. More... | |
| struct | IsSafe< Safe::Shared< T > > |
| Recognizes shared ownership only when its pointee is IsSafe. More... | |
| struct | IsSafe< Safe::Unique< T > > |
| Recognizes unique ownership only when its pointee is IsSafe. More... | |
| struct | IsSafe< Safe::Weak< T > > |
| Recognizes weak ownership only when its pointee is IsSafe. More... | |
| struct | IsMaybeSafe |
| Recognizes types whose DLL-boundary safety depends on documented provider requirements. More... | |
| struct | IsMaybeSafe< T > |
| Recognizes complete derivatives of StormByte::Exception as conditionally DLL-safe. More... | |
| struct | IsMaybeSafe< Safe::Shared< T > > |
| Shared ownership inherits the pointee's conditional classification. More... | |
| struct | IsMaybeSafe< Safe::Unique< T > > |
| Unique ownership inherits the pointee's conditional classification. More... | |
| struct | IsMaybeSafe< Safe::Weak< T > > |
| Weak ownership inherits the pointee's conditional classification. More... | |
| struct | IsMaybeSafe< std::expected< T, E > > |
| Standard expected is conditionally Safe when its alternatives are Safe components. More... | |
| struct | IsSafeOptional |
| Identifies Safe optional wrappers. More... | |
| struct | IsSafeQueue |
| Identifies Safe FIFO wrappers. More... | |
| struct | IsSafeValue |
| Recognizes collection values with Base-controlled lifetime. More... | |
| struct | IsSafeValue< Safe::Binary > |
| Admits Base-owned binary storage. More... | |
| struct | IsSafeValue< Safe::SecureBinary > |
| Admits Base-owned binary storage that zeroes what it drops. More... | |
| struct | IsSafeValue< Safe::String > |
| Admits Base-owned UTF-8 text. More... | |
| struct | IsSafeValue< Safe::WString > |
| Admits Base-owned wide text. More... | |
| struct | IsSafeValue< Size > |
| Admits Base's fixed-width count. More... | |
| struct | IsSafeValue< ByteSize > |
| Admits Base's fixed-width byte count. More... | |
| struct | IsSafeValue< Safe::Shared< T > > |
| Admits copyable Base-heap shared ownership as a collection value. More... | |
| struct | IsSafeValue< T > |
| Admits enumeration values, which cross module boundaries by value. More... | |
Concepts | |
| concept | Reference |
| Lvalue or rvalue reference type. | |
| concept | LvalueReference |
| Lvalue reference type (std::is_lvalue_reference). | |
| concept | RvalueReference |
| Rvalue reference type (std::is_rvalue_reference). | |
| concept | Pointer |
| Raw (possibly cv-qualified) pointer type. | |
| concept | SmartPointer |
| Smart pointer-like type: dereferenceable and exposes get(). | |
| concept | NullablePointer |
| Smart pointer-like type that can test whether it contains an object. | |
| concept | Integral |
| Integral type (bool, char, int, long, …), including cv. | |
| concept | FloatingPoint |
| Floating-point type (float, double, long double). | |
| concept | Arithmetic |
| Integral or floating-point type. | |
| concept | Signed |
| Signed arithmetic type (std::is_signed). | |
| concept | Unsigned |
| Unsigned arithmetic type (std::is_unsigned). | |
| concept | Numeral |
| Host integer or suite count type. | |
| concept | Const |
| Top-level const qualifier (std::is_const_v). | |
| concept | Class |
| Class or struct type (not union, not enum). | |
| concept | EqualityComparable |
| Type whose == and != both yield something convertible to bool. | |
| concept | ThreeWayComparable |
| Type whose <=> operator is well-formed. | |
| concept | Hashable |
| Type with a valid std::hash specialization. | |
| concept | String |
| Text string types that are not generic containers. | |
| concept | Array |
| std::array<U, N> after stripping cv/ref. | |
| concept | Container |
| Has begin(), end() and value_type, and is not a StormByte::Type::String. | |
| concept | HasKeyType |
| StormByte::Type::Container that publishes a nested key_type. | |
| concept | HasMappedType |
| StormByte::Type::Container that publishes a nested mapped_type. | |
| concept | Sized |
| StormByte::Type::Container that publishes size(). | |
| concept | HasPushBack |
| StormByte::Type::Container that accepts push_back of a value_type. | |
| concept | HasPushFront |
| StormByte::Type::Container that accepts push_front of a value_type. | |
| concept | HasInsert |
| Associative StormByte::Type::Container that accepts insert of a value_type. | |
| concept | HasSubscript |
StormByte::Type::Container that supports operator[] with key/index U. | |
| concept | ConvertibleTo |
From is implicitly convertible to To (std::is_convertible). | |
| concept | ExplicitlyConvertibleTo |
From may be explicitly converted to To with static_cast. | |
| concept | Enum |
| Unscoped or scoped enumeration (enum / enum class). | |
| concept | UnsignedEnum |
| StormByte::Type::Enum whose underlying type is unsigned. | |
| concept | ScopedEnum |
| Scoped enumeration (enum class / enum struct). | |
| concept | TriviallyCopyable |
| Type that may be copied with memcpy / as-if memcpy. | |
| concept | TriviallyDestructible |
| Type with a trivial destructor. | |
| concept | DefaultConstructible |
| Type constructible from an empty initializer (T{} / T()). | |
| concept | TriviallyDefaultConstructible |
| StormByte::Type::DefaultConstructible with a trivial default constructor. | |
| concept | CopyConstructible |
| Type that can actually be copy-constructed. | |
| concept | TriviallyCopyConstructible |
| StormByte::Type::CopyConstructible with a trivial copy constructor. | |
| concept | MoveConstructible |
| Type that can be move-constructed. | |
| concept | TriviallyMoveConstructible |
| StormByte::Type::MoveConstructible with a trivial move constructor. | |
| concept | CopyAssignable |
| Type that can actually be copy-assigned. | |
| concept | TriviallyCopyAssignable |
| StormByte::Type::CopyAssignable with a trivial copy-assignment operator. | |
| concept | MoveAssignable |
| Type that can be move-assigned (operator=(T&&)). | |
| concept | TriviallyMoveAssignable |
| StormByte::Type::MoveAssignable with a trivial move-assignment operator. | |
| concept | Copyable |
| Both StormByte::Type::CopyConstructible and StormByte::Type::CopyAssignable. | |
| concept | Movable |
| Both StormByte::Type::MoveConstructible and StormByte::Type::MoveAssignable. | |
| concept | Swappable |
| Type that can be swapped with std::swap (std::is_swappable). | |
| concept | Destructible |
| Type that can be destroyed. | |
| concept | ConstructibleFrom |
Type constructible from Args (std::constructible_from). | |
| concept | AssignableFrom |
T can be assigned from U (std::assignable_from). | |
| concept | TotallyOrdered |
| Type with equality and a total order. | |
| concept | Semiregular |
| Default-constructible, copyable and movable. | |
| concept | Regular |
| StormByte::Type::Semiregular and equality-comparable. | |
| concept | Range |
| Valid range (std::ranges::range). | |
| concept | InputRange |
| Input range (std::ranges::input_range). | |
| concept | OutputRange |
Output range for values of type T (std::ranges::output_range). | |
| concept | ForwardRange |
| Forward range (std::ranges::forward_range). | |
| concept | BidirectionalRange |
| Bidirectional range (std::ranges::bidirectional_range). | |
| concept | RandomAccessRange |
| Random-access range (std::ranges::random_access_range). | |
| concept | ContiguousRange |
| Contiguous range (std::ranges::contiguous_range). | |
| concept | SizedRange |
| Sized range (std::ranges::sized_range). | |
| concept | CommonRange |
| Common range (std::ranges::common_range). | |
| concept | View |
| Range view (std::ranges::view). | |
| concept | BorrowedRange |
| Borrowed range (std::ranges::borrowed_range). | |
| concept | InputIterator |
| Input iterator (std::input_iterator). | |
| concept | OutputIterator |
Output iterator for values of type T (std::output_iterator). | |
| concept | ForwardIterator |
| Forward iterator (std::forward_iterator). | |
| concept | BidirectionalIterator |
| Bidirectional iterator (std::bidirectional_iterator). | |
| concept | RandomAccessIterator |
| Random-access iterator (std::random_access_iterator). | |
| concept | ContiguousIterator |
| Contiguous iterator (std::contiguous_iterator). | |
| concept | SentinelFor |
| Valid sentinel for an iterator (std::sentinel_for). | |
| concept | SizedSentinelFor |
| Sized sentinel for an iterator (std::sized_sentinel_for). | |
| concept | ByteInputRange |
| Input range whose scalar values can be explicitly converted to std::byte. | |
| concept | ByteInputIterator |
| Input iterator whose scalar values can be explicitly converted to std::byte. | |
| concept | Callable |
Invocable with argument types Args (std::is_invocable). | |
| concept | Invocable |
Regularly invocable with argument types Args (std::invocable). | |
| concept | InvocableR |
Invocable with argument types Args and a result convertible to R (std::is_invocable_r). | |
| concept | Predicate |
Predicate over argument types Args (std::predicate). | |
| concept | SameAs |
| Same type after stripping cv and references from both sides. | |
| concept | DerivedFrom |
Derived derives from Base (std::is_base_of). | |
| concept | MaybeSafe |
| Recognizes a conditional Safe component after stripping cv and references. | |
| concept | SafeComponent |
| Recognized Safe component after stripping cv and references. | |
| concept | SafeCursor |
| Recognizes a cursor that stores only a Base node pointer. | |
| concept | SafeValue |
| Value permitted in opaque Safe collections. | |
| concept | Optional |
| std::optional<U> or a Safe optional wrapper. | |
| concept | Queue |
| FIFO wrappers supported by generic queue operations. | |
| concept | Variant |
| Instantiation of std::variant, after stripping cv and references. | |
| concept | VariantHasType |
StormByte::Type::Variant T that lists U among its alternatives. | |
| concept | Pair |
| Type with accessible first and second members. | |
Typedefs | |
Aliases | |
| template<Range R> | |
| using | RangeValue = std::ranges::range_value_t<R> |
| Value type of a valid range. | |
| template<Range R> | |
| using | RangeReference = std::ranges::range_reference_t<R> |
| Reference type produced by a valid range. | |
| template<Range R> | |
| using | RangeDifference = std::ranges::range_difference_t<R> |
| Difference type associated with a valid range. | |
| template<typename I> | |
| using | IteratorValue = std::iter_value_t<I> |
| Value type associated with an iterator. | |
Helpers | |
| template<typename E> | |
| using | UnderlyingType = std::underlying_type_t<std::remove_cv_t<E>> |
Underlying integer type of enumeration E. | |
| template<typename E> requires Enum<E> | |
| constexpr UnderlyingType< E > | ToUnderlying (E e) noexcept |
| Converts an enumeration value to its underlying integer. | |
Named concepts and small type utilities used across the suite.
Concepts and traits used to constrain Safe components.