StormByte 3.0.0
C++26 foundation of the StormByte suite
Loading...
Searching...
No Matches
StormByte::Type Namespace Reference

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.

Detailed Description

Named concepts and small type utilities used across the suite.

Concepts and traits used to constrain Safe components.