Struct rouille::input::multipart::MultipartData

pub struct MultipartData<M> { /* fields omitted */ }

The data of a field in a multipart/form-data request.

You can read it to EOF, or use the save() adaptor to save it to disk/memory.

Methods

impl<M> MultipartData<M> where
    M: ReadEntry, 

pub fn save(&mut self) -> SaveBuilder<&mut MultipartData<M>>

Get a builder type which can save the field with or without a size limit.

pub fn into_inner(self) -> M

Take the inner Multipart or &mut Multipart

pub fn set_min_buf_size(&mut self, min_buf_size: usize)

Set the minimum buffer size that BufRead::fill_buf(self) will return until the end of the stream is reached. Set this as small as you can tolerate to minimize read() calls (read() won't be called again until the buffer is smaller than this).

This value is reset between fields.

Trait Implementations

impl<M> Debug for MultipartData<M> where
    M: Debug, 

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

Formats the value using the given formatter.

impl<M> BufRead for MultipartData<M> where
    M: ReadEntry, 

In this implementation, fill_buf() can return more data with each call.

Use set_min_buf_size() if you require a minimum buffer length.

fn fill_buf(&mut self) -> Result<&[u8], Error>

Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(&mut self, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to read.

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes into buf until the delimiter byte or EOF is reached.

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

Read all bytes until a newline (the 0xA byte) is reached, and append them to the provided buffer.

fn split(self, byte: u8) -> Split<Self>

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

Returns an iterator over the lines of this reader.

impl<M> Read for MultipartData<M> where
    M: ReadEntry, 

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

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

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

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

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.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

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

Creates an adaptor which will chain this stream with another.

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

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