Struct rocket::http::ContentType

pub struct ContentType(pub MediaType);

Representation of HTTP Content-Types.

Usage

ContentTypes should rarely be created directly. Instead, an associated constant should be used; one is declared for most commonly used content types.

Example

A Content-Type of text/html; charset=utf-8 can be instantiated via the HTML constant:

use rocket::http::ContentType;

let html = ContentType::HTML;

Header

ContentType implements Into<Header>. As such, it can be used in any context where an Into<Header> is expected:

use rocket::http::ContentType;
use rocket::response::Response;

let response = Response::build().header(ContentType::HTML).finalize();

Methods

impl ContentType

fn new<T, S>(top: T, sub: S) -> ContentType where
    T: Into<Cow<'static, str>>,
    S: Into<Cow<'static, str>>, 

Creates a new ContentType with top-level type top and subtype sub. This should only be used to construct uncommon or custom content types. Use an associated constant for everything else.

Example

Create a custom application/x-person content type:

use rocket::http::ContentType;

let custom = ContentType::new("application", "x-person");
assert_eq!(custom.top(), "application");
assert_eq!(custom.sub(), "x-person");

fn from_extension(ext: &str) -> Option<ContentType>

Returns the Content-Type associated with the extension ext if the extension is recognized. Not all extensions are recognized. If an extensions is not recognized, then this method returns None. The currently recognized extensions are txt, html, htm, xml, csv, js, css, json, png, gif, bmp, jpeg, jpg, webp, svg, pdf, ttf, otf, woff, and woff2.

Example

A recognized content type:

use rocket::http::ContentType;

let xml = ContentType::from_extension("xml");
assert_eq!(xml, Some(ContentType::XML));

An unrecognized content type:

use rocket::http::ContentType;

let foo = ContentType::from_extension("foo");
assert!(foo.is_none());

fn with_params<T, S, K, V, P>(top: T, sub: S, ps: P) -> ContentType where
    T: Into<Cow<'static, str>>,
    S: Into<Cow<'static, str>>,
    K: Into<Cow<'static, str>>,
    V: Into<Cow<'static, str>>,
    P: IntoCollection<(K, V)>, 

Creates a new ContentType with top-level type top, subtype sub, and parameters ps. This should only be used to construct uncommon or custom content types. Use an associated constant for everything else.

Example

Create a custom application/x-id; id=1 content type:

use rocket::http::ContentType;

let id = ContentType::with_params("application", "x-id", ("id", "1"));
assert_eq!(id.to_string(), "application/x-id; id=1".to_string());

Create a custom text/person; name=bob; weight=175 content type:

use rocket::http::ContentType;

let params = vec![("name", "bob"), ("ref", "2382")];
let mt = ContentType::with_params("text", "person", params);
assert_eq!(mt.to_string(), "text/person; name=bob; ref=2382".to_string());

fn media_type(&self) -> &MediaType

Borrows the inner MediaType of self.

Example

use rocket::http::{ContentType, MediaType};

let http = ContentType::HTML;
let media_type = http.media_type();

const Any: ContentType

Any: ContentType = ContentType(<MediaType>::Any)

Content-Type for any media type : * / *

const HTML: ContentType

HTML: ContentType = ContentType(<MediaType>::HTML)

Content-Type for HTML : text / html ; charset = utf-8

const Plain: ContentType

Plain: ContentType = ContentType(<MediaType>::Plain)

Content-Type for plain text : text / plain ; charset = utf-8

const JSON: ContentType

JSON: ContentType = ContentType(<MediaType>::JSON)

Content-Type for JSON : application / json

const MsgPack: ContentType

MsgPack: ContentType = ContentType(<MediaType>::MsgPack)

Content-Type for MessagePack : application / msgpack

const Form: ContentType

Form: ContentType = ContentType(<MediaType>::Form)

Content-Type for forms : application / x-www-form-urlencoded

const JavaScript: ContentType

JavaScript: ContentType = ContentType(<MediaType>::JavaScript)

Content-Type for JavaScript : application / javascript

const CSS: ContentType

CSS: ContentType = ContentType(<MediaType>::CSS)

Content-Type for CSS : text / css ; charset = utf-8

const FormData: ContentType

FormData: ContentType = ContentType(<MediaType>::FormData)

Content-Type for multipart form data : multipart / form-data

const XML: ContentType

XML: ContentType = ContentType(<MediaType>::XML)

Content-Type for XML : text / xml ; charset = utf-8

const CSV: ContentType

CSV: ContentType = ContentType(<MediaType>::CSV)

Content-Type for CSV : text / csv ; charset = utf-8

const PNG: ContentType

PNG: ContentType = ContentType(<MediaType>::PNG)

Content-Type for PNG : image / png

const GIF: ContentType

GIF: ContentType = ContentType(<MediaType>::GIF)

Content-Type for GIF : image / gif

const BMP: ContentType

BMP: ContentType = ContentType(<MediaType>::BMP)

Content-Type for BMP : image / bmp

const JPEG: ContentType

JPEG: ContentType = ContentType(<MediaType>::JPEG)

Content-Type for JPEG : image / jpeg

const WEBP: ContentType

WEBP: ContentType = ContentType(<MediaType>::WEBP)

Content-Type for WEBP : image / webp

const SVG: ContentType

SVG: ContentType = ContentType(<MediaType>::SVG)

Content-Type for SVG : image / svg+xml

const PDF: ContentType

PDF: ContentType = ContentType(<MediaType>::PDF)

Content-Type for PDF : application / pdf

const TTF: ContentType

TTF: ContentType = ContentType(<MediaType>::TTF)

Content-Type for TTF : application / font-sfnt

const OTF: ContentType

OTF: ContentType = ContentType(<MediaType>::OTF)

Content-Type for OTF : application / font-sfnt

const WOFF: ContentType

WOFF: ContentType = ContentType(<MediaType>::WOFF)

Content-Type for WOFF : application / font-woff

const WOFF2: ContentType

WOFF2: ContentType = ContentType(<MediaType>::WOFF2)

Content-Type for WOFF2 : font / woff2

Methods from Deref<Target = MediaType>

fn top(&self) -> &UncasedStr

Returns the top-level type for this media type. The return type, UncasedStr, has caseless equality comparison and hashing.

Example

use rocket::http::MediaType;

let plain = MediaType::Plain;
assert_eq!(plain.top(), "text");
assert_eq!(plain.top(), "TEXT");
assert_eq!(plain.top(), "Text");

fn sub(&self) -> &UncasedStr

Returns the subtype for this media type. The return type, UncasedStr, has caseless equality comparison and hashing.

Example

use rocket::http::MediaType;

let plain = MediaType::Plain;
assert_eq!(plain.sub(), "plain");
assert_eq!(plain.sub(), "PlaIN");
assert_eq!(plain.sub(), "pLaIn");

fn specificity(&self) -> u8

Returns a u8 representing how specific the top-level type and subtype of this media type are.

The return value is either 0, 1, or 2, where 2 is the most specific. A 0 is returned when both the top and sublevel types are *. A 1 is returned when only one of the top or sublevel types is *, and a 2 is returned when neither the top or sublevel types are *.

Example

use rocket::http::MediaType;

let mt = MediaType::Plain;
assert_eq!(mt.specificity(), 2);

let mt = MediaType::new("text", "*");
assert_eq!(mt.specificity(), 1);

let mt = MediaType::Any;
assert_eq!(mt.specificity(), 0);

fn exact_eq(&self, other: &MediaType) -> bool

Compares self with other and returns true if self and other are exactly equal to eachother, including with respect to their parameters.

This is different from the PartialEq implementation in that it considers parameters. If PartialEq returns false, this function is guaranteed to return false. Similarly, if this function returns true, PartialEq is guaranteed to return true. However, if PartialEq returns true, this function may or may not return true.

Example

use rocket::http::MediaType;

let plain = MediaType::Plain;
let plain2 = MediaType::with_params("text", "plain", ("charset", "utf-8"));
let just_plain = MediaType::new("text", "plain");

// The `PartialEq` implementation doesn't consider parameters.
assert!(plain == just_plain);
assert!(just_plain == plain2);
assert!(plain == plain2);

// While `exact_eq` does.
assert!(!plain.exact_eq(&just_plain));
assert!(!plain2.exact_eq(&just_plain));
assert!(plain.exact_eq(&plain2));

fn params<'a>(&'a self) -> impl Iterator<Item = (&'a str, &'a str)> + 'a

Returns an iterator over the (key, value) pairs of the media type's parameter list. The iterator will be empty if the media type has no parameters.

Example

The MediaType::Plain type has one parameter: charset=utf-8:

use rocket::http::MediaType;

let plain = MediaType::Plain;
let plain_params: Vec<_> = plain.params().collect();
assert_eq!(plain_params, vec![("charset", "utf-8")]);

The MediaType::PNG type has no parameters:

use rocket::http::MediaType;

let png = MediaType::PNG;
assert_eq!(png.params().count(), 0);

const Any: MediaType

fn is_any(&self) -> bool

Returns true if self is the media type for any media type , without considering parameters.

const HTML: MediaType

fn is_html(&self) -> bool

Returns true if self is the media type for HTML , without considering parameters.

const Plain: MediaType

fn is_plain(&self) -> bool

Returns true if self is the media type for plain text , without considering parameters.

const JSON: MediaType

fn is_json(&self) -> bool

Returns true if self is the media type for JSON , without considering parameters.

const MsgPack: MediaType

fn is_msgpack(&self) -> bool

Returns true if self is the media type for MessagePack , without considering parameters.

const Form: MediaType

fn is_form(&self) -> bool

Returns true if self is the media type for forms , without considering parameters.

const JavaScript: MediaType

fn is_javascript(&self) -> bool

Returns true if self is the media type for JavaScript , without considering parameters.

const CSS: MediaType

fn is_css(&self) -> bool

Returns true if self is the media type for CSS , without considering parameters.

const FormData: MediaType

fn is_form_data(&self) -> bool

Returns true if self is the media type for multipart form data , without considering parameters.

const XML: MediaType

fn is_xml(&self) -> bool

Returns true if self is the media type for XML , without considering parameters.

const CSV: MediaType

fn is_csv(&self) -> bool

Returns true if self is the media type for CSV , without considering parameters.

const PNG: MediaType

fn is_png(&self) -> bool

Returns true if self is the media type for PNG , without considering parameters.

const GIF: MediaType

fn is_gif(&self) -> bool

Returns true if self is the media type for GIF , without considering parameters.

const BMP: MediaType

fn is_bmp(&self) -> bool

Returns true if self is the media type for BMP , without considering parameters.

const JPEG: MediaType

fn is_jpeg(&self) -> bool

Returns true if self is the media type for JPEG , without considering parameters.

const WEBP: MediaType

fn is_webp(&self) -> bool

Returns true if self is the media type for WEBP , without considering parameters.

const SVG: MediaType

fn is_svg(&self) -> bool

Returns true if self is the media type for SVG , without considering parameters.

const PDF: MediaType

fn is_pdf(&self) -> bool

Returns true if self is the media type for PDF , without considering parameters.

const TTF: MediaType

fn is_ttf(&self) -> bool

Returns true if self is the media type for TTF , without considering parameters.

const OTF: MediaType

fn is_otf(&self) -> bool

Returns true if self is the media type for OTF , without considering parameters.

const WOFF: MediaType

fn is_woff(&self) -> bool

Returns true if self is the media type for WOFF , without considering parameters.

const WOFF2: MediaType

fn is_woff2(&self) -> bool

Returns true if self is the media type for WOFF2 , without considering parameters.

fn is_known(&self) -> bool

Returns true if this MediaType is known to Rocket, that is, there is an associated constant for self.

Trait Implementations

impl Debug for ContentType

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for ContentType

fn clone(&self) -> ContentType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for ContentType

fn eq(&self, __arg_0: &ContentType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &ContentType) -> bool

This method tests for !=.

impl Hash for ContentType

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Default for ContentType

fn default() -> ContentType

Returns a ContentType of Any, or */*.

impl Deref for ContentType

type Target = MediaType

The resulting type after dereferencing

fn deref(&self) -> &MediaType

The method called to dereference a value

impl FromStr for ContentType

type Err = String

The associated error which can be returned from parsing.

fn from_str(raw: &str) -> Result<ContentType, String>

Parses a ContentType from a given Content-Type header value.

Examples

Parsing an application/json:

use std::str::FromStr;
use rocket::http::ContentType;

let json = ContentType::from_str("application/json").unwrap();
assert!(json.is_known());
assert_eq!(json, ContentType::JSON);

Parsing a content type extension:

use std::str::FromStr;
use rocket::http::ContentType;

let custom = ContentType::from_str("application/x-custom").unwrap();
assert!(!custom.is_known());
assert_eq!(custom.top(), "application");
assert_eq!(custom.sub(), "x-custom");

Parsing an invalid Content-Type value:

use std::str::FromStr;
use rocket::http::ContentType;

let custom = ContentType::from_str("application//x-custom");
assert!(custom.is_err());

impl Display for ContentType

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

Formats the ContentType as an HTTP Content-Type value.

Example

use rocket::http::ContentType;

let ct = format!("{}", ContentType::JSON);
assert_eq!(ct, "application/json");

impl Into<Header<'static>> for ContentType

Creates a new Header with name Content-Type and the value set to the HTTP rendering of this Content-Type.

fn into(self) -> Header<'static>

Performs the conversion.

impl<'a, 'r> FromRequest<'a, 'r> for &'a ContentType

type Error = ()

The associated error to be returned if derivation fails.

fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error>

Derives an instance of Self from the incoming request metadata.