Struct rocket_http::MediaType[][src]

pub struct MediaType { /* fields omitted */ }
Expand description

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 MediaType::new(), MediaType::with_params(), and MediaType::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 MediaType::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.

Implementations

impl MediaType[src]

pub fn new<T, S>(top: T, sub: S) -> MediaType where
    T: Into<Cow<'static, str>>,
    S: Into<Cow<'static, str>>, 
[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");

pub fn with_params<T, S, K, V, P>(top: T, sub: S, ps: P) -> MediaType 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)>, 
[src]

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

pub fn parse_flexible(name: &str) -> Option<MediaType>[src]

Flexibly parses name into a MediaType . The parse is flexible because, in addition to stricly correct media types, it recognizes the following shorthands:

  • “any” - MediaType::Any
  • “binary” - MediaType::Binary
  • “html” - MediaType::HTML
  • “plain” - MediaType::Plain
  • “json” - MediaType::JSON
  • “msgpack” - MediaType::MsgPack
  • “form” - MediaType::Form
  • “js” - MediaType::JavaScript
  • “css” - MediaType::CSS
  • “multipart” - MediaType::FormData
  • “xml” - MediaType::XML For regular parsing, use the MediaType::from_str() method.

Example

Using a shorthand:

use rocket::http::MediaType;

let html = MediaType::parse_flexible("html");
assert_eq!(html, Some(MediaType::HTML));

let json = MediaType::parse_flexible("json");
assert_eq!(json, Some(MediaType::JSON));

Using the full media type:

use rocket::http::MediaType;

let html = MediaType::parse_flexible("text/html; charset=utf-8");
assert_eq!(html, Some(MediaType::HTML));

let json = MediaType::parse_flexible("application/json");
assert_eq!(json, Some(MediaType::JSON));

let custom = MediaType::parse_flexible("application/x+custom");
assert_eq!(custom, Some(MediaType::new("application", "x+custom")));

An unrecognized media type:

use rocket::http::MediaType;

let foo = MediaType::parse_flexible("foo");
assert_eq!(foo, None);

let bar = MediaType::parse_flexible("foo/bar/baz");
assert_eq!(bar, None);

pub fn from_extension(ext: &str) -> Option<MediaType>[src]

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 - MediaType::Plain
  • html - MediaType::HTML
  • htm - MediaType::HTML
  • xml - MediaType::XML
  • csv - MediaType::CSV
  • js - MediaType::JavaScript
  • css - MediaType::CSS
  • json - MediaType::JSON
  • png - MediaType::PNG
  • gif - MediaType::GIF
  • bmp - MediaType::BMP
  • jpeg - MediaType::JPEG
  • jpg - MediaType::JPEG
  • webp - MediaType::WEBP
  • svg - MediaType::SVG
  • ico - MediaType::Icon
  • flac - MediaType::FLAC
  • wav - MediaType::WAV
  • webm - MediaType::WEBM
  • weba - MediaType::WEBA
  • ogg - MediaType::OGG
  • ogv - MediaType::OGG
  • pdf - MediaType::PDF
  • ttf - MediaType::TTF
  • otf - MediaType::OTF
  • woff - MediaType::WOFF
  • woff2 - MediaType::WOFF2
  • mp4 - MediaType::MP4
  • mpeg4 - MediaType::MP4
  • wasm - MediaType::WASM
  • aac - MediaType::AAC
  • ics - MediaType::Calendar
  • bin - MediaType::Binary
  • mpg - MediaType::MPEG
  • mpeg - MediaType::MPEG
  • tar - MediaType::TAR
  • gz - MediaType::GZIP
  • tif - MediaType::TIFF
  • tiff - MediaType::TIFF
  • mov - MediaType::MOV
  • zip - MediaType::ZIP

This list 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());

pub fn top(&self) -> &UncasedStr[src]

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

pub fn sub(&self) -> &UncasedStr[src]

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

pub fn specificity(&self) -> u8[src]

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

pub fn exact_eq(&self, other: &MediaType) -> bool[src]

Compares self with other and returns true if self and other are exactly equal to each other, 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));

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

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

pub const Any: MediaType[src]

Media Type for any media type: */*.

pub const Binary: MediaType[src]

Media Type for binary data: application/octet-stream.

pub const HTML: MediaType[src]

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

pub const Plain: MediaType[src]

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

pub const JSON: MediaType[src]

Media Type for JSON: application/json.

pub const MsgPack: MediaType[src]

Media Type for MsgPack: application/msgpack.

pub const Form: MediaType[src]

Media Type for forms: application/x-www-form-urlencoded.

pub const JavaScript: MediaType[src]

Media Type for JavaScript: application/javascript.

pub const CSS: MediaType[src]

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

pub const FormData: MediaType[src]

Media Type for multipart form data: multipart/form-data.

pub const XML: MediaType[src]

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

pub const CSV: MediaType[src]

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

pub const PNG: MediaType[src]

Media Type for PNG: image/png.

pub const GIF: MediaType[src]

Media Type for GIF: image/gif.

pub const BMP: MediaType[src]

Media Type for BMP: image/bmp.

pub const JPEG: MediaType[src]

Media Type for JPEG: image/jpeg.

pub const WEBP: MediaType[src]

Media Type for WEBP: image/webp.

pub const SVG: MediaType[src]

Media Type for SVG: image/svg+xml.

pub const Icon: MediaType[src]

Media Type for Icon: image/x-icon.

pub const WEBM: MediaType[src]

Media Type for WEBM: video/webm.

pub const WEBA: MediaType[src]

Media Type for WEBM Audio: audio/webm.

pub const OGG: MediaType[src]

Media Type for OGG Video: video/ogg.

pub const FLAC: MediaType[src]

Media Type for FLAC: audio/flac.

pub const WAV: MediaType[src]

Media Type for WAV: audio/wav.

pub const PDF: MediaType[src]

Media Type for PDF: application/pdf.

pub const TTF: MediaType[src]

Media Type for TTF: application/font-sfnt.

pub const OTF: MediaType[src]

Media Type for OTF: application/font-sfnt.

pub const WOFF: MediaType[src]

Media Type for WOFF: application/font-woff.

pub const WOFF2: MediaType[src]

Media Type for WOFF2: font/woff2.

pub const JsonApi: MediaType[src]

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

pub const WASM: MediaType[src]

Media Type for WASM: application/wasm.

pub const TIFF: MediaType[src]

Media Type for TIFF: image/tiff.

pub const AAC: MediaType[src]

Media Type for AAC Audio: audio/aac.

pub const Calendar: MediaType[src]

Media Type for iCalendar: text/calendar.

pub const MPEG: MediaType[src]

Media Type for MPEG Video: video/mpeg.

pub const TAR: MediaType[src]

Media Type for tape archive: application/x-tar.

pub const GZIP: MediaType[src]

Media Type for gzipped binary: application/gzip.

pub const MOV: MediaType[src]

Media Type for quicktime video: video/quicktime.

pub const MP4: MediaType[src]

Media Type for MPEG4 Video: video/mp4.

pub const ZIP: MediaType[src]

Media Type for ZIP archive: application/zip.

pub fn is_known(&self) -> bool[src]

Returns true if this MediaType is known to Rocket. In other words, returns true if there is an associated constant for self.

pub fn is_any(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::Any .

pub fn is_binary(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::Binary .

pub fn is_html(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::HTML .

pub fn is_plain(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::Plain .

pub fn is_json(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::JSON .

pub fn is_msgpack(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::MsgPack .

pub fn is_form(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::Form .

pub fn is_javascript(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::JavaScript .

pub fn is_css(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::CSS .

pub fn is_form_data(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::FormData .

pub fn is_xml(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::XML .

pub fn is_csv(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::CSV .

pub fn is_png(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::PNG .

pub fn is_gif(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::GIF .

pub fn is_bmp(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::BMP .

pub fn is_jpeg(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::JPEG .

pub fn is_webp(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::WEBP .

pub fn is_svg(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::SVG .

pub fn is_icon(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::Icon .

pub fn is_webm(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::WEBM .

pub fn is_weba(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::WEBA .

pub fn is_ogg(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::OGG .

pub fn is_flac(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::FLAC .

pub fn is_wav(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::WAV .

pub fn is_pdf(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::PDF .

pub fn is_ttf(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::TTF .

pub fn is_otf(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::OTF .

pub fn is_woff(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::WOFF .

pub fn is_woff2(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::WOFF2 .

pub fn is_json_api(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::JsonApi .

pub fn is_wasm(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::WASM .

pub fn is_tiff(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::TIFF .

pub fn is_aac(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::AAC .

pub fn is_ical(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::Calendar .

pub fn is_mpeg(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::MPEG .

pub fn is_tar(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::TAR .

pub fn is_gzip(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::GZIP .

pub fn is_mov(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::MOV .

pub fn is_mp4(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::MP4 .

pub fn is_zip(&self) -> bool[src]

Returns true if the top-level and sublevel types of self are the same as those of MediaType::ZIP .

Trait Implementations

impl Clone for MediaType[src]

fn clone(&self) -> MediaType[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl Debug for MediaType[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result[src]

Formats the value using the given formatter. Read more

impl Display for MediaType[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result[src]

Formats the value using the given formatter. Read more

impl From<MediaType> for QMediaType[src]

fn from(media_type: MediaType) -> QMediaType[src]

Performs the conversion.

impl FromStr for MediaType[src]

type Err = String

The associated error which can be returned from parsing.

fn from_str(raw: &str) -> Result<MediaType, String>[src]

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

impl Hash for MediaType[src]

fn hash<H: Hasher>(&self, state: &mut H)[src]

Feeds this value into the given Hasher. Read more

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

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

impl PartialEq<MediaType> for MediaType[src]

fn eq(&self, other: &MediaType) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]

This method tests for !=.

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T, I> AsResult<T, I> for T where
    I: Input
[src]

pub fn as_result(self) -> Result<T, ParseErr<I>>[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> IntoCollection<T> for T[src]

pub fn into_collection<A>(Self) -> SmallVec<A> where
    A: Array<Item = T>, 
[src]

Converts self into a collection.

pub fn mapped<U, F, A>(Self, F) -> SmallVec<A> where
    A: Array<Item = U>,
    F: FnMut(T) -> U, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T where
    T: Display + ?Sized
[src]

pub default fn to_string(&self) -> String[src]

Converts the given value to a String. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.

impl<T> Typeable for T where
    T: Any

fn get_type(&self) -> TypeId

Get the TypeId of this object.