[][src]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[src]

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

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

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

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

  • "any" - ContentType::Any
  • "binary" - ContentType::Binary
  • "html" - ContentType::HTML
  • "plain" - ContentType::Plain
  • "json" - ContentType::JSON
  • "msgpack" - ContentType::MsgPack
  • "form" - ContentType::Form
  • "js" - ContentType::JavaScript
  • "css" - ContentType::CSS
  • "multipart" - ContentType::FormData
  • "xml" - ContentType::XML

For regular parsing, use the ContentType::from_str() method.

Example

Using a shorthand:

use rocket::http::ContentType;

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

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

Using the full content-type:

use rocket::http::ContentType;

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

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

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

An unrecognized content-type:

use rocket::http::ContentType;

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

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

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

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

This list is likely to grow. Extensions are matched case-insensitively.

Example

Recognized content types:

use rocket::http::ContentType;

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

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

pub 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)>, 
[src]

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

pub fn media_type(&self) -> &MediaType[src]

Borrows the inner MediaType of self.

Example

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

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

pub const Any: ContentType[src]

Content Type for any media type: */*.

pub const Binary: ContentType[src]

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

pub const HTML: ContentType[src]

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

pub const Plain: ContentType[src]

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

pub const JSON: ContentType[src]

Content Type for JSON: application/json.

pub const MsgPack: ContentType[src]

Content Type for MsgPack: application/msgpack.

pub const Form: ContentType[src]

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

pub const JavaScript: ContentType[src]

Content Type for JavaScript: application/javascript.

pub const CSS: ContentType[src]

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

pub const FormData: ContentType[src]

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

pub const XML: ContentType[src]

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

pub const CSV: ContentType[src]

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

pub const PNG: ContentType[src]

Content Type for PNG: image/png.

pub const GIF: ContentType[src]

Content Type for GIF: image/gif.

pub const BMP: ContentType[src]

Content Type for BMP: image/bmp.

pub const JPEG: ContentType[src]

Content Type for JPEG: image/jpeg.

pub const WEBP: ContentType[src]

Content Type for WEBP: image/webp.

pub const SVG: ContentType[src]

Content Type for SVG: image/svg+xml.

pub const Icon: ContentType[src]

Content Type for Icon: image/x-icon.

pub const WEBM: ContentType[src]

Content Type for WEBM: video/webm.

pub const WEBA: ContentType[src]

Content Type for WEBM Audio: audio/webm.

pub const OGG: ContentType[src]

Content Type for OGG Video: video/ogg.

pub const FLAC: ContentType[src]

Content Type for FLAC: audio/flac.

pub const WAV: ContentType[src]

Content Type for WAV: audio/wav.

pub const PDF: ContentType[src]

Content Type for PDF: application/pdf.

pub const TTF: ContentType[src]

Content Type for TTF: application/font-sfnt.

pub const OTF: ContentType[src]

Content Type for OTF: application/font-sfnt.

pub const WOFF: ContentType[src]

Content Type for WOFF: application/font-woff.

pub const WOFF2: ContentType[src]

Content Type for WOFF2: font/woff2.

pub const JsonApi: ContentType[src]

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

pub const WASM: ContentType[src]

Content Type for WASM: application/wasm.

pub const TIFF: ContentType[src]

Content Type for TIFF: image/tiff.

pub const AAC: ContentType[src]

Content Type for AAC Audio: audio/aac.

pub const Calendar: ContentType[src]

Content Type for iCalendar: text/calendar.

pub const MPEG: ContentType[src]

Content Type for MPEG Video: video/mpeg.

pub const TAR: ContentType[src]

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

pub const GZIP: ContentType[src]

Content Type for gzipped binary: application/gzip.

pub const MOV: ContentType[src]

Content Type for quicktime video: video/quicktime.

pub const MP4: ContentType[src]

Content Type for MPEG4 Video: video/mp4.

pub const ZIP: ContentType[src]

Content Type for ZIP archive: application/zip.

Methods from Deref<Target = MediaType>

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]

pub const Binary: MediaType[src]

pub const HTML: MediaType[src]

pub const Plain: MediaType[src]

pub const JSON: MediaType[src]

pub const MsgPack: MediaType[src]

pub const Form: MediaType[src]

pub const JavaScript: MediaType[src]

pub const CSS: MediaType[src]

pub const FormData: MediaType[src]

pub const XML: MediaType[src]

pub const CSV: MediaType[src]

pub const PNG: MediaType[src]

pub const GIF: MediaType[src]

pub const BMP: MediaType[src]

pub const JPEG: MediaType[src]

pub const WEBP: MediaType[src]

pub const SVG: MediaType[src]

pub const Icon: MediaType[src]

pub const WEBM: MediaType[src]

pub const WEBA: MediaType[src]

pub const OGG: MediaType[src]

pub const FLAC: MediaType[src]

pub const WAV: MediaType[src]

pub const PDF: MediaType[src]

pub const TTF: MediaType[src]

pub const OTF: MediaType[src]

pub const WOFF: MediaType[src]

pub const WOFF2: MediaType[src]

pub const JsonApi: MediaType[src]

pub const WASM: MediaType[src]

pub const TIFF: MediaType[src]

pub const AAC: MediaType[src]

pub const Calendar: MediaType[src]

pub const MPEG: MediaType[src]

pub const TAR: MediaType[src]

pub const GZIP: MediaType[src]

pub const MOV: MediaType[src]

pub const MP4: MediaType[src]

pub const ZIP: MediaType[src]

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 ContentType[src]

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

Performs copy-assignment from source. Read more

impl Into<Header<'static>> for ContentType[src]

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

impl Default for ContentType[src]

fn default() -> ContentType[src]

Returns a ContentType of Any, or */*.

impl PartialEq<ContentType> for ContentType[src]

impl Hash for ContentType[src]

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 Debug for ContentType[src]

impl Display for ContentType[src]

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

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 Deref for ContentType[src]

type Target = MediaType

The resulting type after dereferencing.

impl FromStr for ContentType[src]

type Err = String

The associated error which can be returned from parsing.

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

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

Auto Trait Implementations

Blanket Implementations

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

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

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

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

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

type Owned = T

The resulting type after obtaining ownership.

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.

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.

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

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

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

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

impl<T> Typeable for T where
    T: Any

fn get_type(&self) -> TypeId

Get the TypeId of this object.