Struct Buffered

pub struct Buffered<'a, T: ?Sized>(/* private fields */);

A pointer to objects stored in buffers.

Containers such as &mut [u8] or &mut Vec<u8> yield this pointer type. Note that, unlike most pointer types, it implements Unpin only if T is Unpin. While this may seem counterintuitive, it simplifies obtaining a pinned reference to T in safe Rust, as illustrated below:

fn async_hello() -> Fn!(=> dyn Future<Output = String>) {
    from_fn!(|| async { String::from("Hello!") })
}

let mut stack = MaybeUninit::<[u8; 16]>::uninit();
let fut: Buffered<dyn Future<Output = String>> = async_hello().init(&mut stack);
// Pin it on the stack just as it has the inner type `T = dyn Future`.
let fut: Pin<&mut Buffered<_>> = std::pin::pin!(fut);
// Then project it to obtain a pinned reference to `T`.
let fut: Pin<&mut dyn Future<Output = String>> = fut.project();
assert_eq!(fut.await, "Hello!");

Tips: Buffered<T: Future> implements Future, so you can simply write async_hello().init(&mut stack).await in practice.

Implementations

impl<'a, T: ?Sized> Buffered<'a, T>

pub unsafe fn from_raw(ptr: NonNull<T>) -> Self

Constructs a new instance with the provided pointer.

Safety

ptr must be a valid pointer to T and exclusive for the returned instance.

pub fn into_raw(self) -> NonNull<T>

Consumes this instance, returning a raw pointer.

pub fn project(self: Pin<&mut Self>) -> Pin<&mut T>

Returns a pinned mutable reference to the inner value.

pub fn project_ref(self: Pin<&Self>) -> Pin<&T>

Returns a pinned immutable reference to the inner value.

Trait Implementations

impl<T: ?Sized + Debug> Debug for Buffered<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ?Sized> Deref for Buffered<'_, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: ?Sized> DerefMut for Buffered<'_, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: ?Sized> Drop for Buffered<'_, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Future for Buffered<'_, T>

where T: ?Sized + Future,

type Output = <T as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<T: ?Sized + Unpin> Unpin for Buffered<'_, T>