Struct multipart::client::SizedRequest

pub struct SizedRequest<R> { /* fields omitted */ }

A wrapper around a request object that measures the request body and sets the Content-Length header to its size in bytes.

Sized requests are more human-readable and use less bandwidth (as chunking adds visual noise and overhead), but they must be able to load their entirety, including the contents of all files and streams, into memory so the request body can be measured.

You should really only use sized requests if you intend to inspect the data manually on the server side, as it will produce a more human-readable request body. Also, of course, if the server doesn’t support chunked requests or otherwise rejects them.

Trait Implementations

impl<R: HttpRequest> HttpRequest for SizedRequest<R> where
    <R::Stream as HttpStream>::Error: From<R::Error>, 

fn apply_headers(&mut self, boundary: &str, _content_len: Option<u64>) -> bool

SizedRequest ignores _content_len because it sets its own later.

type Stream = Self

The HTTP stream type that can be opend by this request, to which the multipart data will be written.

type Error = R::Error

The error type for this request. Must be compatible with io::Error as well as Self::HttpStream::Error

fn open_stream(self) -> Result<Self, Self::Error>

Open the request stream and return it or any error otherwise.

impl<R: HttpRequest> HttpStream for SizedRequest<R> where
    <R::Stream as HttpStream>::Error: From<R::Error>, 

type Request = Self

The request type that opened this stream.

type Response = <<R as HttpRequest>::Stream as HttpStream>::Response

The response type that will be returned after the request is completed.

type Error = <<R as HttpRequest>::Stream as HttpStream>::Error

The error type for this stream. Must be compatible with io::Error as well as Self::Request::Error.

fn finish(self) -> Result<Self::Response, Self::Error>

Finalize and close the stream and return the response object, or any error otherwise.

impl<R> Write for SizedRequest<R>

fn write(&mut self, data: &[u8]) -> Result<usize>

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

fn flush(&mut self) -> Result<()>

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

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Write.