Struct icu_locale::LocaleDirectionality

pub struct LocaleDirectionality<Expander = LocaleExpander> { /* private fields */ }

Provides methods to determine the direction of a locale.

The Expander generic parameter wraps a LocaleExpander.

Examples

use icu::locale::{langid, Direction, LocaleDirectionality};

let ld = LocaleDirectionality::new();

assert_eq!(ld.get(&langid!("en")), Some(Direction::LeftToRight));

Implementations

impl LocaleDirectionality<LocaleExpander>

pub const fn new() -> Self

Creates a LocaleDirectionality from compiled data.

This includes limited likely subtags data, see LocaleExpander::new().

pub fn try_new_with_any_provider( provider: &(impl AnyProvider + ?Sized), ) -> Result<Self, DataError>

A version of Self::new that uses custom data provided by an AnyProvider.

📚 Help choosing a constructor

pub fn try_new_with_buffer_provider( provider: &(impl BufferProvider + ?Sized), ) -> Result<Self, DataError>

A version of Self::new that uses custom data provided by a BufferProvider.

✨ Enabled with the serde feature.

📚 Help choosing a constructor

pub fn try_new_unstable<P>( provider: &P, ) -> Result<LocaleDirectionality, DataError>

where P: DataProvider<ScriptDirectionV1Marker> + DataProvider<LikelySubtagsForLanguageV1Marker> + DataProvider<LikelySubtagsForScriptRegionV1Marker> + ?Sized,

A version of Self::new that uses custom data provided by a DataProvider.

📚 Help choosing a constructor

⚠️ The bounds on provider may change over time, including in SemVer minor releases.

impl<Expander: AsRef<LocaleExpander>> LocaleDirectionality<Expander>

pub const fn new_with_expander(expander: Expander) -> Self

Creates a LocaleDirectionality with a custom LocaleExpander and compiled data.

This allows using LocaleExpander::new_extended() with data for all locales.

Examples

use icu::locale::{
    langid, Direction, LocaleDirectionality, LocaleExpander,
};

let ld_default = LocaleDirectionality::new();

assert_eq!(ld_default.get(&langid!("jbn")), None);

let expander = LocaleExpander::new_extended();
let ld_extended = LocaleDirectionality::new_with_expander(expander);

assert_eq!(
    ld_extended.get(&langid!("jbn")),
    Some(Direction::RightToLeft)
);

pub fn try_new_with_expander_unstable<P>( provider: &P, expander: Expander, ) -> Result<Self, DataError>

where P: DataProvider<ScriptDirectionV1Marker> + ?Sized,

A version of Self::new_with_expander that uses custom data provided by a DataProvider.

📚 Help choosing a constructor

⚠️ The bounds on provider may change over time, including in SemVer minor releases.

pub fn get(&self, langid: &LanguageIdentifier) -> Option<Direction>

Returns the script direction of the given locale.

Note that the direction is a property of the script of a locale, not of the language. As such, when given a locale without an associated script tag (i.e., locale!("en") vs. locale!("en-Latn")), this method first tries to infer the script using the language and region before returning its direction.

If you already have a script struct and want to get its direction, you should use Locale::from(Some(my_script)) and call this method.

This method will return None if either a locale’s script cannot be determined, or there is no information for the script.

Examples

Using an existing locale:

use icu::locale::{langid, Direction, LocaleDirectionality};

let ld = LocaleDirectionality::new();

assert_eq!(ld.get(&langid!("en-US")), Some(Direction::LeftToRight));

assert_eq!(ld.get(&langid!("ar")), Some(Direction::RightToLeft));

assert_eq!(ld.get(&langid!("en-Arab")), Some(Direction::RightToLeft));

assert_eq!(ld.get(&langid!("foo")), None);

Using a script directly:

use icu::locale::subtags::script;
use icu::locale::{LanguageIdentifier, Direction, LocaleDirectionality};

let ld = LocaleDirectionality::new();

assert_eq!(
    ld.get(&LanguageIdentifier::from(Some(script!("Latn")))),
    Some(Direction::LeftToRight)
);

pub fn is_right_to_left(&self, langid: &LanguageIdentifier) -> bool

Returns whether the given locale is right-to-left.

Note that if this method returns false, the locale is either left-to-right or the LocaleDirectionality does not include data for the locale. You should use LocaleDirectionality::get if you need to differentiate between these cases.

See LocaleDirectionality::get for more information.

pub fn is_left_to_right(&self, langid: &LanguageIdentifier) -> bool

Returns whether the given locale is left-to-right.

Note that if this method returns false, the locale is either right-to-left or the LocaleDirectionality does not include data for the locale. You should use LocaleDirectionality::get if you need to differentiate between these cases.

See LocaleDirectionality::get for more information.

Trait Implementations

impl<Expander: Debug> Debug for LocaleDirectionality<Expander>

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

Formats the value using the given formatter.

impl Default for LocaleDirectionality<LocaleExpander>

fn default() -> Self

Returns the “default value” for a type.