# Struct hyper::upgrade::Upgraded [−] [src]

    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.

## Implementations

### `impl Upgraded` [src]

#### `pub fn downcast<T: AsyncRead + AsyncWrite + Unpin + 'static>(
self
) -> Result<Parts<T>, Self>` [src]

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 AsyncRead for Upgraded` [src]

#### `fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<()>>` [src]

Attempts to read from the `AsyncRead` into `buf`. Read more

### `impl AsyncWrite for Upgraded` [src]

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

Attempt to write bytes from `buf` into the object. Read more

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

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

#### `fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>` [src]

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

#### `fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>` [src]

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

#### `fn is_write_vectored(&self) -> bool` [src]

Determines if this writer has an efficient `poll_write_vectored` implementation. Read more

### `impl Debug for Upgraded` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl !RefUnwindSafe for Upgraded`

### `impl Send for Upgraded`

### `impl !Sync for Upgraded`

### `impl Unpin for Upgraded`

### `impl !UnwindSafe for Upgraded`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized,` [src]

#### `pub fn chain<R>(self, next: R) -> Chain<Self, R> where
R: AsyncRead,` [src]

Creates a new `AsyncRead` instance that chains this stream with `next`. Read more

#### `pub fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin,` [src]

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

#### `pub fn read_buf<B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B> where
Self: Unpin,
B: BufMut,` [src]

Pulls some bytes from this source into the specified buffer, advancing the buffer’s internal cursor. Read more

#### `pub fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin,` [src]

Reads the exact number of bytes required to fill `buf`. Read more

#### `pub fn read_u8(&'a mut self) -> ReadU8<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 8 bit integer from the underlying reader. Read more

#### `pub fn read_i8(&'a mut self) -> ReadI8<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 8 bit integer from the underlying reader. Read more

#### `pub fn read_u16(&'a mut self) -> ReadU16<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 16-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i16(&'a mut self) -> ReadI16<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 16-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u32(&'a mut self) -> ReadU32<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 32-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i32(&'a mut self) -> ReadI32<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 32-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u64(&'a mut self) -> ReadU64<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 64-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i64(&'a mut self) -> ReadI64<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 64-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u128(&'a mut self) -> ReadU128<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 128-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_i128(&'a mut self) -> ReadI128<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 128-bit integer in big-endian order from the underlying reader. Read more

#### `pub fn read_u16_le(&'a mut self) -> ReadU16Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 16-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i16_le(&'a mut self) -> ReadI16Le<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 16-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_u32_le(&'a mut self) -> ReadU32Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 32-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i32_le(&'a mut self) -> ReadI32Le<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 32-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_u64_le(&'a mut self) -> ReadU64Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 64-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i64_le(&'a mut self) -> ReadI64Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 64-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_u128_le(&'a mut self) -> ReadU128Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 128-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_i128_le(&'a mut self) -> ReadI128Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 128-bit integer in little-endian order from the underlying reader. Read more

#### `pub fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEnd<'a, Self> where
Self: Unpin,` [src]

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

#### `pub fn read_to_string(
&'a mut self,
dst: &'a mut String
) -> ReadToString<'a, Self> where
Self: Unpin,` [src]

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

#### `pub fn take(self, limit: u64) -> Take<Self>` [src]

Creates an adaptor which reads at most `limit` bytes from it. Read more

### `impl<W> AsyncWriteExt for W where
W: AsyncWrite + ?Sized,` [src]

#### `pub fn write(&'a mut self, src: &'a [u8]) -> Write<'a, Self> where
Self: Unpin,` [src]

Writes a buffer into this writer, returning how many bytes were written. Read more

#### `pub fn write_buf<B>(&'a mut self, src: &'a mut B) -> WriteBuf<'a, Self, B> where
Self: Unpin,
B: Buf,` [src]

Writes a buffer into this writer, advancing the buffer’s internal cursor. Read more

#### `pub fn write_all(&'a mut self, src: &'a [u8]) -> WriteAll<'a, Self> where
Self: Unpin,` [src]

Attempts to write an entire buffer into this writer. Read more

#### `pub fn write_u8(&'a mut self, n: u8) -> WriteU8<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 8-bit integer to the underlying writer. Read more

#### `pub fn write_i8(&'a mut self, n: i8) -> WriteI8<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 8-bit integer to the underlying writer. Read more

#### `pub fn write_u16(&'a mut self, n: u16) -> WriteU16<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 16-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i16(&'a mut self, n: i16) -> WriteI16<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 16-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u32(&'a mut self, n: u32) -> WriteU32<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 32-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i32(&'a mut self, n: i32) -> WriteI32<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 32-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u64(&'a mut self, n: u64) -> WriteU64<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 64-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i64(&'a mut self, n: i64) -> WriteI64<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 64-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u128(&'a mut self, n: u128) -> WriteU128<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 128-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_i128(&'a mut self, n: i128) -> WriteI128<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 128-bit integer in big-endian order to the underlying writer. Read more

#### `pub fn write_u16_le(&'a mut self, n: u16) -> WriteU16Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 16-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i16_le(&'a mut self, n: i16) -> WriteI16Le<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 16-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_u32_le(&'a mut self, n: u32) -> WriteU32Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 32-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i32_le(&'a mut self, n: i32) -> WriteI32Le<&'a mut Self> where
Self: Unpin,` [src]

Writes a signed 32-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_u64_le(&'a mut self, n: u64) -> WriteU64Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 64-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i64_le(&'a mut self, n: i64) -> WriteI64Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 64-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_u128_le(&'a mut self, n: u128) -> WriteU128Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an unsigned 128-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn write_i128_le(&'a mut self, n: i128) -> WriteI128Le<&'a mut Self> where
Self: Unpin,` [src]

Writes an signed 128-bit integer in little-endian order to the underlying writer. Read more

#### `pub fn flush(&mut self) -> Flush<'_, Self> where
Self: Unpin,` [src]

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

#### `pub fn shutdown(&mut self) -> Shutdown<'_, Self> where
Self: Unpin,` [src]

Shuts down the output stream, ensuring that the value can be dropped cleanly. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T> Instrument for T` [src]

#### `pub fn instrument(self, span: Span) -> Instrumented<Self>` [src]

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more

#### `pub fn in_current_span(self) -> Instrumented<Self>` [src]

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.