Struct handlebars_fluent::loader::LanguageIdentifier
pub struct LanguageIdentifier { /* private fields */ }
Expand description
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(), 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(), Some("Latn"));
assert_eq!(li.region(), Some("US"));
assert_eq!(li.variants().collect::<Vec<_>>(), &["valencia"]);
Implementations§
§impl LanguageIdentifier
impl LanguageIdentifier
pub fn from_bytes(
v: &[u8]
) -> Result<LanguageIdentifier, LanguageIdentifierError>
pub fn from_bytes( 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<S>(
language: Option<S>,
script: Option<S>,
region: Option<S>,
variants: &[S]
) -> Result<LanguageIdentifier, LanguageIdentifierError>
pub fn from_parts<S>( language: Option<S>, script: Option<S>, region: Option<S>, variants: &[S] ) -> Result<LanguageIdentifier, LanguageIdentifierError>
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(Some("fr"), None, Some("CA"), &[])
.expect("Parsing failed.");
assert_eq!(li.to_string(), "fr-CA");
pub fn into_raw_parts(
self
) -> (Option<u64>, Option<u32>, Option<u32>, Option<Box<[u64]>>)
pub fn into_raw_parts( self ) -> (Option<u64>, Option<u32>, Option<u32>, Option<Box<[u64]>>)
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_raw_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 const fn from_raw_parts_unchecked(
language: Option<TinyStr8>,
script: Option<TinyStr4>,
region: Option<TinyStr4>,
variants: Option<Box<[TinyStr8]>>
) -> LanguageIdentifier
pub const fn from_raw_parts_unchecked( language: Option<TinyStr8>, script: Option<TinyStr4>, region: Option<TinyStr4>, variants: Option<Box<[TinyStr8]>> ) -> LanguageIdentifier
Consumes raw representation of subtags generating new LanguageIdentifier
without any checks.
Primarily used for restoring internal representation.
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_raw_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
) -> boolwhere
O: AsRef<LanguageIdentifier>,
pub fn matches<O>(
&self,
other: &O,
self_as_range: bool,
other_as_range: bool
) -> boolwhere
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 language(&self) -> &str
pub fn language(&self) -> &str
Returns the language subtag of the LanguageIdentifier
.
If the language is empty, "und"
is returned.
Examples
use unic_langid_impl::LanguageIdentifier;
let li1: LanguageIdentifier = "de-AT".parse()
.expect("Parsing failed.");
assert_eq!(li1.language(), "de");
let li2: LanguageIdentifier = "und-AT".parse()
.expect("Parsing failed.");
assert_eq!(li2.language(), "und");
pub fn set_language<S>(
&mut self,
language: S
) -> Result<(), LanguageIdentifierError>
pub fn set_language<S>( &mut self, language: S ) -> Result<(), LanguageIdentifierError>
Sets the language subtag of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier;
let mut li: LanguageIdentifier = "de-Latn-AT".parse()
.expect("Parsing failed.");
li.set_language("fr")
.expect("Parsing failed.");
assert_eq!(li.to_string(), "fr-Latn-AT");
pub fn clear_language(&mut self)
pub fn clear_language(&mut self)
Clears the language subtag of the LanguageIdentifier
.
An empty language subtag is serialized to und
.
Examples
use unic_langid_impl::LanguageIdentifier;
let mut li: LanguageIdentifier = "de-Latn-AT".parse()
.expect("Parsing failed.");
li.clear_language();
assert_eq!(li.to_string(), "und-Latn-AT");
pub fn script(&self) -> Option<&str>
pub fn script(&self) -> Option<&str>
Returns the script subtag of the LanguageIdentifier
, if set.
Examples
use unic_langid_impl::LanguageIdentifier;
let li1: LanguageIdentifier = "de-Latn-AT".parse()
.expect("Parsing failed.");
assert_eq!(li1.script(), Some("Latn"));
let li2: LanguageIdentifier = "de-AT".parse()
.expect("Parsing failed.");
assert_eq!(li2.script(), None);
pub fn set_script<S>(
&mut self,
script: S
) -> Result<(), LanguageIdentifierError>
pub fn set_script<S>( &mut self, script: S ) -> Result<(), LanguageIdentifierError>
Sets the script subtag of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier;
let mut li: LanguageIdentifier = "sr-Latn".parse()
.expect("Parsing failed.");
li.set_script("Cyrl")
.expect("Parsing failed.");
assert_eq!(li.to_string(), "sr-Cyrl");
pub fn clear_script(&mut self)
pub fn clear_script(&mut self)
Clears the script subtag of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier;
let mut li: LanguageIdentifier = "sr-Latn".parse()
.expect("Parsing failed.");
li.clear_script();
assert_eq!(li.to_string(), "sr");
pub fn region(&self) -> Option<&str>
pub fn region(&self) -> Option<&str>
Returns the region subtag of the LanguageIdentifier
, if set.
Examples
use unic_langid_impl::LanguageIdentifier;
let li1: LanguageIdentifier = "de-Latn-AT".parse()
.expect("Parsing failed.");
assert_eq!(li1.region(), Some("AT"));
let li2: LanguageIdentifier = "de".parse()
.expect("Parsing failed.");
assert_eq!(li2.region(), None);
pub fn set_region<S>(
&mut self,
region: S
) -> Result<(), LanguageIdentifierError>
pub fn set_region<S>( &mut self, region: S ) -> Result<(), LanguageIdentifierError>
Sets the region subtag of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier;
let mut li: LanguageIdentifier = "fr-FR".parse()
.expect("Parsing failed.");
li.set_region("CA")
.expect("Parsing failed.");
assert_eq!(li.to_string(), "fr-CA");
pub fn clear_region(&mut self)
pub fn clear_region(&mut self)
Clears the region subtag of the LanguageIdentifier
.
Examples
use unic_langid_impl::LanguageIdentifier;
let mut li: LanguageIdentifier = "fr-FR".parse()
.expect("Parsing failed.");
li.clear_region();
assert_eq!(li.to_string(), "fr");
pub fn variants(&self) -> impl ExactSizeIterator
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().collect::<Vec<_>>(), &["valencia"]);
let li2: LanguageIdentifier = "de".parse()
.expect("Parsing failed.");
assert_eq!(li2.variants().len(), 0);
pub fn set_variants<S>(
&mut self,
variants: impl IntoIterator<Item = S>
) -> Result<(), LanguageIdentifierError>
pub fn set_variants<S>( &mut self, variants: impl IntoIterator<Item = S> ) -> Result<(), LanguageIdentifierError>
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"])
.expect("Parsing failed.");
assert_eq!(li.to_string(), "ca-ES-valencia");
pub fn has_variant<S>(
&self,
variant: S
) -> Result<bool, LanguageIdentifierError>
pub fn has_variant<S>( &self, variant: S ) -> Result<bool, LanguageIdentifierError>
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"), Ok(false));
assert_eq!(li.has_variant("macos"), Ok(true));
pub fn clear_variants(&mut self)
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
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
impl AsRef<LanguageIdentifier> for LanguageIdentifier
§fn as_ref(&self) -> &LanguageIdentifier
fn as_ref(&self) -> &LanguageIdentifier
§impl Clone for LanguageIdentifier
impl Clone for LanguageIdentifier
§fn clone(&self) -> LanguageIdentifier
fn clone(&self) -> LanguageIdentifier
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more§impl Debug for LanguageIdentifier
impl Debug for LanguageIdentifier
§impl Default for LanguageIdentifier
impl Default for LanguageIdentifier
§fn default() -> LanguageIdentifier
fn default() -> LanguageIdentifier
§impl Display for LanguageIdentifier
impl Display for LanguageIdentifier
§impl FromStr for LanguageIdentifier
impl FromStr for LanguageIdentifier
§impl Hash for LanguageIdentifier
impl Hash for LanguageIdentifier
§impl Ord for LanguageIdentifier
impl Ord for LanguageIdentifier
§fn cmp(&self, other: &LanguageIdentifier) -> Ordering
fn cmp(&self, other: &LanguageIdentifier) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
§impl PartialEq for LanguageIdentifier
impl PartialEq for LanguageIdentifier
§fn eq(&self, other: &LanguageIdentifier) -> bool
fn eq(&self, other: &LanguageIdentifier) -> bool
self
and other
values to be equal, and is used
by ==
.§impl PartialOrd for LanguageIdentifier
impl PartialOrd for LanguageIdentifier
§fn partial_cmp(&self, other: &LanguageIdentifier) -> Option<Ordering>
fn partial_cmp(&self, other: &LanguageIdentifier) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read more