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. After the close delimiter it reads the rest of the body, which is epilogue and counts against max_epilogue_bytes and max_body_bytes, as parse_multipart counts it (D-142).

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.