Loading...
Searching...
No Matches
rstd.core Module Reference
Exported Modules | |
| module | rstd.basic |
Concepts | |
| concept | rstd::mtp::is_trait_api |
| Checks whether T is a valid trait API type with an associated Trait and type info. | |
| concept | rstd::mtp::is_direct_trait |
| Checks whether T is a direct trait (implemented directly on the type, not via Impl). | |
| concept | rstd::mtp::has_trait_api |
| Checks whether T has an Api member template defining trait methods. | |
| concept | rstd::Impled |
| Checks whether type A implements all the given traits T. | |
| concept | rstd::fmt::formattable |
| Checks whether a type can be formatted, i.e. | |
| concept | rstd::str_::ViewableStr |
Concept for types that can be viewed as a string slice (must expose data() and size()). | |
| concept | rstd::mtp::DST |
A dynamically-sized type whose pointer metadata is defined via Pointee. | |
| concept | rstd::mtp::DSTArray |
A dynamically-sized array type whose pointer metadata is a usize length. | |
Classes | |
| struct | rstd::convert::From< TF > |
Trait for constructing a type from another type, analogous to Rust's From. More... | |
| struct | rstd::convert::Into< TF > |
Trait for consuming self and producing a value of another type, analogous to Rust's Into. More... | |
| struct | rstd::convert::AsRef< T > |
| Trait for cheaply borrowing data as an immutable reference to T. More... | |
| struct | rstd::convert::AsMut< T > |
| Trait for cheaply borrowing data as a mutable reference to T. More... | |
| struct | rstd::time::Duration |
| A span of time, with nanosecond precision. More... | |
| struct | rstd::ptr_::dyn< A > |
A dynamically-typed wrapper enabling trait-object dispatch, analogous to Rust's dyn Trait. More... | |
| struct | rstd::ptr_::dyn_delegate< T > |
| Delegate that holds the vtable and data pointer for dynamic dispatch. More... | |
| struct | rstd::mtp::dyn_traits< T > |
Traits for extracting information from a dyn<T> type. More... | |
| struct | rstd::alloc::Layout |
| Describes the memory layout of a type: its size and alignment. More... | |
| struct | rstd::num::nonzero::NonZero< T > |
| A value that is known not to equal zero. More... | |
| struct | rstd::num::niche_types::NonZeroBase< T > |
| Base type for niche-optimized non-zero integer inner representations. More... | |
| struct | rstd::ptr_::non_null::NonNull< T > |
A non-null pointer type, analogous to Rust's NonNull<T>. More... | |
| struct | rstd::sync::atomic::Ordering |
| Named constants for atomic memory orderings. More... | |
| class | rstd::sync::atomic::Atomic< T > |
| A generic atomic type for lock-free concurrent access. More... | |
| struct | rstd::TraitFuncs< Api > |
| A compile-time collection of function pointers representing a trait's API. More... | |
| struct | rstd::Impl< T, A > |
| The trait implementation specialization point. More... | |
| struct | rstd::default_tag< T, P > |
| Tag type used to select a default trait implementation for type T. More... | |
| struct | rstd::ImplBase< A > |
| Base class for Impl specializations, providing a pointer-based self accessor. More... | |
| struct | rstd::LinkClassMethod< T, A > |
| Links a class's own methods as the trait implementation, delegating via in-class dispatch. More... | |
| struct | rstd::WithTrait< Self, Traits > |
| Mixin that inherits the API of all given Traits for type Self. More... | |
| struct | rstd::MayWithTrait< Self, Traits > |
| Conditionally mixes in trait APIs for Self, only including traits that Self implements. More... | |
| struct | rstd::WithTraitDefault< Self, Traits > |
| Mixin that inherits the default trait implementations for all given Traits using in-class policy. More... | |
| class | rstd::mem::manually_drop::ManuallyDrop< T > |
A wrapper that inhibits the automatic destructor call, analogous to Rust's ManuallyDrop<T>. More... | |
| struct | rstd::mem::drop_guard::DropGuard< T, F > |
| A scope guard that invokes a callable on the inner value when dropped. More... | |
| struct | rstd::fmt::FormattingOptions |
| Options that control how values are formatted (fill, align, width, precision, flags). More... | |
| struct | rstd::fmt::Display |
Trait for user-facing output formatting, invoked via {}. More... | |
| struct | rstd::fmt::Debug |
Trait for programmer-facing debug output, invoked via {:?} or pretty-printed via {:#?}. More... | |
| struct | rstd::fmt::Write |
| Trait for a byte-oriented output sink used by the formatting machinery. More... | |
| struct | rstd::fmt::Formatter |
| The core formatting engine that drives output through a type-erased Write sink. More... | |
| struct | rstd::fmt::Argument |
| A type-erased formatting argument that can dispatch to Display or Debug. More... | |
| struct | rstd::fmt::Arguments |
| A pre-compiled set of format arguments: a format string plus its type-erased Argument array. More... | |
| struct | rstd::fmt::FormatString< Args > |
| A compile-time validated format string that ensures argument count and brace matching. More... | |
| struct | rstd::str_::Str |
An unsized UTF-8 string type, analogous to Rust's str. More... | |
| struct | rstd::str_::Chars |
| A hand-rolled iterator over Unicode code points in a UTF-8 string slice. More... | |
| struct | rstd::ptr_::Pointee |
Trait for types whose pointers carry metadata, analogous to Rust's Pointee. More... | |
| struct | rstd::clone::Clone |
| Trait for types that can explicitly duplicate themselves. More... | |
| struct | rstd::cmp::PartialEq< Rhs > |
Trait for partial equality comparisons, analogous to Rust's PartialEq. More... | |
| struct | rstd::FnOnce< T > |
| Trait for callables that can be called once, consuming themselves. More... | |
| struct | rstd::FnMut< T > |
| Trait for callables that can be called by mutable reference. More... | |
| struct | rstd::Fn< T > |
| Trait for callables that can be called by const reference. More... | |
| struct | rstd::ptr< T > |
An immutable raw pointer, analogous to Rust's *const T. More... | |
| struct | rstd::mut_ptr< T > |
A mutable raw pointer, analogous to Rust's *mut T. More... | |
| struct | rstd::ref< T > |
An immutable reference wrapper, analogous to Rust's &T. More... | |
| struct | rstd::mut_ref< T > |
A mutable reference wrapper, analogous to Rust's &mut T. More... | |
| struct | rstd::ref_base< Self, T, Mutable > |
CRTP base for reference-like pointer types (ref, mut_ref). More... | |
| struct | rstd::ptr_base< Self, T, Mutable > |
CRTP base for raw pointer types (ptr, mut_ptr). More... | |
| struct | rstd::alloc::AllocError |
| The error type for fallible allocation operations. More... | |
| struct | rstd::alloc::Allocator |
| A high-level trait for an allocator. More... | |
| class | rstd::pin::Pin< Ptr > |
A pinned pointer that guarantees the pointee will not be moved, analogous to Rust's Pin<P>. More... | |
| struct | rstd::str_::FromStr |
| Trait for parsing a value from a string slice. More... | |
| class | rstd::option::Option< T > |
An optional value: either Some containing a value, or None. More... | |
| struct | rstd::option::Unknown |
A sentinel type representing an untyped None value, implicitly convertible to any Option<T>. More... | |
| struct | rstd::option::detail::option_store< T > |
Internal storage for Option<T>. More... | |
| class | rstd::result::Result< T, E > |
A type that represents either success (Ok) or failure (Err). More... | |
| struct | rstd::panic< Args > |
| Compile-time-checked panic with format string support. More... | |
| struct | rstd::Copy |
| Marker trait for types that can be duplicated by simple bitwise copy. More... | |
| struct | rstd::Send |
| Marker trait for types that can be safely transferred across thread boundaries. More... | |
| struct | rstd::Sync |
| Marker trait for types that can be safely shared between threads via references. More... | |
| struct | rstd::Sized |
| Marker trait for types with a constant size known at compile time. More... | |
| struct | rstd::value_type< V > |
| A type-level wrapper that carries a compile-time value as a type. More... | |
| struct | rstd::Choice< Enum, Data > |
| A tagged union that pairs an enum discriminant with associated data. More... | |
| struct | rstd::mem::maybe_uninit::maybe_uninit_traits< T > |
Traits for extracting the value type from a MaybeUninit specialization. More... | |
| class | rstd::mem::maybe_uninit::MaybeUninit< T > |
A wrapper type to construct uninitialized instances of T. More... | |
Enumerations | |
| enum class | memory_order : int |
| Atomic memory ordering constraints. | |
| enum class | Align : u32 |
| Text alignment options for formatted output. | |
Typedefs | |
| template<typename T , typename A , TraitDefaultPolicy P = TraitDefaultPolicy::Normal> | |
| using | rstd::LinkTraitDefault = Impl<T, default_tag<A, P>> |
| Alias for a trait's default implementation, which can be inherited by Impl or class A. | |
| template<typename... Args> | |
| using | rstd::fmt::format_string = FormatString<typename _FmtId<Args>::type...> |
| Convenience alias for FormatString with identity-mapped argument types. | |
| using | rstd::str = str_::Str |
| Type alias for the unsized string type. | |
| using | value_type = mtp::cond<Mutable, mtp::rm_ext<T>, mtp::add_const<mtp::rm_ext<T>>> |
| we only process T[] for value_type | |
| using | value_type = mtp::cond<Mutable, mtp::rm_ext<T>, mtp::add_const<mtp::rm_ext<T>>> |
| we only process T[] for value_type | |
| template<typename T > | |
| using | rstd::slice = ref<T[]> |
A borrowed reference to a contiguous sequence of T, analogous to Rust's &[T]. | |
Functions | |
| auto | rstd::memchr::memchr (u8 needle, slice< u8 > haystack) noexcept -> Option< usize > |
| Searches for the first occurrence of a byte in a slice. | |
| template<typename T , typename F > | |
| auto | rstd::convert::into (F &&val) -> T |
| Converts a value of type F into type T using the Into trait. | |
| template<typename T > | |
| auto | rstd::convert::into (T &&t) -> IntoWrapper< mtp::rm_ref< T > > |
| Returns an IntoWrapper that defers conversion, enabling implicit conversion via operator U(). | |
| template<typename T , typename F > | |
| auto | rstd::convert::as_ref (F &r) noexcept |
| Borrows r as an immutable reference to T via the AsRef trait. | |
| template<typename T , typename F > | |
| auto | rstd::convert::as_mut (F &r) noexcept |
| Borrows r as a mutable reference to T via the AsMut trait. | |
| void | rstd::hint::spin_loop () |
| Emits a hardware hint to the processor that the current thread is in a spin loop. | |
| template<typename T > | |
| constexpr int | rstd::num::countl_zero (T x) noexcept |
| Counts the number of consecutive zero bits, starting from the most significant bit. | |
| template<typename T > | |
| constexpr T | rstd::num::bit_ceil (T x) noexcept |
| Returns the smallest power of two greater than or equal to x. | |
| void | rstd::sync::atomic::fence (memory_order order) noexcept |
| Issues a thread-level memory fence with the given ordering. | |
| void | rstd::sync::atomic::compiler_fence (memory_order order) noexcept |
| Issues a compiler-only memory fence (no CPU instruction emitted). | |
| template<typename T , typename A , typename ToCheck > | |
| consteval bool | rstd::mtp::check_trait_apis () |
| Validates that ToCheck correctly implements all API methods for trait T with type A. | |
| template<typename T , typename A > | |
| consteval bool | rstd::mtp::check_trait () |
| Checks whether type A implements trait T, either directly or via Impl. | |
| template<usize I, typename TApi , typename... Args> requires mtp::is_trait_api<mtp::rm_cv<TApi>> | |
| constexpr decltype(auto) | rstd::trait_call (TApi *self, Args &&... args) |
| Dispatches a trait method call to the appropriate Impl, handling static, dynamic, and in-class dispatch. | |
| template<usize I, typename TApi , typename... Args> requires mtp::is_trait_api<mtp::rm_cv<TApi>> | |
| constexpr decltype(auto) | rstd::trait_static_call (Args &&... args) |
| Dispatches a static (non-member) trait method call to the appropriate Impl. | |
| template<typename T , typename A > | |
| constexpr decltype(auto) | rstd::as (A &t) noexcept |
| Casts an lvalue reference to a trait view, returning the Impl wrapper for trait T. | |
| static constexpr auto | make (T &&v) noexcept -> ManuallyDrop |
Creates a new ManuallyDrop wrapping the given value. | |
| constexpr auto | as_ptr () const -> T const * |
| Returns a const pointer to the contained value. | |
| constexpr auto | as_mut_ptr () -> T * |
| Returns a mutable pointer to the contained value. | |
| constexpr auto | take () -> T && |
| Extracts the contained value by move. | |
| template<typename T > | |
| constexpr auto | rstd::ptr_::null_mut () noexcept -> T * |
| Creates a null mutable raw pointer. | |
| template<typename T > | |
| auto | rstd::ptr_::without_provenance_mut (usize addr) noexcept -> T * |
| Creates a mutable pointer with the given address and no provenance. | |
| template<typename Dst , typename Src > | |
| constexpr auto | rstd::mem::transmute (Src src) noexcept -> Dst |
Reinterprets the bits of Src as type Dst, analogous to Rust's transmute. | |
| constexpr auto | rstd::mem::memcmp (const_voidp v1, const_voidp v2, usize len) noexcept -> bool |
Compares len bytes of memory at v1 and v2. | |
| auto | rstd::mem::memset (voidp src, u8 val, usize len) noexcept -> voidp |
Fills len bytes of memory at src with val. | |
| auto | rstd::mem::memcpy (voidp dst, const_voidp src, usize len) noexcept -> voidp |
Copies len bytes from src to dst; regions must not overlap. | |
| template<typename T > | |
| constexpr auto | rstd::mem::all (T const &src, u8 val) noexcept -> bool |
Checks whether all bytes of src are equal to val. | |
| template<mtp::triv_copy T> | |
| constexpr void | rstd::mem::fill (T &src, u8 val) noexcept |
| Fills all bytes of a trivially-copyable value with the given byte. | |
| template<typename T > | |
| constexpr auto | rstd::mem::zeroed () noexcept -> T |
Returns a zero-initialized value of type T. | |
| constexpr bool | rstd::operator== (ref< str > a, ref< str > b) noexcept |
| Compares two string slices for equality by value. | |
| constexpr auto | rstd::from_utf8_unchecked (slice< u8 > bytes) noexcept -> ref< str > |
| Creates a string slice from a byte slice without UTF-8 validation. | |
| constexpr auto | rstd::str_::is_empty (ref< str > s) noexcept -> bool |
Returns true if the string is empty (zero bytes). | |
| constexpr auto | rstd::str_::is_ascii (ref< str > s) noexcept -> bool |
Returns true if all bytes are ASCII. | |
| constexpr auto | rstd::str_::is_char_boundary (ref< str > s, usize pos) noexcept -> bool |
Returns true if pos is on a UTF-8 character boundary. | |
| constexpr auto | rstd::str_::as_bytes (ref< str > s) noexcept -> slice< u8 > |
| Returns the byte slice of the string. | |
| constexpr auto | rstd::str_::chars (ref< str > s) noexcept -> Chars |
Returns a Chars iterator over the string's Unicode code points. | |
| constexpr auto | rstd::str_::contains (ref< str > haystack, ref< str > needle) noexcept -> bool |
Returns true if needle is a substring of haystack. | |
| constexpr auto | rstd::str_::starts_with (ref< str > s, ref< str > prefix) noexcept -> bool |
Returns true if the string starts with prefix. | |
| constexpr auto | rstd::str_::ends_with (ref< str > s, ref< str > suffix) noexcept -> bool |
Returns true if the string ends with suffix. | |
| constexpr auto | rstd::str_::split_at (ref< str > s, usize mid) noexcept -> rstd::tuple< ref< str >, ref< str > > |
| Splits the string at the given byte position. | |
| constexpr auto | rstd::str_::trim (ref< str > s) noexcept -> ref< str > |
| Returns the string with leading and trailing ASCII whitespace removed. | |
| constexpr auto | rstd::str_::extract_last (ref< str > path, usize count) -> ref< str > |
Extracts the last count path components from a path string. | |
| template<typename T > | |
| constexpr auto | rstd::cmp::max (T v1, T v2) noexcept -> T |
| Returns the greater of two values. | |
| template<typename T > | |
| constexpr auto | rstd::cmp::min (T v1, T v2) noexcept -> T |
| Returns the lesser of two values. | |
| void | rstd::intrinsics::abort () noexcept |
| Immediately aborts the process via a trap instruction. | |
| template<class T > requires (mtp::is_int<T>) | |
| constexpr auto | rstd::intrinsics::add_with_overflow (T a, T b) noexcept -> rstd::tuple< T, bool > |
| Performs checked addition, returning the result and whether overflow occurred. | |
| constexpr auto | rstd::char_::is_ascii (char32_t c) noexcept -> bool |
Returns true if the code point is in the ASCII range (0x00–0x7F). | |
| constexpr auto | rstd::char_::len_utf8 (char32_t c) noexcept -> usize |
| Returns the number of bytes needed to encode this code point in UTF-8 (1–4). | |
| constexpr auto | rstd::char_::encode_utf8 (char32_t c, u8 *buf) noexcept -> usize |
| Encodes a Unicode code point into UTF-8. | |
| constexpr auto | rstd::char_::decode_utf8 (const u8 *ptr, usize len) noexcept -> rstd::tuple< char32_t, usize > |
| Decodes one UTF-8 code point from the start of a byte sequence. | |
| constexpr auto | rstd::char_::is_continuation (u8 b) noexcept -> bool |
Returns true if the byte is a UTF-8 continuation byte (10xxxxxx). | |
| constexpr auto | rstd::char_::is_char_boundary (const u8 *ptr, usize len, usize pos) noexcept -> bool |
Returns true if position pos is on a UTF-8 character boundary within the byte sequence [ptr, ptr+len). | |
| constexpr auto | rstd::char_::is_valid_utf8 (const u8 *ptr, usize len) noexcept -> bool |
| Validates that a byte sequence is well-formed UTF-8. | |
| static Pin | make (Ptr p) noexcept(mtp::noex_move< Ptr >||mtp::triv_copy< Ptr >) |
| Pins a pointer, asserting that the pointee satisfies pinning requirements. | |
| static constexpr Pin | make_unchecked (Ptr p) noexcept(mtp::noex_move< Ptr >||mtp::triv_copy< Ptr >) |
Constructs a Pin without verifying pinning guarantees (unsafe). | |
| static constexpr Ptr | into_inner_unchecked (Pin p) noexcept(mtp::noex_move< Ptr >) |
Unwraps the Pin, returning the inner pointer (unsafe). | |
| const Ptr & | get_ref () const noexcept |
| Returns an immutable reference to the inner pointer. | |
| Ptr & | get_mut () noexcept |
| Returns a mutable reference to the inner pointer. | |
| Ptr & | get_unchecked_mut () noexcept |
| Returns a mutable reference to the inner pointer without borrow checking (unsafe). | |
| template<typename T > | |
| auto | rstd::from_str (ref< str > str) |
| Parses a string slice into the specified type. | |
| constexpr auto | rstd::str_::from_utf8 (slice< u8 > bytes) noexcept -> Option< ref< str > > |
| Validates a byte slice as UTF-8 and returns a string slice on success. | |
| constexpr auto | rstd::str_::find (ref< str > haystack, ref< str > needle) noexcept -> Option< usize > |
Finds the byte offset of needle in haystack. | |
| template<typename U = void, typename T > | |
| constexpr auto | rstd::option::Some (T &&val) |
Creates an Option containing the given value. | |
| template<typename U = void, typename T = Unknown> | |
| constexpr auto | rstd::option::None (T &&={}) |
Creates an empty Option representing no value. | |
| constexpr auto | is_some () const noexcept -> bool |
Returns true if the option contains a value. | |
| constexpr auto | is_none () const noexcept -> bool |
Returns true if the option is None. | |
| template<typename F > | |
| auto | is_some_and (F &&f) -> bool |
Returns true if the option contains a value and the predicate returns true. | |
| constexpr auto | as_ref () const -> Option< mtp::add_ref< mtp::add_const< T > > > |
Converts from Option<T> to Option<const T&>. | |
| auto | expect (ref< str > msg) -> T |
| Returns the contained value, consuming the option. | |
| auto | unwrap () -> T |
| Returns the contained value, consuming the option. | |
| template<typename U > | |
| auto | unwrap_or (U &&default_value) -> T |
| Returns the contained value or the provided default. | |
| template<typename F > | |
| auto | unwrap_or_else (F &&f) -> T |
| Returns the contained value or computes it from the provided closure. | |
| constexpr auto | unwrap_unchecked () -> T |
| Returns the contained value without checking. | |
| template<typename F , typename U = mtp::invoke_result_t<F, T>> | |
| constexpr auto | map (F &&f) -> Option< U > |
Maps an Option<T> to Option<U> by applying a function to the contained value. | |
| template<typename F , typename U = mtp::invoke_result_t<F, T>> requires mtp::spec_of<U, Option> | |
| constexpr auto | and_then (F &&f) -> U |
Returns None if the option is None, otherwise calls f with the contained value and returns the result. | |
| constexpr auto | take () -> Option< T > |
Takes the value out of the option, leaving None in its place. | |
| constexpr auto & | operator* () const noexcept |
Dereferences the contained value. Asserts that the option is Some. | |
| constexpr auto & | operator* () noexcept |
Dereferences the contained value. Asserts that the option is Some. | |
| constexpr auto * | operator-> () const noexcept |
Accesses the contained value via pointer. Asserts that the option is Some. | |
| constexpr auto * | operator-> () noexcept |
Accesses the contained value via pointer. Asserts that the option is Some. | |
| constexpr | operator bool () const noexcept |
Returns true if the option is Some. | |
| template<typename T , typename TErr = UnknownErr> | |
| constexpr auto | rstd::result::Ok (T &&val) -> Result< T, TErr > |
Creates a Result in the Ok state containing the given value. | |
| template<typename TErr , typename T = UnknownOk> | |
| constexpr auto | rstd::result::Err (TErr &&val) -> Result< T, TErr > |
Creates a Result in the Err state containing the given error. | |
| void | rstd::panic_fmt (fmt::Arguments args, panic_::Location loc) |
| Triggers a panic with a formatted message and source location. | |
| void | rstd::panic_fmt_nounwind (fmt::Arguments args, panic_::Location loc) |
| Triggers a non-unwinding panic for noexcept or FFI contexts. | |
| ~MaybeUninit ()=default | |
| Destructor does nothing - it never calls T's destructor. | |
| static constexpr auto | make (T &&val) noexcept(mtp::noex_move< T >) -> MaybeUninit |
Creates a new MaybeUninit<T> initialized with the given value. | |
| static constexpr auto | uninit () noexcept -> MaybeUninit |
Creates a new MaybeUninit<T> in an uninitialized state. | |
| static constexpr auto | zeroed () noexcept -> MaybeUninit |
Creates a new MaybeUninit<T> in an uninitialized state, with the memory being filled with 0 bytes. | |
| constexpr auto | write (T &&val) noexcept(mtp::noex_move< T >) -> T & |
Sets the value of the MaybeUninit<T>. | |
| constexpr auto | as_ptr () const noexcept -> const T * |
| Gets a const pointer to the contained value. | |
| constexpr auto | as_mut_ptr () noexcept -> T * |
| Gets a mutable pointer to the contained value. | |
| constexpr auto | assume_init () &&noexcept -> T requires(mtp::move< T >) |
Extracts the value from the MaybeUninit<T> container by move. | |
| constexpr auto | assume_init_read () const noexcept -> T requires(mtp::copy< T >) |
Extracts the value from the MaybeUninit<T> container by copy. | |
| constexpr auto | assume_init_ref () const noexcept -> const T & |
| Gets a const reference to the contained value. | |
| constexpr auto | assume_init_mut () noexcept -> T & |
| Gets a mutable reference to the contained value. | |
| constexpr void | assume_init_drop () noexcept |
| Drops the contained value in place. | |
Generated by
1.12.0