Struct UpgradeableConnection

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

An upgradable Connection, returned by Builder::serve_upgradable_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> UpgradeableConnection<'_, I, S, E>

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

Start a graceful shutdown process for this connection.

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

Note

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

fn into_owned(self: Self) -> UpgradeableConnection<'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 UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> Freeze for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> RefUnwindSafe for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> Send for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> Sync for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> UnsafeUnpin for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> UnwindSafe for UpgradeableConnection<'a, I, S, E>

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

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

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

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

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

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

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

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

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

fn from(t: T) -> T

Returns the argument unchanged.

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

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

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

impl<T, U> Into for UpgradeableConnection<'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 UpgradeableConnection<'a, I, S, E>

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

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

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