Struct MultipartReader 

pub struct MultipartReader<R: Read> { /* private fields */ }

Available on crate feature std only.

Reads a multipart body from a blocking reader, one part at a time.

It has no hooks: the caller sees each part itself. Dropping a PartReader before its end skips the rest of the part at the next next_part.

Examples

use std::io::Read;

let body = b"--X\r\nContent-Disposition: form-data; name=note\r\n\r\nhi\r\n--X\r\nContent-Disposition: form-data; name=f; filename=a.bin\r\n\r\n0123\r\n--X--";
let mut reader = form_net::MultipartReader::new(b"multipart/form-data; boundary=X", &body[..])?;
let mut seen = Vec::new();
while let Some(mut part) = reader.next_part()? {
    if part.head().view().is_file() {
        let mut bytes = Vec::new();
        part.read_to_end(&mut bytes).unwrap();
        seen.push(bytes.len());
    } else {
        seen.push(part.text()?.len());
    }
}
assert_eq!(seen, [2, 4]);

Implementations

impl<R: Read> MultipartReader<R>

pub fn new(content_type: &[u8], reader: R) -> Result<Self, FormError>

A reader with the default limits and policy.

Errors

UnsupportedMediaType and the boundary errors.

pub fn with_limits( content_type: &[u8], reader: R, limits: &Limits, policy: &Policy, ) -> Result<Self, FormError>

A reader with explicit limits and policy.

Errors

As new; InvalidLimits.

pub fn captured_token(&self) -> Option<&str>

The token field’s value, once its part has ended.

pub fn next_part(&mut self) -> Result<Option<PartReader<'_, R>>, FormError>

The next part, or None after the close delimiter. Skips whatever is left of the previous part.

Errors

Every multipart error; Io { kind } from the reader.

Trait Implementations

impl<R: Read> Debug for MultipartReader<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Read> Drop for MultipartReader<R>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.