Enum edge_http::io::server::Connection

pub enum Connection<'b, T, const N: usize = DEFAULT_MAX_HEADERS_COUNT> {
    Transition(TransitionState),
    Unbound(T),
    Request(RequestState<'b, T, N>),
    Response(SendBody<T>),
}

Variants

Transition(TransitionState)

Unbound(T)

Request(RequestState<'b, T, N>)

Response(SendBody<T>)

Implementations

impl<'b, T, const N: usize> Connection<'b, T, N>

where T: Read + Write,

pub async fn new( buf: &'b mut [u8], io: T, timeout_ms: Option<u32>, ) -> Result<Connection<'b, T, N>, Error<T::Error>>

pub fn is_request_initiated(&self) -> bool

pub fn split(&mut self) -> (&RequestHeaders<'b, N>, &mut Body<'b, T>)

pub fn headers(&self) -> Result<&RequestHeaders<'b, N>, Error<T::Error>>

pub fn is_ws_upgrade_request(&self) -> Result<bool, Error<T::Error>>

pub async fn initiate_response( &mut self, status: u16, message: Option<&str>, headers: &[(&str, &str)], ) -> Result<(), Error<T::Error>>

pub async fn initiate_ws_upgrade_response( &mut self, buf: &mut [u8; 33], ) -> Result<(), Error<T::Error>>

pub fn is_response_initiated(&self) -> bool

pub async fn complete(&mut self) -> Result<(), Error<T::Error>>

pub async fn complete_err(&mut self, err: &str) -> Result<(), Error<T::Error>>

pub fn needs_close(&self) -> bool

pub fn unbind(&mut self) -> Result<&mut T, Error<T::Error>>

Trait Implementations

impl<'b, T, const N: usize> ErrorType for Connection<'b, T, N>

where T: ErrorType,

type Error = Error<<T as ErrorType>::Error>

Error type of all the IO operations on this type.

impl<'b, T, const N: usize> Read for Connection<'b, T, N>

where T: Read + Write,

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

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

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<'b, T, const N: usize> Write for Connection<'b, T, N>

where T: Read + Write,

async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.