Struct multipart::client::lazy::PreparedFields

pub struct PreparedFields<'d> { /* fields omitted */ }

The result of Multipart::prepare().

Implements Read, contains the entire request body.

Individual files/streams are dropped as they are read to completion.

Note

The fields in the request may have been reordered to simplify the preparation step. No compliant server implementation will be relying on the specific ordering of fields anyways.

Implementations

impl<'d> PreparedFields<'d>

pub fn content_len(&self) -> Option<u64>

Get the content-length value for this set of fields, if applicable (all fields are sized, i.e. not generic streams).

pub fn boundary(&self) -> &str

Get the boundary that was used to serialize the request.

Trait Implementations

impl<'d> Read for PreparedFields<'d>

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

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

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

Like read, except that it reads into a slice of buffers.

pub fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

pub unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

pub fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

pub fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

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

Read the exact number of bytes required to fill buf.

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

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

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

pub fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

pub fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.