Docs.rs
  • radix-rust-1.3.0
    • radix-rust 1.3.0
    • Docs.rs crate page
    • Links
    • Repository
    • crates.io
    • Source
    • Owners
    • radixbot
    • Dependencies
      • hashbrown ^0.13.2 normal optional
      • indexmap ^2.2.5 normal
      • serde ^1.0.144 normal optional
    • Versions
    • 39.55% of the crate is documented
  • Platform
    • i686-pc-windows-msvc
    • i686-unknown-linux-gnu
    • x86_64-apple-darwin
    • x86_64-pc-windows-msvc
    • x86_64-unknown-linux-gnu
  • Feature flags
  • docs.rs
    • About docs.rs
    • Privacy policy
  • Rust
    • Rust website
    • The Book
    • Standard Library API Reference
    • Rust by Example
    • The Cargo Guide
    • Clippy Documentation

Crate radix_rust

radix_rust1.3.0

  • All Items

Crate Items

  • Modules
  • Macros
  • Structs
  • Traits
  • Functions

Crates

  • radix_rust

Crate radix_rust

Source

Modules§

iterators
prelude
Each module should have its own prelude, which:
rust

Macros§

assert_matches
Attempts to be a replacement for assert!(matches!(...)) but with better error messages, and allowing further code on success.
btreemap
btreeset
hashmap
hashset
indexmap
indexset
labelled_resolvable_using_resolvable_impl
labelled_resolvable_with_identity_impl
resolvable_with_identity_impl
resolvable_with_try_into_impls

Structs§

ContextDisplayable

Traits§

ContextualDisplay
This trait is used where context is required to correctly display a value.
ContextualTryFrom
ContextualTryInto
LabelResolver
LabelledResolvable
LabelledResolvable is a marker trait, serving a few purposes:
LabelledResolve
This trait is intended to be used as an impl argument in helper methods, to accept a wider range of arguments.
LabelledResolveFrom
The inverse trait of LabelledResolve.
Resolvable
Resolvable is a marker trait, mainly to make resolution opt-in and to avoid polluting every type with a resolve method.
Resolve
This trait is intended to be used as an impl argument in helper methods, to accept a wider range of arguments.
ResolveFrom
The inverse trait of Resolve.

Functions§

combine
Combines a u8 with a u8 slice.
copy_u8_array
Copies a slice to a fixed-sized array.

Results

Settings
Help
    struct
    radix_rust::rust::prelude::Rc
    A single-threaded reference-counting pointer. ‘Rc’ …
    module
    radix_rust::rust::rc
    Single-threaded reference-counting pointers. ‘Rc’ …
    struct
    radix_rust::rust::slice::RChunks
    An iterator over a slice in (non-overlapping) chunks (…
    struct
    radix_rust::rust::slice::RChunksMut
    An iterator over a slice in (non-overlapping) mutable …
    struct
    radix_rust::rust::slice::RChunksExact
    An iterator over a slice in (non-overlapping) chunks (…
    struct
    radix_rust::rust::slice::RChunksExactMut
    An iterator over a slice in (non-overlapping) mutable …
    method
    radix_rust::rust::prelude::Rc::from
    Rc<str> -> Rc<[u8]>
    Converts a reference-counted string slice into a byte …
    method
    radix_rust::rust::prelude::Rc::into_raw
    Rc<T, A> ->
    Consumes the Rc, returning the wrapped pointer.
    method
    radix_rust::rust::prelude::Rc::as_raw_fd
    &Rc<T> -> i32
    method
    radix_rust::rust::prelude::Rc::as_fd
    &Rc<T> -> BorrowedFd
    method
    radix_rust::rust::prelude::Rc::as_ptr
    &Rc<T, A> ->
    Provides a raw pointer to the data.
    method
    radix_rust::rust::prelude::Rc::into_inner
    Rc<T, A> -> Option<T>
    Returns the inner value, if the Rc has exactly one strong …
    method
    radix_rust::rust::prelude::Rc::unwrap_or_clone
    Rc<T, A> -> T
    If we have the only reference to T then unwrap it. …
    method
    radix_rust::rust::prelude::Rc::into_array
    Rc<[T]> -> Option<Rc<[T]>>
    Converts the reference-counted slice into a …
    method
    radix_rust::rust::prelude::Rc::weak_count
    &Rc<T, A> -> usize
    Gets the number of Weak pointers to this allocation.
    method
    radix_rust::rust::prelude::Rc::strong_count
    &Rc<T, A> -> usize
    Gets the number of strong (Rc) pointers to this allocation.
    method
    radix_rust::rust::prelude::Rc::into_raw_with_allocator
    Rc<T, A> -> (A)
    Consumes the Rc, returning the wrapped pointer and …
    method
    radix_rust::rust::prelude::Rc::drop
    &mut Rc<T, A> -> ()
    Drops the Rc.
    method
    radix_rust::rust::prelude::Rc::deref
    &Rc<T, A> -> &T
    method
    radix_rust::rust::prelude::Rc::as_ref
    &Rc<T, A> -> &T
    method
    radix_rust::rust::prelude::Rc::borrow
    &Rc<T, A> -> &T
    method
    radix_rust::rust::prelude::Rc::allocator
    &Rc<T, A> -> &A
    Returns a reference to the underlying allocator.
    method
    radix_rust::rust::prelude::Rc::assume_init
    Rc<MaybeUninit<T>, A> -> Rc<T, A>
    Converts to Rc<T>.
    method
    radix_rust::rust::prelude::Rc::downcast_unchecked
    Rc<Any, A> -> Rc<T, A>
    Downcasts the Rc<dyn Any> to a concrete type.
    method
    radix_rust::rust::prelude::Rc::try_unwrap
    Rc<T, A> -> Result<T, Rc<T, A>>
    Returns the inner value, if the Rc has exactly one strong …
    method
    radix_rust::rust::prelude::Rc::clone
    &Rc<T, A> -> Rc<T, A>
    Makes a clone of the Rc pointer.
    method
    radix_rust::rust::prelude::Rc::try_from
    Rc<[T], A> -> Result<Rc<[T], A>>
    method
    radix_rust::rust::prelude::Rc::downgrade
    &Rc<T, A> -> Weak<T, A>
    Creates a new Weak pointer to this allocation.
    method
    radix_rust::rust::prelude::Rc::get_mut_unchecked
    &mut Rc<T, A> -> &mut T
    Returns a mutable reference into the given Rc, without any …
    method
    radix_rust::rust::prelude::Rc::ptr_eq
    &Rc<T, A>, &Rc<T, A> -> bool
    Returns true if the two Rcs point to the same allocation …
    method
    radix_rust::rust::prelude::Rc::get_mut
    &mut Rc<T, A> -> Option<&mut T>
    Returns a mutable reference into the given Rc, if there are
    method
    radix_rust::rust::prelude::Rc::eq
    &Rc<T, A>, &Rc<T, A> -> bool
    Equality for two Rcs.
    method
    radix_rust::rust::prelude::Rc::ge
    &Rc<T, A>, &Rc<T, A> -> bool
    ‘Greater than or equal to’ comparison for two Rcs.
    method
    radix_rust::rust::prelude::Rc::gt
    &Rc<T, A>, &Rc<T, A> -> bool
    Greater-than comparison for two Rcs.
    method
    radix_rust::rust::prelude::Rc::le
    &Rc<T, A>, &Rc<T, A> -> bool
    ‘Less than or equal to’ comparison for two Rcs.
    method
    radix_rust::rust::prelude::Rc::lt
    &Rc<T, A>, &Rc<T, A> -> bool
    Less-than comparison for two Rcs.
    method
    radix_rust::rust::prelude::Rc::ne
    &Rc<T, A>, &Rc<T, A> -> bool
    Inequality for two Rcs.
    method
    radix_rust::rust::prelude::Rc::cmp
    &Rc<T, A>, &Rc<T, A> -> Ordering
    Comparison for two Rcs.
    method
    radix_rust::rust::prelude::Rc::fmt
    &Rc<T, A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::Rc::hash
    &Rc<T, A>, &mut H -> ()
    method
    radix_rust::rust::prelude::Rc::downcast
    Rc<Any, A> -> Result<Rc<T, A>, Rc<Any, A>>
    Attempts to downcast the Rc<dyn Any> to a concrete type.
    method
    radix_rust::rust::prelude::Rc::make_mut
    &mut Rc<T, A> -> &mut T
    Makes a mutable reference into the given Rc.
    method
    radix_rust::rust::prelude::Rc::partial_cmp
    &Rc<T, A>, &Rc<T, A> -> Option<Ordering>
    Partial comparison for two Rcs.
    method
    radix_rust::rust::prelude::Rc::default
    -> Rc<str>
    Creates an empty str inside an Rc
    method
    radix_rust::rust::prelude::Rc::new
    T -> Rc<T>
    Constructs a new Rc<T>.
    method
    radix_rust::rust::prelude::Rc::from
    String -> Rc<str>
    Allocates a reference-counted string slice and copies v …
    method
    radix_rust::rust::prelude::Rc::from_raw
    -> Rc<T>
    Constructs an Rc<T> from a raw pointer.
    method
    radix_rust::rust::prelude::Rc::new_uninit
    -> Rc<MaybeUninit<T>>
    Constructs a new Rc with uninitialized contents.
    method
    radix_rust::rust::prelude::Rc::new_zeroed
    -> Rc<MaybeUninit<T>>
    Constructs a new Rc with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::Rc::try_new
    T -> Result<Rc<T>, AllocError>
    Constructs a new Rc<T>, returning an error if the …
    method
    radix_rust::rust::prelude::Rc::try_new_uninit
    -> Result<Rc<MaybeUninit<T>>, AllocError>
    Constructs a new Rc with uninitialized contents, returning …
    method
    radix_rust::rust::prelude::Rc::try_new_zeroed
    -> Result<Rc<MaybeUninit<T>>, AllocError>
    Constructs a new Rc with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::Rc::new_uninit_slice
    usize -> Rc<[MaybeUninit<T>]>
    Constructs a new reference-counted slice with …
    method
    radix_rust::rust::prelude::Rc::new_zeroed_slice
    usize -> Rc<[MaybeUninit<T>]>
    Constructs a new reference-counted slice with …
    method
    radix_rust::rust::prelude::Rc::new_in
    T, A -> Rc<T, A>
    Constructs a new Rc in the provided allocator.
    method
    radix_rust::rust::prelude::Rc::from_raw_in
    A -> Rc<T, A>
    Constructs an Rc<T, A> from a raw pointer in the provided …
    method
    radix_rust::rust::prelude::Rc::new_uninit_in
    A -> Rc<MaybeUninit<T>, A>
    Constructs a new Rc with uninitialized contents in the …
    method
    radix_rust::rust::prelude::Rc::new_zeroed_in
    A -> Rc<MaybeUninit<T>, A>
    Constructs a new Rc with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::Rc::from_iter
    I -> Rc<[T]>
    Takes each element in the Iterator and collects it into an …
    method
    radix_rust::rust::rc::UniqueRc::into_rc
    UniqueRc<T, A> -> Rc<T, A>
    Converts the UniqueRc into a regular Rc.
    method
    radix_rust::rust::prelude::Rc::try_new_in
    T, A -> Result<Rc<T, A>, AllocError>
    Constructs a new Rc<T> in the provided allocator, …
    method
    radix_rust::rust::prelude::Rc::try_new_uninit_in
    A -> Result<Rc<MaybeUninit<T>, A>, AllocError>
    Constructs a new Rc with uninitialized contents, in the …
    method
    radix_rust::rust::prelude::Rc::try_new_zeroed_in
    A -> Result<Rc<MaybeUninit<T>, A>, AllocError>
    Constructs a new Rc with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::Rc::new_uninit_slice_in
    usize, A -> Rc<[MaybeUninit<T>], A>
    Constructs a new reference-counted slice with …
    method
    radix_rust::rust::prelude::Rc::new_zeroed_slice_in
    usize, A -> Rc<[MaybeUninit<T>], A>
    Constructs a new reference-counted slice with …
    method
    radix_rust::rust::prelude::Rc::new_cyclic
    F -> Rc<T>
    Constructs a new Rc<T> while giving you a Weak<T> to the …
    method
    radix_rust::rust::rc::Weak::upgrade
    &Weak<T, A> -> Option<Rc<T, A>>
    Attempts to upgrade the Weak pointer to an Rc, delaying …
    method
    radix_rust::rust::prelude::Rc::new_cyclic_in
    F, A -> Rc<T, A>
    Constructs a new Rc<T, A> in the given allocator while …
    method
    radix_rust::rust::prelude::Rc::into_array
    Rc<[T]> -> Option<Rc<[T]>>
    Converts the reference-counted slice into a …
    method
    radix_rust::rust::prelude::Rc::assume_init
    Rc<MaybeUninit<T>, A> -> Rc<T, A>
    Converts to Rc<T>.
    method
    radix_rust::rust::prelude::Rc::downcast_unchecked
    Rc<Any, A> -> Rc<T, A>
    Downcasts the Rc<dyn Any> to a concrete type.
    method
    radix_rust::rust::prelude::Rc::try_unwrap
    Rc<T, A> -> Result<T, Rc<T, A>>
    Returns the inner value, if the Rc has exactly one strong …
    method
    radix_rust::rust::prelude::Rc::clone
    &Rc<T, A> -> Rc<T, A>
    Makes a clone of the Rc pointer.
    method
    radix_rust::rust::prelude::Rc::try_from
    Rc<[T], A> -> Result<Rc<[T], A>>
    method
    radix_rust::rust::prelude::Rc::downcast
    Rc<Any, A> -> Result<Rc<T, A>, Rc<Any, A>>
    Attempts to downcast the Rc<dyn Any> to a concrete type.