| Nstd | STL namespace |
| Cnumeric_limits< StormByte::ByteSize > | Limits of StormByte::ByteSize |
| Chash< StormByte::ByteSize > | |
| Cis_error_code_enum< StormByte::Error::Code > | Marks StormByte::Error::Code as an std::error_code enum |
| Chash< StormByte::Safe::Binary > | Hash of the byte sequence |
| Chash< StormByte::Safe::Optional< T > > | Hash of a StormByte::Safe::Optional for an STL unordered container in this module |
| Ctuple_size< StormByte::Safe::Pair< First, Second > > | Tuple arity of a Safe pair |
| Ctuple_size< StormByte::Safe::PairReference< First, Second, SecondReference > > | Tuple arity of a Safe pair-reference proxy |
| Ctuple_element< Index, StormByte::Safe::Pair< First, Second > > | Tuple element type of a Safe pair |
| Ctuple_element< Index, StormByte::Safe::PairReference< First, Second, SecondReference > > | Tuple element type of a Safe pair-reference proxy |
| Chash< StormByte::Safe::Pair< First, Second > > | Hash of a StormByte::Safe::Pair for an STL unordered container in this module |
| Chash< StormByte::Safe::Shared< T > > | |
| Chash< StormByte::Safe::Unique< T > > | |
| Chash< StormByte::Safe::Weak< T > > | |
| Cformatter< StormByte::Safe::String, char > | Formats owned UTF-8 text with standard string format specifications |
| Chash< StormByte::Safe::String > | |
| Chash< StormByte::Safe::Variant< Ts... > > | |
| Chash< StormByte::Safe::Monostate > | |
| Cformatter< StormByte::Safe::WString, wchar_t > | Formats owned wide text with standard string format specifications |
| Chash< StormByte::Safe::WString > | |
| Cnumeric_limits< StormByte::Size > | Limits of StormByte::Size |
| Chash< StormByte::Size > | |
| NStormByte | Root namespace of the StormByte suite |
| NError | Error-code domains and the StormByte::Error::Fault value type |
| CDomain | Description of one error-code enum |
| CCategory | std::error_category backed by StormByte::Error::Domain |
| CDomain< Code > | Domain for StormByte::Error::Code |
| CFault | Held error: an std::error_code and a StormByte::Safe::String message |
| NSafe | Owned values that cross a DLL without the caller's CRT |
| NDetail | Private helpers |
| COwner | Opaque unique state and creator-module lifetime callbacks |
| CControl | Base-owned reference counts and the real destructor |
| CIsVoidFunction | Whether T is a void-returning Function |
| CIsVoidFunction< Function< void(Args...)> > | A void-returning Function |
| CThreadState | Decayed callable and arguments, allocated on Base's heap |
| CFunctionState | Function and its arguments, allocated on Base's heap |
| NHeap | Allocate and free raw blocks on Base's heap |
| CObjectDeleter | Destroy the concrete object and return its block to Free |
| CHash< StormByte::ByteSize > | |
| CAtomic | Atomic word of one, two, four or eight bytes |
| CBinary | Owned contiguous sequence of std::byte, stored in a Vector |
| CHash< StormByte::Safe::Binary > | Cross-module hash of the byte sequence |
| CCallback | Callback with explicitly cloned context and creator-module release |
| CClonable | Polymorphic copy and move through a base |
| CConditionVariable | Wakes threads waiting on a Mutex |
| CConditionVariableAny | Wakes a thread that waits with any lock it can drop and retake |
| CDeque | Double-ended sequence stored on Base's heap |
| CException | Base exception for Safe |
| CAllocationError | Memory allocation failed under Safe |
| CExpiredWeakPointerError | A shared owner cannot be obtained from an empty or expired observer |
| COutOfBoundsError | An index or range is out of bounds |
| CBadOptionalAccess | An empty Optional was dereferenced |
| CBadVariantAccess | A variant was read with the wrong alternative, or while valueless |
| CExclusiveLock | Owns at most one exclusive hold of a SharedMutex |
| CFunction | Copyable, creator-context callback with a typed signature |
| CFunction< void(Args...)> | Typed callback specialization for void-returning signatures |
| CFunction< Return(Args...)> | Typed callback specialization for value-returning signatures |
| CHash | Cross-module hash |
| CHash< T > | Hash of an integral or enumeration value |
| CHash< T * > | Hash of a pointer identity |
| CIterable | Gives a Safe component the iterators of its category |
| CBasicIterator | Suite cursor |
| CList | Doubly linked list stored on Base's heap |
| CBasicIterator | Bidirectional cursor over Base-owned list nodes |
| Cnode_type | Owning handle to one extracted Base node |
| CMap | Ordered unique-key map stored on Base's heap |
| Cvalue_compare | Orders entries by key, using the map comparator |
| CBasicIterator | Bidirectional cursor over Base-owned map nodes |
| Cnode_type | Owning handle to one extracted Base node |
| Cinsert_return_type | Result of inserting an extracted node |
| CDeferLock | Do not lock the mutex in the UniqueLock constructor |
| CTryToLock | Try to lock the mutex in the UniqueLock constructor |
| CAdoptLock | The calling thread already owns the mutex |
| CMutex | Non-recursive mutex |
| COptional | std::optional stored on Base's heap |
| CHash< StormByte::Safe::Optional< T > > | Cross-module hash of a StormByte::Safe::Optional |
| CPair | std::pair whose members keep their own Safe storage |
| CPairReference | Tuple-like proxy for an immutable first value and callback-backed second value |
| CHash< StormByte::Safe::Pair< First, Second > > | Cross-module hash of a StormByte::Safe::Pair |
| CShared | Forward declaration of shared ownership |
| CUnique | Forward declaration of unique ownership |
| CWeak | Forward declaration of weak ownership |
| CAtomicShared | Atomic publication of a Shared |
| CEnableSharedFromThis | Base that can recover a Shared from an object owned by one |
| CHash< StormByte::Safe::Shared< T > > | |
| CHash< StormByte::Safe::Unique< T > > | |
| CHash< StormByte::Safe::Weak< T > > | |
| CQueue | FIFO sequence stored on Base's heap |
| CReplaceTokenSpec | One ReplaceToken field |
| CReplaceTokenPlace | Where a field sits in the pattern, and how to render its argument |
| CSecureBinary | Binary for secrets: every byte it drops or releases is zeroed first |
| CSet | Ordered unique values stored on Base's heap |
| Citerator | Bidirectional cursor |
| Cconst_iterator | Read-only bidirectional cursor |
| Cnode_type | Owning handle to one extracted Base node |
| Cinsert_return_type | Result of inserting an extracted node |
| CSharedLock | Owns at most one shared hold of a SharedMutex |
| CSharedMutex | Non-recursive shared mutex |
| CString | Owned UTF-8 text |
| CHash< StormByte::Safe::String > | |
| CThread | Execution owned by Base |
| CId | Identifier of an execution |
| CUniqueLock | Owns at most one Mutex |
| CUnorderedMap | Unique-key hash map stored on Base's heap |
| CBasicIterator | Forward cursor over Base-owned hash nodes |
| Cnode_type | Owning handle to one extracted Base node |
| Cinsert_return_type | Result of inserting an extracted node |
| CUnorderedSet | Unique values stored in a Base-heap hash table |
| Citerator | Forward cursor |
| Cconst_iterator | Read-only forward cursor |
| Cnode_type | Owning handle to one extracted Base node |
| Cinsert_return_type | Result of inserting an extracted node |
| CMonostate | Empty alternative |
| CVariant | std::variant stored on Base's heap |
| CHash< StormByte::Safe::Variant< Ts... > > | |
| CHash< StormByte::Safe::Monostate > | |
| CVector | Contiguous sequence stored on Base's heap |
| CWString | Wide counterpart of String |
| CHash< StormByte::Safe::WString > | |
| CHash< StormByte::Size > | |
| NType | Named concepts and small type utilities used across the suite |
| NDetail | Private helpers for Safe classification |
| CIsKnownNeverSafe | Identifies standard-library ownership and view wrappers that Base will not admit |
| CIsKnownNeverSafe< T * > | |
| CIsKnownNeverSafe< T[]> | |
| CIsKnownNeverSafe< T[N]> | |
| CIsKnownNeverSafe< std::basic_string< T, Traits, Allocator > > | |
| CIsKnownNeverSafe< std::basic_string_view< T, Traits > > | |
| CIsKnownNeverSafe< std::array< T, N > > | |
| CIsKnownNeverSafe< std::vector< T, Allocator > > | |
| CIsKnownNeverSafe< std::deque< T, Allocator > > | |
| CIsKnownNeverSafe< std::list< T, Allocator > > | |
| CIsKnownNeverSafe< std::forward_list< T, Allocator > > | |
| CIsKnownNeverSafe< std::map< K, V, Compare, Allocator > > | |
| CIsKnownNeverSafe< std::multimap< K, V, Compare, Allocator > > | |
| CIsKnownNeverSafe< std::set< K, Compare, Allocator > > | |
| CIsKnownNeverSafe< std::multiset< K, Compare, Allocator > > | |
| CIsKnownNeverSafe< std::unordered_map< K, V, Hash, Equal, Allocator > > | |
| CIsKnownNeverSafe< std::unordered_multimap< K, V, Hash, Equal, Allocator > > | |
| CIsKnownNeverSafe< std::unordered_set< K, Hash, Equal, Allocator > > | |
| CIsKnownNeverSafe< std::unordered_multiset< K, Hash, Equal, Allocator > > | |
| CIsKnownNeverSafe< std::queue< T, Container > > | |
| CIsKnownNeverSafe< std::priority_queue< T, Container, Compare > > | |
| CIsKnownNeverSafe< std::stack< T, Container > > | |
| CIsKnownNeverSafe< std::initializer_list< T > > | |
| CIsKnownNeverSafe< std::optional< T > > | |
| CIsKnownNeverSafe< std::variant< T... > > | |
| CIsKnownNeverSafe< std::tuple< T... > > | |
| CIsKnownNeverSafe< std::pair< A, B > > | |
| CIsKnownNeverSafe< std::span< T, Extent > > | |
| CIsKnownNeverSafe< std::reference_wrapper< T > > | |
| CIsKnownNeverSafe< std::function< Signature > > | |
| CIsKnownNeverSafe< std::shared_ptr< T > > | |
| CIsKnownNeverSafe< std::unique_ptr< T, Deleter > > | |
| CIsKnownNeverSafe< std::weak_ptr< T > > | |
| Cis_std_queue | Primary classification for standard FIFO wrappers |
| Cis_std_queue< std::queue< Value, Container > > | Specialization for std::queue with any underlying container |
| CIsMaybeSafe< Safe::Callback > | Recognizes explicit callback ownership, not a copyable collection value |
| CIsSafe< Safe::Clonable< T, SmartPointer > > | Recognizes Safe polymorphic clone interfaces, without certifying derived implementations |
| CIsMaybeSafe< Safe::Clonable< T, SmartPointer > > | Propagates conditional pointee or owner safety to Clonable |
| CIsMaybeSafe< Safe::Function< void(Args...)> > | Classifies provider-implemented typed callbacks as conditional |
| CIsMaybeSafe< Safe::Function< Return(Args...)> > | Classifies provider-implemented value-returning callbacks as conditional |
| CIsSafe< Safe::Iterable< Component > > | Recognizes an iterable facade of an already safe component |
| CIsMaybeSafe< Safe::Iterable< Component > > | Propagates conditional safety from the wrapped component |
| CIsSafeValue< Safe::Iterable< Component > > | Admits an iterable facade as a collection value |
| CIsSafe< Safe::List< T > > | A list of a Safe value is Safe |
| CIsMaybeSafe< Safe::List< T > > | Propagates conditional safety from the element |
| CIsSafeValue< Safe::List< T > > | Admits a Safe list as a collection value |
| CIsSafe< Safe::Map< K, V, Compare > > | Recognizes a map of already safe entries |
| CIsMaybeSafe< Safe::Map< K, V, Compare > > | Propagates conditional safety from a map entry |
| CIsSafeValue< Safe::Map< K, V, Compare > > | Admits a Safe map as a collection value |
| CIsSafe< Safe::Optional< T > > | Recognizes an optional of an already safe component |
| CIsMaybeSafe< Safe::Optional< T > > | Propagates conditional safety from the contained value |
| CIsSafeOptional< Safe::Optional< T > > | Registers a Safe optional for optional-aware generic APIs |
| CIsSafeValue< Safe::Optional< T > > | Admits a Safe optional as a collection value |
| CIsMaybeSafe< Safe::Owner > | Recognizes opaque owner state whose safety depends on its callbacks |
| CIsSafe< Safe::Pair< First, Second > > | Recognizes a pair of already safe values |
| CIsMaybeSafe< Safe::Pair< First, Second > > | Propagates conditional safety when either member is conditionally safe |
| CIsSafeValue< Safe::Pair< First, Second > > | Admits a pair of safe values as a collection value |
| CIsSafe< Safe::Queue< T > > | Recognizes a queue of already safe values |
| CIsMaybeSafe< Safe::Queue< T > > | Propagates conditional safety from the element type |
| CIsSafeValue< Safe::Queue< T > > | Admits a Safe queue as a collection value |
| CIsSafeQueue< Safe::Queue< T > > | Registers a Safe queue for generic queue operations |
| CIsSafe< Safe::UnorderedMap< K, V, Hash, KeyEqual > > | A map of Safe entries is Safe |
| CIsMaybeSafe< Safe::UnorderedMap< K, V, Hash, KeyEqual > > | Propagates conditional safety from a map entry |
| CIsSafeValue< Safe::UnorderedMap< K, V, Hash, KeyEqual > > | Admits a Safe unordered map as a collection value |
| CIsSafe< StormByte::Safe::Monostate > | |
| CIsSafeValue< StormByte::Safe::Monostate > | |
| CIsSafe< StormByte::Safe::Variant< Ts... > > | |
| CIsSafeValue< StormByte::Safe::Variant< Ts... > > | |
| CIsSafe< Safe::Vector< T > > | Recognizes a vector of already safe values |
| CIsMaybeSafe< Safe::Vector< T > > | Propagates conditional safety from the element type |
| CIsSafeValue< Safe::Vector< T > > | Admits a Safe vector as a collection value |
| CIsSafe< Clock::Values > | Coherent clock snapshots contain only fixed-width numeric duration values |
| CIsMaybeSafe< Clock::Sample > | Clock samples carry provider-managed shared state and require compatible STL ABI |
| CIsSafe | Recognizes Base Safe components, not universal ABI compatibility |
| CIsSafe< T > | Arithmetic values cross a DLL boundary by value |
| CIsSafe< StormByte::Exception > | Recognizes Base's exception root, whose destructor and message storage are DLL-safe |
| CIsSafe< Safe::Binary > | Recognizes Base-owned binary storage |
| CIsSafe< Safe::SecureBinary > | Recognizes Base-owned binary storage that zeroes what it drops |
| CIsSafe< Safe::String > | Recognizes Base-owned UTF-8 text |
| CIsSafe< Safe::WString > | Recognizes Base-owned wide text |
| CIsSafe< Size > | Recognizes Base's fixed-width count |
| CIsSafe< ByteSize > | Recognizes Base's fixed-width byte count |
| CIsSafe< Safe::Shared< T > > | Recognizes shared ownership only when its pointee is IsSafe |
| CIsSafe< Safe::Unique< T > > | Recognizes unique ownership only when its pointee is IsSafe |
| CIsSafe< Safe::Weak< T > > | Recognizes weak ownership only when its pointee is IsSafe |
| CIsMaybeSafe | Recognizes types whose DLL-boundary safety depends on documented provider requirements |
| CIsMaybeSafe< T > | Recognizes complete derivatives of StormByte::Exception as conditionally DLL-safe |
| CIsMaybeSafe< Safe::Shared< T > > | Shared ownership inherits the pointee's conditional classification |
| CIsMaybeSafe< Safe::Unique< T > > | Unique ownership inherits the pointee's conditional classification |
| CIsMaybeSafe< Safe::Weak< T > > | Weak ownership inherits the pointee's conditional classification |
| CIsMaybeSafe< std::expected< T, E > > | Standard expected is conditionally Safe when its alternatives are Safe components |
| CIsSafeOptional | Identifies Safe optional wrappers |
| CIsSafeQueue | Identifies Safe FIFO wrappers |
| CIsSafeValue | Recognizes collection values with Base-controlled lifetime |
| CIsSafeValue< Safe::Binary > | Admits Base-owned binary storage |
| CIsSafeValue< Safe::SecureBinary > | Admits Base-owned binary storage that zeroes what it drops |
| CIsSafeValue< Safe::String > | Admits Base-owned UTF-8 text |
| CIsSafeValue< Safe::WString > | Admits Base-owned wide text |
| CIsSafeValue< Size > | Admits Base's fixed-width count |
| CIsSafeValue< ByteSize > | Admits Base's fixed-width byte count |
| CIsSafeValue< Safe::Shared< T > > | Admits copyable Base-heap shared ownership as a collection value |
| CIsSafeValue< T > | Admits enumeration values, which cross module boundaries by value |
| NDetail | Private specialization point for non-trivial types |
| CCodec | Size / write / read for one type T |
| CCodec< std::string > | StormByte::Detail::Codec specialization for std::string |
| CCodec< std::wstring > | StormByte::Detail::Codec specialization for std::wstring |
| CCodec< std::u16string > | StormByte::Detail::Codec specialization for std::u16string |
| CCodec< std::u32string > | StormByte::Detail::Codec specialization for std::u32string |
| CCodec< Safe::String > | StormByte::Detail::Codec specialization for StormByte::Safe::String |
| CCodec< Safe::WString > | StormByte::Detail::Codec specialization for StormByte::Safe::WString |
| CBitmask | CRTP wrapper that stores an unsigned enum as a flag set |
| CByteSize | Count of octets (uint64_t storage) |
| CUnit | One-octet scale used by the named factories |
| CException | Base exception type for the suite |
| CPath | Segments under StormByte, already joined with a dot |
| CDeserializeError | Deserialization failed |
| COperationError | An operation failed with an exception outside the StormByte hierarchy |
| CBase64Error | Base64 encode or decode failed |
| CSerializable | Encodes and decodes one value of type T |
| CSize | Count of abstract units (uint64_t storage) |
| CClock | Thread-safe aggregate of independently timed operation samples |
| CValues | Coherent snapshot of completed measurements |
| CSample | One independently timed interval contributing to a shared Clock |
| CTelemetry | Abstract session telemetry base with a protected clock drawer |
| CThreadLock | Mutex with owner-thread reentry |