Struct SendRequest 

pub struct SendRequest<T, B>
where
    T: OpenStreams<B>,
    B: Buf,
{ /* private fields */ }

HTTP/3 request sender

send_request() initiates a new request and will resolve when it is ready to be sent to the server. Then a RequestStream will be returned to send a request body (for POST, PUT methods) and receive a response. After the whole body is sent, it is necessary to call RequestStream::finish() to let the server know the request transfer is complete. This includes the cases where no body is sent at all.

This struct is cloneable so multiple requests can be sent concurrently.

Existing instances are atomically counted internally, so whenever all of them have been dropped, the connection will be automatically closed whith HTTP/3 connection error code HTTP_NO_ERROR = 0.

Examples

Sending a request with no body

// Prepare the HTTP request to send to the server
let request = Request::get("https://www.example.com/").body(())?;

// Send the request to the server
let mut req_stream: RequestStream<_, _> = send_request.send_request(request).await?;
// Don't forget to end up the request by finishing the send stream.
req_stream.finish().await?;
// Receive the response
let response: Response<()> = req_stream.recv_response().await?;
// Process the response...

Sending a request with a body and trailers

// Prepare the HTTP request to send to the server
let request = Request::get("https://www.example.com/").body(())?;

// Send the request to the server
let mut req_stream = send_request.send_request(request).await?;
// Send some data
req_stream.send_data("body".into()).await?;
// Prepare the trailers
let mut trailers = HeaderMap::new();
trailers.insert("trailer", "value".parse()?);
// Send them and finish the send stream
req_stream.send_trailers(trailers).await?;
// We don't need to finish the send stream, as `send_trailers()` did it for us

// Receive the response.
let response = req_stream.recv_response().await?;
// Process the response...

Implementations

impl<T, B> SendRequest<T, B>

where T: OpenStreams<B>, B: Buf,

pub async fn send_request( &mut self, req: Request<()>, ) -> Result<RequestStream<T::BidiStream, B>, Error>

Send a HTTP/3 request to the server

Trait Implementations

impl<T, B> Clone for SendRequest<T, B>

where T: OpenStreams<B> + Clone, B: Buf,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, B> Drop for SendRequest<T, B>

where T: OpenStreams<B>, B: Buf,

fn drop(&mut self)

Executes the destructor for this type.