Struct MultipartReader

pub struct MultipartReader<'r> { /* private fields */ }

A data guard for multipart/* data. Provides async reading of the individual multipart sections.

Example

#[post("/mixed", data = "<mixed>")]
async fn multipart_data(mut mixed: MultipartReader<'_>) -> String {
    while let Some(mut a) = mixed.next().await.unwrap() {
        if let Some(ct) = a.headers().get_one("Content-Type") {
            // Check content_type
        }
        let mut buf = vec![];
        a.read_to_end(&mut buf).await.unwrap();
        // Use section's body
    }
}

Limits

Like most data guards, MultipartReader provides a configurable limit. It uses the file/multipart limit or a default limit of 1 MiB. This is the limit for the entire stream, not individual sections.

Implementations

impl<'r> MultipartReader<'r>

pub async fn next( &mut self, ) -> Result<Option<MultipartReadSection<'r, '_>>, Error>

Gets the next section from this multipart reader. The returned section mutably borrows from self, so it must be dropped before another secton can be read.

pub fn content_type(&self) -> &'r ContentType

The content type of the multipart stream as a whole. The primary type is always multipart

Trait Implementations

impl<'r> FromData<'r> for MultipartReader<'r>

type Error = Error

The associated error to be returned when the guard fails.

fn from_data<'life0, 'async_trait>( req: &'r Request<'life0>, data: Data<'r>, ) -> Pin<Box<dyn Future<Output = Outcome<'r, Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Asynchronously validates, parses, and converts an instance of Self from the incoming request body data.