Struct multipart::client::lazy::Multipart

pub struct Multipart<'n, 'd> { /* fields omitted */ }

A multipart request which writes all fields at once upon being provided an output stream.

Sacrifices static dispatch for support for dynamic construction. Reusable.

Lifetimes

• 'n: Lifetime for field names; will only escape this struct in LazyIoError<'n>.
• 'd: Lifetime for data: will only escape this struct in PreparedFields<'d>.

Methods

impl<'n, 'd> Multipart<'n, 'd>

fn client_request<U: IntoUrl>(&mut self,
                              client: &Client,
                              url: U)
                              -> HyperResult<Response>

Feature: hyper

Complete a POST request with the given hyper::client::Client and URL.

Supplies the fields in the body, optionally setting the content-length header if applicable (all added fields were text or files, i.e. no streams).

fn client_request_mut<U: IntoUrl, F: FnOnce(RequestBuilder) -> RequestBuilder>(&mut self,
                                                                               client: &Client,
                                                                               url: U,
                                                                               mut_fn: F)
                                                                               -> HyperResult<Response>

Feature: hyper

Complete a POST request with the given hyper::client::Client and URL; allows mutating the hyper::client::RequestBuilder via the passed closure.

Note that the body, and the ContentType and ContentLength headers will be overwritten, either by this method or by Hyper.

impl<'n, 'd> Multipart<'n, 'd>

fn new() -> Self

Initialize a new lazy dynamic request.

fn add_text<N, T>(&mut self, name: N, text: T) -> &mut Self where N: Into<Cow<'n, str>>, T: Into<Cow<'d, str>>

Add a text field to this request.

fn add_file<N, P>(&mut self, name: N, path: P) -> &mut Self where N: Into<Cow<'n, str>>, P: IntoCowPath<'d>

Add a file field to this request.

Note

Does not check if path exists.

fn add_stream<N, R, F>(&mut self,
                       name: N,
                       stream: R,
                       filename: Option<F>,
                       mime: Option<Mime>)
                       -> &mut Self where N: Into<Cow<'n, str>>, R: Read + 'd, F: Into<Cow<'n, str>>

Add a generic stream field to this request,

fn send<R: HttpRequest>(&mut self,
                        req: R)
                        -> Result<R::Stream::Response, LazyError<'n, R::Stream::Error>>

Convert req to HttpStream, write out the fields in this request, and finish the request, returning the response if successful, or the first error encountered.

fn prepare(&mut self) -> LazyIoResult<'n, PreparedFields<'d>>

Export the multipart data contained in this lazy request as an adaptor which implements Read.

A certain amount of field data will be buffered. See prepare_threshold() for more information on this behavior.

fn prepare_threshold(&mut self,
                     buffer_threshold: Option<u64>)
                     -> LazyIoResult<'n, PreparedFields<'d>>

Export the multipart data contained in this lazy request to an adaptor which implements Read.

Buffering

For efficiency, text and file fields smaller than buffer_threshold are copied to an in-memory buffer. If None, all fields are copied to memory.

Trait Implementations

impl<'n, 'd> Debug for Multipart<'n, 'd>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'n, 'd> Default for Multipart<'n, 'd>

fn default() -> Multipart<'n, 'd>

Returns the "default value" for a type.