Struct rocket::http::MediaType[][src]

pub struct MediaType { /* fields omitted */ }
[]

An HTTP media type.

Usage

A MediaType should rarely be used directly. Instead, one is typically used indirectly via types like Accept and ContentType, which internally contain MediaTypes. Nonetheless, a MediaType can be created via the new, with_params, and from_extension methods. The preferred method, however, is to create a MediaType via an associated constant.

Example

A media type of application/json can be instantiated via the JSON constant:

use rocket::http::MediaType;

let json = MediaType::JSON;
assert_eq!(json.top(), "application");
assert_eq!(json.sub(), "json");

let json = MediaType::new("application", "json");
assert_eq!(MediaType::JSON, json);

Comparison and Hashing

The PartialEq and Hash implementations for MediaType do not take into account parameters. This means that a media type of text/html is equal to a media type of text/html; charset=utf-8, for instance. This is typically the comparison that is desired.

If an exact comparison is desired that takes into account parameters, the exact_eq method can be used.

Methods

impl MediaType
[src]
[]

[]

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

Example

Create a custom application/x-person media type:

use rocket::http::MediaType;

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

[]

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

Example

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

use rocket::http::MediaType;

let id = MediaType::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 media type:

use rocket::http::MediaType;

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

[]

Returns the Media-Type associated with the extension ext. Not all extensions are recognized. If an extensions is not recognized, None is returned. The currently recognized extensions are txt , html , htm , xml , csv , js , css , json , png , gif , bmp , jpeg , jpg , webp , svg , wav , webm , ogg , pdf , ttf , otf , woff , wasm , woff2 , and is likely to grow. Extensions are matched case-insensitively.

Example

Recognized media types:

use rocket::http::MediaType;

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

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

An unrecognized media type:

use rocket::http::MediaType;

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

[]

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");

[]

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");

[]

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);

[]

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));

[]

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);

Any: MediaType = MediaType{source: Source::Known("*/*"),
          top: IndexedStr::Concrete(Cow::Borrowed("*")),
          sub: IndexedStr::Concrete(Cow::Borrowed("*")),
          params: MediaParams::Static(&[]),}

Media type for any media type :

/

[]

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

Binary: MediaType = MediaType{source: Source::Known("application/octet-stream"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("octet-stream")),
          params: MediaParams::Static(&[]),}

Media type for binary data : application / octet-stream

[]

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

HTML: MediaType = MediaType{source: Source::Known("text/html; charset=utf-8"),
          top: IndexedStr::Concrete(Cow::Borrowed("text")),
          sub: IndexedStr::Concrete(Cow::Borrowed("html")),
          params:
              MediaParams::Static(&[(IndexedStr::Concrete(Cow::Borrowed("charset")),
                                     IndexedStr::Concrete(Cow::Borrowed("utf-8")))]),}

Media type for HTML : text / html ; charset = utf-8

[]

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

Plain: MediaType = MediaType{source: Source::Known("text/plain; charset=utf-8"),
          top: IndexedStr::Concrete(Cow::Borrowed("text")),
          sub: IndexedStr::Concrete(Cow::Borrowed("plain")),
          params:
              MediaParams::Static(&[(IndexedStr::Concrete(Cow::Borrowed("charset")),
                                     IndexedStr::Concrete(Cow::Borrowed("utf-8")))]),}

Media type for plain text : text / plain ; charset = utf-8

[]

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

JSON: MediaType = MediaType{source: Source::Known("application/json"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("json")),
          params: MediaParams::Static(&[]),}

Media type for JSON : application / json

[]

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

MsgPack: MediaType = MediaType{source: Source::Known("application/msgpack"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("msgpack")),
          params: MediaParams::Static(&[]),}

Media type for MessagePack : application / msgpack

[]

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

Form: MediaType = MediaType{source: Source::Known("application/x-www-form-urlencoded"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("x-www-form-urlencoded")),
          params: MediaParams::Static(&[]),}

Media type for forms : application / x-www-form-urlencoded

[]

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

JavaScript: MediaType = MediaType{source: Source::Known("application/javascript"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("javascript")),
          params: MediaParams::Static(&[]),}

Media type for JavaScript : application / javascript

[]

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

CSS: MediaType = MediaType{source: Source::Known("text/css; charset=utf-8"),
          top: IndexedStr::Concrete(Cow::Borrowed("text")),
          sub: IndexedStr::Concrete(Cow::Borrowed("css")),
          params:
              MediaParams::Static(&[(IndexedStr::Concrete(Cow::Borrowed("charset")),
                                     IndexedStr::Concrete(Cow::Borrowed("utf-8")))]),}

Media type for CSS : text / css ; charset = utf-8

[]

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

FormData: MediaType = MediaType{source: Source::Known("multipart/form-data"),
          top: IndexedStr::Concrete(Cow::Borrowed("multipart")),
          sub: IndexedStr::Concrete(Cow::Borrowed("form-data")),
          params: MediaParams::Static(&[]),}

Media type for multipart form data : multipart / form-data

[]

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

XML: MediaType = MediaType{source: Source::Known("text/xml; charset=utf-8"),
          top: IndexedStr::Concrete(Cow::Borrowed("text")),
          sub: IndexedStr::Concrete(Cow::Borrowed("xml")),
          params:
              MediaParams::Static(&[(IndexedStr::Concrete(Cow::Borrowed("charset")),
                                     IndexedStr::Concrete(Cow::Borrowed("utf-8")))]),}

Media type for XML : text / xml ; charset = utf-8

[]

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

CSV: MediaType = MediaType{source: Source::Known("text/csv; charset=utf-8"),
          top: IndexedStr::Concrete(Cow::Borrowed("text")),
          sub: IndexedStr::Concrete(Cow::Borrowed("csv")),
          params:
              MediaParams::Static(&[(IndexedStr::Concrete(Cow::Borrowed("charset")),
                                     IndexedStr::Concrete(Cow::Borrowed("utf-8")))]),}

Media type for CSV : text / csv ; charset = utf-8

[]

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

PNG: MediaType = MediaType{source: Source::Known("image/png"),
          top: IndexedStr::Concrete(Cow::Borrowed("image")),
          sub: IndexedStr::Concrete(Cow::Borrowed("png")),
          params: MediaParams::Static(&[]),}

Media type for PNG : image / png

[]

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

GIF: MediaType = MediaType{source: Source::Known("image/gif"),
          top: IndexedStr::Concrete(Cow::Borrowed("image")),
          sub: IndexedStr::Concrete(Cow::Borrowed("gif")),
          params: MediaParams::Static(&[]),}

Media type for GIF : image / gif

[]

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

BMP: MediaType = MediaType{source: Source::Known("image/bmp"),
          top: IndexedStr::Concrete(Cow::Borrowed("image")),
          sub: IndexedStr::Concrete(Cow::Borrowed("bmp")),
          params: MediaParams::Static(&[]),}

Media type for BMP : image / bmp

[]

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

JPEG: MediaType = MediaType{source: Source::Known("image/jpeg"),
          top: IndexedStr::Concrete(Cow::Borrowed("image")),
          sub: IndexedStr::Concrete(Cow::Borrowed("jpeg")),
          params: MediaParams::Static(&[]),}

Media type for JPEG : image / jpeg

[]

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

WEBP: MediaType = MediaType{source: Source::Known("image/webp"),
          top: IndexedStr::Concrete(Cow::Borrowed("image")),
          sub: IndexedStr::Concrete(Cow::Borrowed("webp")),
          params: MediaParams::Static(&[]),}

Media type for WEBP : image / webp

[]

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

SVG: MediaType = MediaType{source: Source::Known("image/svg+xml"),
          top: IndexedStr::Concrete(Cow::Borrowed("image")),
          sub: IndexedStr::Concrete(Cow::Borrowed("svg+xml")),
          params: MediaParams::Static(&[]),}

Media type for SVG : image / svg+xml

[]

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

WEBM: MediaType = MediaType{source: Source::Known("video/webm"),
          top: IndexedStr::Concrete(Cow::Borrowed("video")),
          sub: IndexedStr::Concrete(Cow::Borrowed("webm")),
          params: MediaParams::Static(&[]),}

Media type for WEBM : video / webm

[]

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

OGG: MediaType = MediaType{source: Source::Known("video/ogg"),
          top: IndexedStr::Concrete(Cow::Borrowed("video")),
          sub: IndexedStr::Concrete(Cow::Borrowed("ogg")),
          params: MediaParams::Static(&[]),}

Media type for OGG : video / ogg

[]

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

WAV: MediaType = MediaType{source: Source::Known("audio/wav"),
          top: IndexedStr::Concrete(Cow::Borrowed("audio")),
          sub: IndexedStr::Concrete(Cow::Borrowed("wav")),
          params: MediaParams::Static(&[]),}

Media type for WAV : audio / wav

[]

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

PDF: MediaType = MediaType{source: Source::Known("application/pdf"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("pdf")),
          params: MediaParams::Static(&[]),}

Media type for PDF : application / pdf

[]

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

TTF: MediaType = MediaType{source: Source::Known("application/font-sfnt"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("font-sfnt")),
          params: MediaParams::Static(&[]),}

Media type for TTF : application / font-sfnt

[]

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

OTF: MediaType = MediaType{source: Source::Known("application/font-sfnt"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("font-sfnt")),
          params: MediaParams::Static(&[]),}

Media type for OTF : application / font-sfnt

[]

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

WOFF: MediaType = MediaType{source: Source::Known("application/font-woff"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("font-woff")),
          params: MediaParams::Static(&[]),}

Media type for WOFF : application / font-woff

[]

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

WOFF2: MediaType = MediaType{source: Source::Known("font/woff2"),
          top: IndexedStr::Concrete(Cow::Borrowed("font")),
          sub: IndexedStr::Concrete(Cow::Borrowed("woff2")),
          params: MediaParams::Static(&[]),}

Media type for WOFF2 : font / woff2

[]

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

WASM: MediaType = MediaType{source: Source::Known("application/wasm"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("wasm")),
          params: MediaParams::Static(&[]),}

Media type for WASM : application / wasm

[]

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

JsonApi: MediaType = MediaType{source: Source::Known("application/vnd.api+json"),
          top: IndexedStr::Concrete(Cow::Borrowed("application")),
          sub: IndexedStr::Concrete(Cow::Borrowed("vnd.api+json")),
          params: MediaParams::Static(&[]),}

Media type for JSON API : application / vnd.api+json

[]

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

[]

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

Trait Implementations

impl Debug for MediaType
[src]
[+]

[]

Formats the value using the given formatter. Read more

impl Clone for MediaType
[src]
[+]

[]

Returns a copy of the value. Read more

[]

Performs copy-assignment from source. Read more

impl FromStr for MediaType
[src]
[+]

The associated error which can be returned from parsing.

[]

Parses a string s to return a value of this type. Read more

impl PartialEq for MediaType
[src]
[+]

[]

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

[]

This method tests for !=.

impl Hash for MediaType
[src]
[+]

[]

Feeds this value into the given [Hasher]. Read more

[]

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

impl Display for MediaType
[src]
[+]

[]

Formats the value using the given formatter. Read more

impl From<MediaType> for QMediaType
[src]
[+]

[]

Performs the conversion.

Auto Trait Implementations

impl Send for MediaType

impl Sync for MediaType