Struct MediaType

pub struct MediaType<'a> {
    pub ty: Name<'a>,
    pub subty: Name<'a>,
    pub suffix: Option<Name<'a>>,
    pub params: Cow<'a, [(Name<'a>, Value<'a>)]>,
}

A borrowed media type.

use mediatype::{names::*, MediaType, Value, WriteParams};

let mut multipart = MediaType::new(MULTIPART, FORM_DATA);

let boundary = Value::new("dyEV84n7XNJ").unwrap();
multipart.set_param(BOUNDARY, boundary);
assert_eq!(
    multipart.to_string(),
    "multipart/form-data; boundary=dyEV84n7XNJ"
);

multipart.subty = RELATED;
assert_eq!(
    multipart.to_string(),
    "multipart/related; boundary=dyEV84n7XNJ"
);

const IMAGE_SVG: MediaType = MediaType::from_parts(IMAGE, SVG, Some(XML), &[]);
let svg = MediaType::parse("IMAGE/SVG+XML").unwrap();
assert_eq!(svg, IMAGE_SVG);

Fields

ty: Name<'a>

Top-level type.

subty: Name<'a>

Subtype.

suffix: Option<Name<'a>>

Optional suffix.

params: Cow<'a, [(Name<'a>, Value<'a>)]>

Parameters.

Implementations

impl<'a> MediaType<'a>

pub const fn new(ty: Name<'a>, subty: Name<'a>) -> Self

Constructs a MediaType from a top-level type and a subtype.

const IMAGE_PNG: MediaType = MediaType::new(IMAGE, PNG);
assert_eq!(IMAGE_PNG, MediaType::parse("image/png").unwrap());

pub const fn from_parts( ty: Name<'a>, subty: Name<'a>, suffix: Option<Name<'a>>, params: &'a [(Name<'a>, Value<'a>)], ) -> Self

Constructs a MediaType with an optional suffix and parameters.

const IMAGE_SVG: MediaType = MediaType::from_parts(IMAGE, SVG, Some(XML), &[(CHARSET, UTF_8)]);
assert_eq!(
    IMAGE_SVG,
    MediaType::parse("image/svg+xml; charset=UTF-8").unwrap()
);

pub fn parse<'s: 'a>(s: &'s str) -> Result<Self, MediaTypeError>

Constructs a MediaType from str without copying the string.

Errors

Returns an error if the string fails to be parsed.

pub const fn essence(&self) -> MediaType<'_>

Returns a MediaType without parameters.

const IMAGE_SVG: MediaType = MediaType::from_parts(IMAGE, SVG, Some(XML), &[(CHARSET, UTF_8)]);
assert_eq!(
    IMAGE_SVG.essence(),
    MediaType::parse("image/svg+xml").unwrap()
);

Trait Implementations

impl<'a> Clone for MediaType<'a>

fn clone(&self) -> MediaType<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for MediaType<'a>

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

Formats the value using the given formatter.

impl<'a> Display for MediaType<'a>

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

Formats the value using the given formatter.

impl From<&MediaType<'_>> for MediaTypeBuf

fn from(t: &MediaType<'_>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a MediaTypeBuf> for MediaType<'a>

fn from(t: &'a MediaTypeBuf) -> Self

Converts to this type from the input type.

impl From<MediaType<'_>> for MediaTypeBuf

fn from(t: MediaType<'_>) -> Self

Converts to this type from the input type.

impl<'a> Hash for MediaType<'a>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<&MediaType<'_>> for MediaTypeBuf

fn eq(&self, other: &&MediaType<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<&MediaTypeBuf> for MediaType<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<MediaType<'_>> for &MediaTypeBuf

fn eq(&self, other: &MediaType<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<MediaType<'_>> for MediaTypeBuf

fn eq(&self, other: &MediaType<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<MediaType<'b>> for MediaType<'a>

fn eq(&self, other: &MediaType<'b>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<MediaTypeBuf> for MediaType<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> ReadParams for MediaType<'a>

fn params(&self) -> Params<'_>

Returns the parameters.

fn get_param(&self, name: Name<'_>) -> Option<Value<'_>>

Gets the parameter value by its name.

impl<'a> WriteParams<'a> for MediaType<'a>

fn set_param<'n: 'a, 'v: 'a>(&mut self, name: Name<'n>, value: Value<'v>)

Sets a parameter value.

fn remove_params(&mut self, name: Name<'_>)

Removes all parameters with the name.

fn clear_params(&mut self)

Removes all parameters.

impl<'a> Eq for MediaType<'a>