Struct multipart_rfc7578::Form

pub struct Form<'a> { /* fields omitted */ }

Implements the multipart/form-data media type as described by RFC 7578.

See.

Methods

impl<'a> Form<'a>

pub fn new<G>() -> Self where
    G: BoundaryGenerator, 

Creates a new form with the specified boundary generator function.

Examples

struct TestGenerator;

impl BoundaryGenerator for TestGenerator {
    fn generate_boundary() -> String {
        "test".to_string()
    }
}

let form = Form::new::<TestGenerator>();

pub fn add_text<N, T>(&mut self, name: N, text: T) where
    N: Display,
    T: Into<String>, 

Adds a text part to the Form.

Examples

use multipart_rfc7578::Form;

let mut form = Form::default();

form.add_text("text", "Hello World!");
form.add_text("more", String::from("Hello Universe!"));

pub fn add_reader2<F, G, R>(
    &mut self,
    name: F,
    read: R,
    filename: Option<G>,
    mime: Option<Mime>,
    length: Option<u64>
) where
    F: Display,
    G: Into<String>,
    R: 'a + Read + Send, 

Adds a readable part to the Form.

Examples

use multipart_rfc7578::Form;
use std::io::Cursor;

let string = "Hello World!";
let bytes = Cursor::new(string);
let mut form = Form::default();

form.add_reader2("input", bytes, Some("filename.png"), Some(mime::TEXT_PLAIN), Some(string.len() as u64));

pub fn add_reader<F, R>(&mut self, name: F, read: R) where
    F: Display,
    R: 'a + Read + Send, 

Adds a readable part to the Form.

Examples

use multipart_rfc7578::Form;
use std::io::Cursor;

let bytes = Cursor::new("Hello World!");
let mut form = Form::default();

form.add_reader("input", bytes);

pub fn add_reader_file<F, G, R>(&mut self, name: F, read: R, filename: G) where
    F: Display,
    G: Into<String>,
    R: 'a + Read + Send, 

Adds a readable part to the Form as a file.

Examples

use multipart_rfc7578::Form;
use std::io::Cursor;

let bytes = Cursor::new("Hello World!");
let mut form = Form::default();

form.add_reader_file("input", bytes, "filename.txt");

pub fn add_reader_file_with_mime<F, G, R>(
    &mut self,
    name: F,
    read: R,
    filename: G,
    mime: Mime
) where
    F: Display,
    G: Into<String>,
    R: 'a + Read + Send, 

Adds a readable part to the Form as a file with a specified mime.

Examples

use multipart_rfc7578::Form;
use std::io::Cursor;

let bytes = Cursor::new("Hello World!");
let mut form = Form::default();

form.add_reader_file_with_mime("input", bytes, "filename.txt", mime::TEXT_PLAIN);

pub fn add_file<P, F>(&mut self, name: F, path: P) -> Result<()> where
    P: AsRef<Path>,
    F: Display, 

Adds a file, and attempts to derive the mime type.

Examples

use multipart_rfc7578::Form;

let mut form = Form::default();

form.add_file("file", file!()).expect("file to exist");

pub fn add_file_with_mime<P, F>(
    &mut self,
    name: F,
    path: P,
    mime: Mime
) -> Result<()> where
    P: AsRef<Path>,
    F: Display, 

Adds a file with the specified mime type to the form. If the mime type isn't specified, a mime type will try to be derived.

Examples

use multipart_rfc7578::Form;

let mut form = Form::default();

form.add_file_with_mime("data", "test.csv", mime::TEXT_CSV);

pub fn content_type(&self) -> String

get boundary as content type string

pub fn content_length(&self) -> Option<u64>

get content length

impl Form<'static>

pub fn set_body(self) -> !

Just for documentation. Updates a request instance with the multipart Content-Type header and the payload data.

awc example

use awc::Client;
use multipart_rfc7578::{Form, SetBody};

let url = "http://localhost:80/upload";
let req = Client::default().post(url);
let mut form = Form::default();

form.add_text("text", "Hello World!");
let req = form.set_body(req).unwrap();

Hyper example

use hyper::{Method, Request, Uri};
use multipart_rfc7578::{Form, SetBody};

let url: Uri = "http://localhost:80/upload".parse().unwrap();
let mut req_builder = Request::post(url);
let mut form = Form::default();

form.add_text("text", "Hello World!");
let req = form.set_body(&mut req_builder).unwrap();

Trait Implementations

impl<'a> Default for Form<'a>

fn default() -> Self

Creates a new form with the default boundary generator.

impl<'a> From<Form<'a>> for Body<'a>

fn from(form: Form<'a>) -> Self

Turns a Form into a multipart Body.