Struct `Connection`

struct Connection<'a, I, S, E> { ... }
where
    S: HttpService<hyper::body::Incoming>

A Future representing an HTTP/1 connection, returned from Builder::serve_connection.

To drive HTTP on this connection this future must be polled, typically with .await. If it isn't polled, no progress will be made on this connection.

Implementations

`impl<I, S, E, B> Connection<'_, I, S, E>`

fn graceful_shutdown(self: Pin<&mut Self>)

Start a graceful shutdown process for this connection.

This Connection should continue to be polled until shutdown can finish.

Note

This should only be called while the Connection future is still pending. If called after Connection::poll has resolved, this does nothing.

fn into_owned(self: Self) -> Connection<'static, I, S, E> where Builder<E>: Clone

Make this Connection static, instead of borrowing from Builder.

`impl<'__pin, 'a, I, S, E> Unpin for Connection<'a, I, S, E>`

`impl<'a, I, S, E> Freeze for Connection<'a, I, S, E>`

`impl<'a, I, S, E> RefUnwindSafe for Connection<'a, I, S, E>`

`impl<'a, I, S, E> Send for Connection<'a, I, S, E>`

`impl<'a, I, S, E> Sync for Connection<'a, I, S, E>`

`impl<'a, I, S, E> UnsafeUnpin for Connection<'a, I, S, E>`

`impl<'a, I, S, E> UnwindSafe for Connection<'a, I, S, E>`

`impl<F> IntoFuture for Connection<'a, I, S, E>`

fn into_future(self: Self) -> <F as IntoFuture>::IntoFuture

`impl<F, T, E> TryFuture for Connection<'a, I, S, E>`

fn try_poll(self: Pin<&mut F>, cx: &mut Context<'_>) -> Poll<<F as Future>::Output>

`impl<Fut> TryFutureExt for Connection<'a, I, S, E>`

`impl<I, S, E, B> Future for Connection<'_, I, S, E>`

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

`impl<T> Any for Connection<'a, I, S, E>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Connection<'a, I, S, E>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Connection<'a, I, S, E>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for Connection<'a, I, S, E>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> FutureExt for Connection<'a, I, S, E>`

`impl<T> Instrument for Connection<'a, I, S, E>`

`impl<T> WithSubscriber for Connection<'a, I, S, E>`

`impl<T, U> Into for Connection<'a, I, S, E>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Connection<'a, I, S, E>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Connection<'a, I, S, E>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>