[−][src]Struct unic_langid::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>
Methods
impl LanguageIdentifier
[src]
pub fn from_bytes(
v: &[u8]
) -> Result<LanguageIdentifier, LanguageIdentifierError>
[src]
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
[src]
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]>>
) -> LanguageIdentifier
[src]
language: Language,
script: Option<Script>,
region: Option<Region>,
variants: Option<Box<[Variant]>>
) -> 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>)
[src]
self
) -> (Language, Option<Script>, Option<Region>, Vec<Variant>)
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>,
[src]
&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
[src]
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])
[src]
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
[src]
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)
[src]
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
[src]
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
[src]
fn as_ref(&self) -> &LanguageIdentifier
[src]
impl Clone for LanguageIdentifier
[src]
fn clone(&self) -> LanguageIdentifier
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for LanguageIdentifier
[src]
impl Default for LanguageIdentifier
[src]
fn default() -> LanguageIdentifier
[src]
impl Display for LanguageIdentifier
[src]
impl Eq for LanguageIdentifier
[src]
impl FromStr for LanguageIdentifier
[src]
type Err = LanguageIdentifierError
The associated error which can be returned from parsing.
fn from_str(
source: &str
) -> Result<LanguageIdentifier, <LanguageIdentifier as FromStr>::Err>
[src]
source: &str
) -> Result<LanguageIdentifier, <LanguageIdentifier as FromStr>::Err>
impl Hash for LanguageIdentifier
[src]
fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
[src]
__H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Ord for LanguageIdentifier
[src]
fn cmp(&self, other: &LanguageIdentifier) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<'_> PartialEq<&'_ str> for LanguageIdentifier
[src]
impl PartialEq<LanguageIdentifier> for LanguageIdentifier
[src]
fn eq(&self, other: &LanguageIdentifier) -> bool
[src]
fn ne(&self, other: &LanguageIdentifier) -> bool
[src]
impl PartialOrd<LanguageIdentifier> for LanguageIdentifier
[src]
fn partial_cmp(&self, other: &LanguageIdentifier) -> Option<Ordering>
[src]
fn lt(&self, other: &LanguageIdentifier) -> bool
[src]
fn le(&self, other: &LanguageIdentifier) -> bool
[src]
fn gt(&self, other: &LanguageIdentifier) -> bool
[src]
fn ge(&self, other: &LanguageIdentifier) -> bool
[src]
impl StructuralEq for LanguageIdentifier
[src]
impl StructuralPartialEq for LanguageIdentifier
[src]
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> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[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> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
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.
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>,