Struct hyper::upgrade::Upgraded

pub struct Upgraded { /* fields omitted */ }

An upgraded HTTP connection.

This type holds a trait object internally of the original IO that was used to speak HTTP before the upgrade. It can be used directly as a Read or Write for convenience.

Alternatively, if the exact type is known, this can be deconstructed into its parts.

Methods

impl Upgraded

pub fn downcast<T: AsyncRead + AsyncWrite + 'static>(     self ) -> Result<Parts<T>, Self>

Tries to downcast the internal trait object to the type passed.

On success, returns the downcasted parts. On error, returns the Upgraded back.

Trait Implementations

impl Debug for Upgraded

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

Formats the value using the given formatter.

impl Read for Upgraded

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where     R: Read,

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl Write for Upgraded

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this object, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this write.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.

impl AsyncWrite for Upgraded

fn shutdown(&mut self) -> Poll<(), Error>

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

fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, Error>

Write a Buf into this value, returning how many bytes were written.

fn poll_write(&mut self, buf: &[u8]) -> Result<Async<usize>, Error>

Attempt to write bytes from buf into the object.

fn poll_flush(&mut self) -> Result<Async<()>, Error>

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

impl AsyncRead for Upgraded

unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> Poll<usize, Error>

Pull some bytes from this source into the specified BufMut, returning how many bytes were read.

fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>

Attempt to read from the AsyncRead into buf.

fn framed<T>(self, codec: T) -> Framed<Self, T> where     Self: AsyncWrite,     T: Decoder + Encoder,

Deprecated since 0.1.7

: Use tokio_codec::Decoder::framed instead

Provides a Stream and Sink interface for reading and writing to this I/O object, using Decode and Encode to read and write the raw data.

fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where     Self: AsyncWrite,

Helper method for splitting this read/write object into two halves.