Struct VibeioIo 

pub struct VibeioIo<T> { /* private fields */ }

A wrapper type that adapts I/O types for use with hyper and tokio.

VibeioIo<T> wraps any type T that implements tokio::io::AsyncRead and tokio::io::AsyncWrite and provides implementations for:

• hyper::rt::Read and hyper::rt::Write
• tokio::io::AsyncRead and tokio::io::AsyncWrite

This allows seamless interoperability between hyper’s I/O traits and tokio’s async I/O traits when using the vibeio runtime.

Implementations

impl<T> VibeioIo<T>

pub fn new(inner: T) -> Self

Creates a new VibeioIo wrapper around the given I/O type.

Methods from Deref<Target = Pin<Box<T>>>

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

where Ptr: Deref,

Gets a shared reference to the pinned value this Pin points to.

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 <Ptr as Deref>::Target>

where Ptr: DerefMut,

Gets a mutable reference to the pinned value this Pin<Ptr> points to.

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 pinning pointer.

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 as_deref_mut( self: Pin<&mut Pin<Ptr>>, ) -> Pin<&mut <Ptr as Deref>::Target>

where Ptr: DerefMut,

Gets Pin<&mut T> to the underlying pinned value from this nested Pin-pointer.

This is a generic method to go from Pin<&mut Pin<Pointer<T>>> to Pin<&mut T>. It is safe because the existence of a Pin<Pointer<T>> ensures that the pointee, T, cannot move in the future, and this method does not enable the pointee to move. “Malicious” implementations of Ptr::DerefMut are likewise ruled out by the contract of Pin::new_unchecked.

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

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

Assigns a new value to the memory location pointed to by the Pin<Ptr>.

This overwrites pinned data, but that is okay: the original pinned value’s destructor gets run before being overwritten and the new value is also a valid value of the same type, so no pinning invariant is violated. See the pin module documentation for more information on how this upholds the pinning invariants.

Example

use std::pin::Pin;

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

Trait Implementations

impl<T> AsyncRead for VibeioIo<T>

where T: Read,

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, tbuf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<T> AsyncWrite for VibeioIo<T>

where T: Write,

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

impl<T: Debug> Debug for VibeioIo<T>

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

Formats the value using the given formatter.

impl<T> Deref for VibeioIo<T>

type Target = Pin<Box<T>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for VibeioIo<T>

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

Mutably dereferences the value.

impl<T> Read for VibeioIo<T>

where T: AsyncRead,

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: ReadBufCursor<'_>, ) -> Poll<Result<(), Error>>

Attempts to read bytes into the buf.

impl<T> Write for VibeioIo<T>

where T: AsyncWrite,

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the destination.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object.

fn poll_shutdown( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to shut down this writer.

fn is_write_vectored(&self) -> bool

Returns whether this writer has an efficient poll_write_vectored implementation.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.