Enum edge_http::io::client::Connection

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

Variants

Transition(TransitionState)

Unbound(UnboundState<'b, T, N>)

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

Response(ResponseState<'b, T, N>)

Implementations

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

where T: TcpConnect,

pub fn new(buf: &'b mut [u8], socket: &'b T, addr: SocketAddr) -> Self

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

pub async fn initiate_request( &mut self, http11: bool, method: Method, uri: &str, headers: &[(&str, &str)], ) -> Result<(), Error<T::Error>>

pub fn is_request_initiated(&self) -> bool

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

pub fn is_response_initiated(&self) -> bool

pub async fn initiate_ws_upgrade_request( &mut self, host: Option<&str>, origin: Option<&str>, uri: &str, version: Option<&str>, nonce: &[u8; 16], nonce_base64_buf: &mut [u8; 28], ) -> Result<(), Error<T::Error>>

pub fn is_ws_upgrade_accepted( &self, nonce: &[u8; 16], buf: &mut [u8; 33], ) -> Result<bool, Error<T::Error>>

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

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

pub fn raw_connection(&mut self) -> Result<&mut T::Socket<'b>, Error<T::Error>>

pub fn release(self) -> (T::Socket<'b>, &'b mut [u8])

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

Trait Implementations

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

where T: TcpConnect,

type Error = Error<<T as TcpConnect>::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: TcpConnect,

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: TcpConnect,

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.