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

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

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

SizedRequest ignores _content_len because it sets its own later.

pub fn open_stream(mut self: 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.

pub fn finish(mut self: 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>

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

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

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

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

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

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

pub 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.

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

Attempts to write an entire buffer into this writer.

pub 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.

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

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

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

Creates a "by reference" adaptor for this instance of Write.