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.

Implementations

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> 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.

pub 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.

pub 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.

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

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

pub 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.

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

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

pub fn lines(self) -> Lines<Self>

Returns an iterator over the lines of this reader.

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

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

Formats the value using the given formatter.

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

pub 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.

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

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

pub fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

pub 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.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

Creates a “by reference” adaptor for this instance of Read.

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adaptor which will chain this stream with another.

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

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