Struct rocket::http::ContentType [−]
Representation of HTTP Content-Types.
Usage
ContentType
s 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>>,
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
- “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
- “pdf” -
ContentType::PDF
For regular parsing, use theContentType::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>>,
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 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 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
.
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 HTML: MediaType
pub const Plain: 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 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_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_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
.
Trait Implementations
impl Clone for ContentType
pub fn clone(&self) -> ContentType
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for ContentType
impl Default for ContentType
pub fn default() -> ContentType
Returns a ContentType of Any
, or */*
.
impl Deref for ContentType
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<'a, 'r> FromRequest<'a, 'r> for &'a ContentType
[src]
type Error = Infallible
The associated error to be returned if derivation fails.
fn from_request<'async_trait>(
request: &'a Request<'r>
) -> Pin<Box<dyn Future<Output = Outcome<Self, Self::Error>> + Send + 'async_trait>> where
'a: 'async_trait,
'r: 'async_trait,
Self: 'async_trait,
[src]
request: &'a Request<'r>
) -> Pin<Box<dyn Future<Output = Outcome<Self, Self::Error>> + Send + 'async_trait>> where
'a: 'async_trait,
'r: 'async_trait,
Self: 'async_trait,
impl FromStr for ContentType
type Err = String
The associated error which can be returned from parsing.
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());
impl Hash for ContentType
pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
__H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: 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.
impl PartialEq<ContentType> for ContentType
pub fn eq(&self, other: &ContentType) -> bool
pub fn ne(&self, other: &ContentType) -> bool
impl StructuralPartialEq for ContentType
Auto Trait Implementations
impl RefUnwindSafe for ContentType
impl Send for ContentType
impl Sync for ContentType
impl Unpin for ContentType
impl UnwindSafe for ContentType
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> IntoCollection<T> for T
pub fn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
A: Array<Item = T>,
pub fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
F: FnMut(T) -> U,
A: Array<Item = U>,
F: FnMut(T) -> U,
A: Array<Item = U>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
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]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
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]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,