Struct hyper::proto::h1::dispatch::Dispatcher

pub(crate) struct Dispatcher<D, Bs: HttpBody, I, T> {
    conn: Conn<I, Bs::Data, T>,
    dispatch: D,
    body_tx: Option<Sender>,
    body_rx: Pin<Box<Option<Bs>>>,
    is_closing: bool,
}

Fields

conn: Conn<I, Bs::Data, T>

dispatch: D

body_tx: Option<Sender>

body_rx: Pin<Box<Option<Bs>>>

is_closing: bool

Implementations

impl<D, Bs, I, T> Dispatcher<D, Bs, I, T>

where D: Dispatch<PollItem = MessageHead<T::Outgoing>, PollBody = Bs, RecvItem = MessageHead<T::Incoming>> + Unpin, D::PollError: Into<Box<dyn StdError + Send + Sync>>, I: AsyncRead + AsyncWrite + Unpin, T: Http1Transaction + Unpin, Bs: HttpBody + 'static, Bs::Error: Into<Box<dyn StdError + Send + Sync>>,

pub(crate) fn new(dispatch: D, conn: Conn<I, Bs::Data, T>) -> Self

pub(crate) fn disable_keep_alive(&mut self)

pub(crate) fn into_inner(self) -> (I, Bytes, D)

pub(crate) fn poll_without_shutdown( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<()>>

where Self: Unpin,

Run this dispatcher until HTTP says this connection is done, but don’t call AsyncWrite::shutdown on the underlying IO.

This is useful for old-style HTTP upgrades, but ignores newer-style upgrade API.

fn poll_catch( &mut self, cx: &mut Context<'_>, should_shutdown: bool, ) -> Poll<Result<Dispatched>>

fn poll_inner( &mut self, cx: &mut Context<'_>, should_shutdown: bool, ) -> Poll<Result<Dispatched>>

fn poll_loop(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

fn poll_read(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

fn poll_read_head(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

fn poll_write(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

fn close(&mut self)

fn is_done(&self) -> bool

Trait Implementations

impl<D, Bs, I, T> Future for Dispatcher<D, Bs, I, T>

where D: Dispatch<PollItem = MessageHead<T::Outgoing>, PollBody = Bs, RecvItem = MessageHead<T::Incoming>> + Unpin, D::PollError: Into<Box<dyn StdError + Send + Sync>>, I: AsyncRead + AsyncWrite + Unpin, T: Http1Transaction + Unpin, Bs: HttpBody + 'static, Bs::Error: Into<Box<dyn StdError + Send + Sync>>,

type Output = Result<Dispatched, Error>

The type of value produced on completion.

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

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.