Struct rocket::http::MediaType [−][src]
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 MediaType
s. 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]
[−]
impl MediaType
pub fn new<T, S>(top: T, sub: S) -> MediaType where
T: Into<Cow<'static, str>>,
S: Into<Cow<'static, str>>,
[src]
[−]
pub fn new<T, S>(top: T, sub: S) -> MediaType where
T: Into<Cow<'static, str>>,
S: Into<Cow<'static, str>>,
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]
[−]
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)>,
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 from_extension(ext: &str) -> Option<MediaType>
[src]
[−]
pub fn from_extension(ext: &str) -> Option<MediaType>
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());
pub fn top(&self) -> &UncasedStr
[src]
[−]
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
[src]
[−]
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
[src]
[−]
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
[src]
[−]
pub 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));
pub fn params<'a>(
&'a self
) -> impl Iterator<Item = (&'a str, &'a str)> + 'a
[src]
[−]
pub 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);
pub const Any: MediaType
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 :
/
pub fn is_any(&self) -> bool
[src]
[−]
pub fn is_any(&self) -> bool
Returns true
if self
is the media type for
any media type
,
without considering parameters.
pub const Binary: MediaType
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
pub fn is_binary(&self) -> bool
[src]
[−]
pub fn is_binary(&self) -> bool
Returns true
if self
is the media type for
binary data
,
without considering parameters.
pub const HTML: MediaType
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
pub fn is_html(&self) -> bool
[src]
[−]
pub fn is_html(&self) -> bool
Returns true
if self
is the media type for
HTML
,
without considering parameters.
pub const Plain: MediaType
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
pub fn is_plain(&self) -> bool
[src]
[−]
pub fn is_plain(&self) -> bool
Returns true
if self
is the media type for
plain text
,
without considering parameters.
pub const JSON: MediaType
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
pub fn is_json(&self) -> bool
[src]
[−]
pub fn is_json(&self) -> bool
Returns true
if self
is the media type for
JSON
,
without considering parameters.
pub const MsgPack: MediaType
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
pub fn is_msgpack(&self) -> bool
[src]
[−]
pub fn is_msgpack(&self) -> bool
Returns true
if self
is the media type for
MessagePack
,
without considering parameters.
pub const Form: MediaType
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
pub fn is_form(&self) -> bool
[src]
[−]
pub fn is_form(&self) -> bool
Returns true
if self
is the media type for
forms
,
without considering parameters.
pub const JavaScript: MediaType
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
pub fn is_javascript(&self) -> bool
[src]
[−]
pub fn is_javascript(&self) -> bool
Returns true
if self
is the media type for
JavaScript
,
without considering parameters.
pub const CSS: MediaType
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
pub fn is_css(&self) -> bool
[src]
[−]
pub fn is_css(&self) -> bool
Returns true
if self
is the media type for
CSS
,
without considering parameters.
pub const FormData: MediaType
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
pub fn is_form_data(&self) -> bool
[src]
[−]
pub fn is_form_data(&self) -> bool
Returns true
if self
is the media type for
multipart form data
,
without considering parameters.
pub const XML: MediaType
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
pub fn is_xml(&self) -> bool
[src]
[−]
pub fn is_xml(&self) -> bool
Returns true
if self
is the media type for
XML
,
without considering parameters.
pub const CSV: MediaType
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
pub fn is_csv(&self) -> bool
[src]
[−]
pub fn is_csv(&self) -> bool
Returns true
if self
is the media type for
CSV
,
without considering parameters.
pub const PNG: MediaType
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
pub fn is_png(&self) -> bool
[src]
[−]
pub fn is_png(&self) -> bool
Returns true
if self
is the media type for
PNG
,
without considering parameters.
pub const GIF: MediaType
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
pub fn is_gif(&self) -> bool
[src]
[−]
pub fn is_gif(&self) -> bool
Returns true
if self
is the media type for
GIF
,
without considering parameters.
pub const BMP: MediaType
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
pub fn is_bmp(&self) -> bool
[src]
[−]
pub fn is_bmp(&self) -> bool
Returns true
if self
is the media type for
BMP
,
without considering parameters.
pub const JPEG: MediaType
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
pub fn is_jpeg(&self) -> bool
[src]
[−]
pub fn is_jpeg(&self) -> bool
Returns true
if self
is the media type for
JPEG
,
without considering parameters.
pub const WEBP: MediaType
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
pub fn is_webp(&self) -> bool
[src]
[−]
pub fn is_webp(&self) -> bool
Returns true
if self
is the media type for
WEBP
,
without considering parameters.
pub const SVG: MediaType
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
pub fn is_svg(&self) -> bool
[src]
[−]
pub fn is_svg(&self) -> bool
Returns true
if self
is the media type for
SVG
,
without considering parameters.
pub const WEBM: MediaType
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
pub fn is_webm(&self) -> bool
[src]
[−]
pub fn is_webm(&self) -> bool
Returns true
if self
is the media type for
WEBM
,
without considering parameters.
pub const OGG: MediaType
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
pub fn is_ogg(&self) -> bool
[src]
[−]
pub fn is_ogg(&self) -> bool
Returns true
if self
is the media type for
OGG
,
without considering parameters.
pub const WAV: MediaType
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
pub fn is_wav(&self) -> bool
[src]
[−]
pub fn is_wav(&self) -> bool
Returns true
if self
is the media type for
WAV
,
without considering parameters.
pub const PDF: MediaType
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
pub fn is_pdf(&self) -> bool
[src]
[−]
pub fn is_pdf(&self) -> bool
Returns true
if self
is the media type for
PDF
,
without considering parameters.
pub const TTF: MediaType
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
pub fn is_ttf(&self) -> bool
[src]
[−]
pub fn is_ttf(&self) -> bool
Returns true
if self
is the media type for
TTF
,
without considering parameters.
pub const OTF: MediaType
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
pub fn is_otf(&self) -> bool
[src]
[−]
pub fn is_otf(&self) -> bool
Returns true
if self
is the media type for
OTF
,
without considering parameters.
pub const WOFF: MediaType
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
pub fn is_woff(&self) -> bool
[src]
[−]
pub fn is_woff(&self) -> bool
Returns true
if self
is the media type for
WOFF
,
without considering parameters.
pub const WOFF2: MediaType
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
pub fn is_woff2(&self) -> bool
[src]
[−]
pub fn is_woff2(&self) -> bool
Returns true
if self
is the media type for
WOFF2
,
without considering parameters.
pub const WASM: MediaType
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
pub fn is_wasm(&self) -> bool
[src]
[−]
pub fn is_wasm(&self) -> bool
Returns true
if self
is the media type for
WASM
,
without considering parameters.
pub const JsonApi: MediaType
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
pub fn is_json_api(&self) -> bool
[src]
[−]
pub fn is_json_api(&self) -> bool
Returns true
if self
is the media type for
JSON API
,
without considering parameters.
pub fn is_known(&self) -> bool
[src]
[−]
pub 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 MediaType
[src]
[+]
impl Debug for MediaType
impl Clone for MediaType
[src]
[+]
impl Clone for MediaType
impl FromStr for MediaType
[src]
[+]
impl FromStr for MediaType
impl PartialEq for MediaType
[src]
[+]
impl PartialEq for MediaType
impl Hash for MediaType
[src]
[+]
impl Hash for MediaType
impl Display for MediaType
[src]
[+]
impl Display for MediaType
impl From<MediaType> for QMediaType
[src]
[+]
impl From<MediaType> for QMediaType