Struct rocket_accept_language::LanguageIdentifier [−]
LanguageIdentifier
is a core struct representing a Unicode Language Identifier.
Examples
use unic_langid_impl::LanguageIdentifier; let li: LanguageIdentifier = "en-US".parse() .expect("Failed to parse."); assert_eq!(li.language, "en"); assert_eq!(li.script, None); assert_eq!(li.region.as_ref().map(Into::into), Some("US")); assert_eq!(li.variants().len(), 0);
Parsing
Unicode recognizes three levels of standard conformance for any language identifier:
- well-formed - syntactically correct
- valid - well-formed and only uses registered language subtags, extensions, keywords, types…
- canonical - valid and no deprecated codes or structure.
At the moment parsing normalizes a well-formed language identifier converting
_
separators to -
and adjusting casing to conform to the Unicode standard.
Any bogus subtags will cause the parsing to fail with an error. No subtag validation is performed.
Examples:
use unic_langid_impl::LanguageIdentifier; let li: LanguageIdentifier = "eN_latn_Us-Valencia".parse() .expect("Failed to parse."); assert_eq!(li.language, "en"); assert_eq!(li.script.as_ref().map(Into::into), Some("Latn")); assert_eq!(li.region.as_ref().map(Into::into), Some("US")); assert_eq!(li.variants().map(|v| v.as_str()).collect::<Vec<_>>(), &["valencia"]);
Fields
language: Language
script: Option<Script>
region: Option<Region>
Implementations
impl LanguageIdentifier
pub fn from_bytes(
v: &[u8]
) -> Result<LanguageIdentifier, LanguageIdentifierError>
v: &[u8]
) -> Result<LanguageIdentifier, LanguageIdentifierError>
A constructor which takes a utf8 slice, parses it and
produces a well-formed LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier; let li = LanguageIdentifier::from_bytes("en-US".as_bytes()) .expect("Parsing failed."); assert_eq!(li.to_string(), "en-US");
pub fn from_parts(
language: Language,
script: Option<Script>,
region: Option<Region>,
variants: &[Variant]
) -> LanguageIdentifier
language: Language,
script: Option<Script>,
region: Option<Region>,
variants: &[Variant]
) -> LanguageIdentifier
A constructor which takes optional subtags as AsRef<[u8]>
, parses them and
produces a well-formed LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier; let li = LanguageIdentifier::from_parts( "fr".parse().expect("Parsing failed."), None, Some("CA".parse().expect("Parsing failed.")), &[] ); assert_eq!(li.to_string(), "fr-CA");
pub const fn from_raw_parts_unchecked(
language: Language,
script: Option<Script>,
region: Option<Region>,
variants: Option<Box<[Variant], Global>>
) -> LanguageIdentifier
language: Language,
script: Option<Script>,
region: Option<Region>,
variants: Option<Box<[Variant], Global>>
) -> LanguageIdentifier
Unchecked
This function accepts subtags expecting variants to be deduplicated and ordered.
pub fn into_parts(
self
) -> (Language, Option<Script>, Option<Region>, Vec<Variant, Global>)
self
) -> (Language, Option<Script>, Option<Region>, Vec<Variant, Global>)
Consumes LanguageIdentifier
and produces raw internal representations
of all subtags in form of u64
/u32
.
Primarily used for storing internal representation and restoring via
from_raw_parts_unchecked
.
Examples
use unic_langid_impl::LanguageIdentifier; use tinystr::{TinyStr8, TinyStr4}; let li: LanguageIdentifier = "en-US".parse() .expect("Parsing failed."); let (lang, script, region, variants) = li.into_parts(); // let li2 = LanguageIdentifier::from_raw_parts_unchecked( // lang.map(|l| unsafe { TinyStr8::new_unchecked(l) }), // script.map(|s| unsafe { TinyStr4::new_unchecked(s) }), // region.map(|r| unsafe { TinyStr4::new_unchecked(r) }), // variants.map(|v| v.into_iter().map(|v| unsafe { TinyStr8::new_unchecked(*v) }).collect()), //); //assert_eq!(li2.to_string(), "en-US");
pub fn matches<O>(
&self,
other: &O,
self_as_range: bool,
other_as_range: bool
) -> bool where
O: AsRef<LanguageIdentifier>,
&self,
other: &O,
self_as_range: bool,
other_as_range: bool
) -> bool where
O: AsRef<LanguageIdentifier>,
Compares a LanguageIdentifier
to another AsRef<LanguageIdentifier
allowing for either side to use the missing fields as wildcards.
This allows for matching between en
(treated as en-*-*-*
) and en-US
.
Examples
use unic_langid_impl::LanguageIdentifier; let li1: LanguageIdentifier = "en".parse() .expect("Parsing failed."); let li2: LanguageIdentifier = "en-US".parse() .expect("Parsing failed."); assert_ne!(li1, li2); // "en" != "en-US" assert_ne!(li1.to_string(), li2.to_string()); // "en" != "en-US" assert_eq!(li1.matches(&li2, false, false), false); // "en" != "en-US" assert_eq!(li1.matches(&li2, true, false), true); // "en-*-*-*" == "en-US" assert_eq!(li1.matches(&li2, false, true), false); // "en" != "en-*-US-*" assert_eq!(li1.matches(&li2, true, true), true); // "en-*-*-*" == "en-*-US-*"
pub fn variants(&self) -> impl ExactSizeIterator
Returns a vector of variants subtags of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier; let li1: LanguageIdentifier = "ca-ES-valencia".parse() .expect("Parsing failed."); assert_eq!(li1.variants().map(|v| v.as_str()).collect::<Vec<_>>(), &["valencia"]); let li2: LanguageIdentifier = "de".parse() .expect("Parsing failed."); assert_eq!(li2.variants().len(), 0);
pub fn set_variants(&mut self, variants: &[Variant])
Sets variant subtags of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier; let mut li: LanguageIdentifier = "ca-ES".parse() .expect("Parsing failed."); li.set_variants(&["valencia".parse().expect("Parsing failed.")]); assert_eq!(li.to_string(), "ca-ES-valencia");
pub fn has_variant(&self, variant: Variant) -> bool
Tests if a variant subtag is present in the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier; let mut li: LanguageIdentifier = "ca-ES-macos".parse() .expect("Parsing failed."); assert_eq!(li.has_variant("valencia".parse().unwrap()), false); assert_eq!(li.has_variant("macos".parse().unwrap()), true);
pub fn clear_variants(&mut self)
Clears variant subtags of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier; let mut li: LanguageIdentifier = "ca-ES-valencia".parse() .expect("Parsing failed."); li.clear_variants(); assert_eq!(li.to_string(), "ca-ES");
pub fn character_direction(&self) -> CharacterDirection
Returns character direction of the LanguageIdentifier
.
Examples
use unic_langid_impl::{LanguageIdentifier, CharacterDirection}; let li1: LanguageIdentifier = "es-AR".parse() .expect("Parsing failed."); let li2: LanguageIdentifier = "fa".parse() .expect("Parsing failed."); assert_eq!(li1.character_direction(), CharacterDirection::LTR); assert_eq!(li2.character_direction(), CharacterDirection::RTL);
Trait Implementations
impl AsRef<LanguageIdentifier> for LanguageIdentifier
pub fn as_ref(&self) -> &LanguageIdentifier
impl Clone for LanguageIdentifier
pub fn clone(&self) -> LanguageIdentifier
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for LanguageIdentifier
impl Default for LanguageIdentifier
pub fn default() -> LanguageIdentifier
impl Display for LanguageIdentifier
impl Eq for LanguageIdentifier
impl FromStr for LanguageIdentifier
type Err = LanguageIdentifierError
The associated error which can be returned from parsing.
pub fn from_str(
source: &str
) -> Result<LanguageIdentifier, <LanguageIdentifier as FromStr>::Err>
source: &str
) -> Result<LanguageIdentifier, <LanguageIdentifier as FromStr>::Err>
impl Hash for LanguageIdentifier
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 Ord for LanguageIdentifier
pub fn cmp(&self, other: &LanguageIdentifier) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<'_> PartialEq<&'_ str> for LanguageIdentifier
impl PartialEq<LanguageIdentifier> for LanguageIdentifier
pub fn eq(&self, other: &LanguageIdentifier) -> bool
pub fn ne(&self, other: &LanguageIdentifier) -> bool
impl PartialOrd<LanguageIdentifier> for LanguageIdentifier
pub fn partial_cmp(&self, other: &LanguageIdentifier) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl StructuralEq for LanguageIdentifier
impl StructuralPartialEq for LanguageIdentifier
Auto Trait Implementations
impl RefUnwindSafe for LanguageIdentifier
impl Send for LanguageIdentifier
impl Sync for LanguageIdentifier
impl Unpin for LanguageIdentifier
impl UnwindSafe for LanguageIdentifier
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T, I> AsResult<T, I> for T where
I: Input,
I: Input,
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<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
[src]
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
pub fn equivalent(&self, key: &K) -> bool
[src]
impl<T> From<T> for T
[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
A: Array<Item = U>,
F: FnMut(T) -> U,
A: Array<Item = U>,
F: FnMut(T) -> 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<T> Typeable for T where
T: Any,
T: Any,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,