Struct mfio::backend::BackendHandle

pub struct BackendHandle<'a, B: ?Sized> { /* private fields */ }

Handle to a backend.

This handle can be used to drive arbitrary future to completion by attaching a backend to it. This is typically done using WithBackend that is constructed in IoBackendExt::with_backend.

Usually, the user would want to bypass this type and use IoBackendExt::block_on, or an Integration equivalent.

Methods from Deref<Target = Pin<&'a mut B>>

pub fn as_ref(&self) -> Pin<&<P as Deref>::Target>

Gets a pinned shared reference from this pinned pointer.

This is a generic method to go from &Pin<Pointer<T>> to Pin<&T>. It is safe because, as part of the contract of Pin::new_unchecked, the pointee cannot move after Pin<Pointer<T>> got created. “Malicious” implementations of Pointer::Deref are likewise ruled out by the contract of Pin::new_unchecked.

pub fn as_mut(&mut self) -> Pin<&mut <P as Deref>::Target>

Gets a pinned mutable reference from this pinned pointer.

This is a generic method to go from &mut Pin<Pointer<T>> to Pin<&mut T>. It is safe because, as part of the contract of Pin::new_unchecked, the pointee cannot move after Pin<Pointer<T>> got created. “Malicious” implementations of Pointer::DerefMut are likewise ruled out by the contract of Pin::new_unchecked.

This method is useful when doing multiple calls to functions that consume the pinned type.

Example

use std::pin::Pin;

impl Type {
    fn method(self: Pin<&mut Self>) {
        // do something
    }

    fn call_method_twice(mut self: Pin<&mut Self>) {
        // `method` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.
        self.as_mut().method();
        self.as_mut().method();
    }
}

pub fn set(&mut self, value: <P as Deref>::Target)

where <P as Deref>::Target: Sized,

Assigns a new value to the memory behind the pinned reference.

This overwrites pinned data, but that is okay: its destructor gets run before being overwritten, so no pinning guarantee is violated.

Example

use std::pin::Pin;

let mut val: u8 = 5;
let mut pinned: Pin<&mut u8> = Pin::new(&mut val);
println!("{}", pinned); // 5
pinned.as_mut().set(10);
println!("{}", pinned); // 10

Trait Implementations

impl<'a, B: ?Sized> Deref for BackendHandle<'a, B>

type Target = Pin<&'a mut B>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, B: ?Sized> DerefMut for BackendHandle<'a, B>

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

Mutably dereferences the value.

impl<'a, B: ?Sized> Drop for BackendHandle<'a, B>

fn drop(&mut self)

Executes the destructor for this type.