Struct `Connection`

struct Connection<T, S, E> { ... }
where
    S: HttpService<crate::body::Incoming>

A Future representing an HTTP/2 connection, bound to a Service, 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, B, S, E> 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.

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

`impl<F> IntoFuture for Connection<T, S, E>`

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

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

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

`impl<Fut> TryFutureExt for Connection<T, S, E>`

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

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

`impl<I, S, E> Debug for Connection<I, S, E>`

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

`impl<T> Any for Connection<T, S, E>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Connection<T, S, E>`

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

`impl<T> BorrowMut for Connection<T, S, E>`

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

`impl<T> From for Connection<T, S, E>`

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

`impl<T> FutureExt for Connection<T, S, E>`

`impl<T> Instrument for Connection<T, S, E>`

`impl<T> WithSubscriber for Connection<T, S, E>`

`impl<T, S, E> Freeze for Connection<T, S, E>`

`impl<T, S, E> RefUnwindSafe for Connection<T, S, E>`

`impl<T, S, E> Send for Connection<T, S, E>`

`impl<T, S, E> Sync for Connection<T, S, E>`

`impl<T, S, E> UnwindSafe for Connection<T, S, E>`

`impl<T, U> Into for Connection<T, 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<T, S, E>`

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

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

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