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

Implementations

impl ContentType

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

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

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
• “bytes” - ContentType::Bytes
• “html” - ContentType::HTML
• “plain” - ContentType::Plain
• “text” - ContentType::Text
• “json” - ContentType::JSON
• “msgpack” - ContentType::MsgPack
• “form” - ContentType::Form
• “js” - ContentType::JavaScript
• “css” - ContentType::CSS
• “multipart” - ContentType::FormData
• “xml” - ContentType::XML
• “pdf” - ContentType::PDF 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>

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
• avif - ContentType::AVIF
• 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>>,
    V: Into<Cow<'static, str>>,
    P: IntoCollection<(K, V)>,
    K: Into<Cow<'static, str>>, 

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

Borrows the inner MediaType of self.

Example

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

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

pub fn extension(&self) -> Option<&UncasedStr>

Returns the most common file extension associated with the Content-Type self if it is known. Otherwise, returns None . The currently recognized extensions are identical to those in ContentType::from_extension() with the most common extension being the first extension appearing in the list for a given Content-Type .

Example

Known extension:

use rocket::http::ContentType;

assert_eq!(ContentType::JSON.extension().unwrap(), "json");
assert_eq!(ContentType::JPEG.extension().unwrap(), "jpeg");
assert_eq!(ContentType::JPEG.extension().unwrap(), "JPEG");
assert_eq!(ContentType::PDF.extension().unwrap(), "pdf");

An unknown extension:

use rocket::http::ContentType;

let foo = ContentType::new("foo", "bar");
assert!(foo.extension().is_none());

pub const Any: ContentType

Content Type for any media type: */*.

pub const Binary: ContentType

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

pub const Bytes: ContentType

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

pub const HTML: ContentType

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

pub const Plain: ContentType

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

pub const Text: ContentType

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

pub const JSON: ContentType

Content Type for JSON: application/json.

pub const MsgPack: ContentType

Content Type for MsgPack: application/msgpack.

pub const Form: ContentType

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

pub const JavaScript: ContentType

Content Type for JavaScript: application/javascript.

pub const CSS: ContentType

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

pub const FormData: ContentType

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

pub const XML: ContentType

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

pub const CSV: ContentType

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

pub const PNG: ContentType

Content Type for PNG: image/png.

pub const GIF: ContentType

Content Type for GIF: image/gif.

pub const BMP: ContentType

Content Type for BMP: image/bmp.

pub const JPEG: ContentType

Content Type for JPEG: image/jpeg.

pub const WEBP: ContentType

Content Type for WEBP: image/webp.

pub const AVIF: ContentType

Content Type for AVIF: image/avif.

pub const SVG: ContentType

Content Type for SVG: image/svg+xml.

pub const Icon: ContentType

Content Type for Icon: image/x-icon.

pub const WEBM: ContentType

Content Type for WEBM: video/webm.

pub const WEBA: ContentType

Content Type for WEBM Audio: audio/webm.

pub const OGG: ContentType

Content Type for OGG Video: video/ogg.

pub const FLAC: ContentType

Content Type for FLAC: audio/flac.

pub const WAV: ContentType

Content Type for WAV: audio/wav.

pub const PDF: ContentType

Content Type for PDF: application/pdf.

pub const TTF: ContentType

Content Type for TTF: application/font-sfnt.

pub const OTF: ContentType

Content Type for OTF: application/font-sfnt.

pub const WOFF: ContentType

Content Type for WOFF: application/font-woff.

pub const WOFF2: ContentType

Content Type for WOFF2: font/woff2.

pub const JsonApi: ContentType

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

pub const WASM: ContentType

Content Type for WASM: application/wasm.

pub const TIFF: ContentType

Content Type for TIFF: image/tiff.

pub const AAC: ContentType

Content Type for AAC Audio: audio/aac.

pub const Calendar: ContentType

Content Type for iCalendar: text/calendar.

pub const MPEG: ContentType

Content Type for MPEG Video: video/mpeg.

pub const TAR: ContentType

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

pub const GZIP: ContentType

Content Type for gzipped binary: application/gzip.

pub const MOV: ContentType

Content Type for quicktime video: video/quicktime.

pub const MP4: ContentType

Content Type for MPEG4 Video: video/mp4.

pub const ZIP: ContentType

Content Type for ZIP archive: application/zip.

pub const EventStream: ContentType

Content Type for SSE stream: text/event-stream.

Methods from Deref<Target = MediaType>

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

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

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

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

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 self) -> impl Iterator<Item = (&'a UncasedStr, &'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 (key, val) = plain.params().next().unwrap();
assert_eq!(key, "charset");
assert_eq!(val, "utf-8");

The MediaType::PNG type has no parameters:

use rocket::http::MediaType;

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

pub fn param(&'a self, name: &str) -> Option<&'a str>

Returns the first parameter with name name, if there is any.

pub fn extension(&self) -> Option<&UncasedStr>

Returns the most common file extension associated with the Media-Type self if it is known. Otherwise, returns None . The currently recognized extensions are identical to those in MediaType::from_extension() with the most common extension being the first extension appearing in the list for a given Media-Type .

Example

Known extension:

use rocket::http::MediaType;

assert_eq!(MediaType::JSON.extension().unwrap(), "json");
assert_eq!(MediaType::JPEG.extension().unwrap(), "jpeg");
assert_eq!(MediaType::JPEG.extension().unwrap(), "JPEG");
assert_eq!(MediaType::PDF.extension().unwrap(), "pdf");

An unknown extension:

use rocket::http::MediaType;

let foo = MediaType::new("foo", "bar");
assert!(foo.extension().is_none());

pub const Any: MediaType

pub const Binary: MediaType

pub const Bytes: MediaType

pub const HTML: MediaType

pub const Plain: MediaType

pub const Text: MediaType

pub const JSON: MediaType

pub const MsgPack: MediaType

pub const Form: MediaType

pub const JavaScript: MediaType

pub const CSS: MediaType

pub const FormData: MediaType

pub const XML: MediaType

pub const CSV: MediaType

pub const PNG: MediaType

pub const GIF: MediaType

pub const BMP: MediaType

pub const JPEG: MediaType

pub const WEBP: MediaType

pub const AVIF: MediaType

pub const SVG: MediaType

pub const Icon: MediaType

pub const WEBM: MediaType

pub const WEBA: MediaType

pub const OGG: MediaType

pub const FLAC: MediaType

pub const WAV: MediaType

pub const PDF: MediaType

pub const TTF: MediaType

pub const OTF: MediaType

pub const WOFF: MediaType

pub const WOFF2: MediaType

pub const JsonApi: MediaType

pub const WASM: MediaType

pub const TIFF: MediaType

pub const AAC: MediaType

pub const Calendar: MediaType

pub const MPEG: MediaType

pub const TAR: MediaType

pub const GZIP: MediaType

pub const MOV: MediaType

pub const MP4: MediaType

pub const ZIP: MediaType

pub const EventStream: MediaType

pub fn is_known(&self) -> bool

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

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

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

pub fn is_bytes(&self) -> bool

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

pub fn is_html(&self) -> bool

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

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

pub fn is_text(&self) -> bool

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

pub fn is_json(&self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn is_avif(&self) -> bool

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

pub fn is_svg(&self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn is_event_stream(&self) -> bool

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

Trait Implementations

impl Clone for ContentType

pub fn clone(&self) -> ContentType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ContentType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for ContentType

pub fn default() -> ContentType

Returns a ContentType of Any, or */*.

impl Deref for ContentType

type Target = MediaType

The resulting type after dereferencing.

pub fn deref(&self) -> &MediaType

Dereferences the value.

impl Display for ContentType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

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 From<MediaType> for ContentType

pub fn from(media_type: MediaType) -> ContentType

Performs the conversion.

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

type Error = Infallible

The associated error to be returned if derivation fails.

fn from_request<'life0, 'async_trait>(
    request: &'r Request<'life0>
) -> Pin<Box<dyn Future<Output = Outcome<Self, Self::Error>> + Send + 'async_trait>> where
    'r: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Derives an instance of Self from the incoming request metadata.

impl FromStr for ContentType

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

type Err = String

The associated error which can be returned from parsing.

impl Hash for ContentType

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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 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.

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

Performs the conversion.

impl PartialEq<ContentType> for ContentType

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

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

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

This method tests for !=.

impl StructuralPartialEq for ContentType