Struct FluentLanguageLoader 

pub struct FluentLanguageLoader { /* private fields */ }

LanguageLoader implementation for the fluent localization system. Also provides methods to access localizations which have been loaded.

⚠️ This API requires the following crate features to be activated: fluent-system.

Implementations

impl FluentLanguageLoader

pub fn new<S: Into<String>>( domain: S, fallback_language: LanguageIdentifier, ) -> Self

Create a new FluentLanguageLoader, which loads messages for the specified domain, and relies on the specified fallback_language for any messages that do not exist for the current language.

pub fn current_languages(&self) -> Vec<LanguageIdentifier>

The languages associated with each actual currently loaded language bundle.

pub fn get(&self, message_id: &str) -> String

Get a localized message referenced by the message_id.

pub fn get_args_concrete<'args>( &self, message_id: &str, args: HashMap<&'args str, FluentValue<'args>>, ) -> String

A non-generic version of FluentLanguageLoader::get_args().

pub fn get_args_fluent<'args>( &self, message_id: &str, args: Option<&'args FluentArgs<'args>>, ) -> String

A non-generic version of FluentLanguageLoader::get_args() accepting FluentArgs instead of a HashMap.

pub fn get_args<'a, S, V>(&self, id: &str, args: HashMap<S, V>) -> String

where S: Into<Cow<'a, str>> + Clone, V: Into<FluentValue<'a>> + Clone,

Get a localized message referenced by the message_id, and formatted with the specified args.

pub fn get_attr(&self, message_id: &str, attribute_id: &str) -> String

Get a localized attribute referenced by the message_id and attribute_id.

pub fn get_attr_args_concrete<'args>( &self, message_id: &str, attribute_id: &str, args: HashMap<&'args str, FluentValue<'args>>, ) -> String

A non-generic version of FluentLanguageLoader::get_attr_args().

pub fn get_attr_args_fluent<'args>( &self, message_id: &str, attribute_id: &str, args: Option<&'args FluentArgs<'args>>, ) -> String

A non-generic version of FluentLanguageLoader::get_attr_args() accepting FluentArgs instead of a HashMap.

pub fn get_attr_args<'a, S, V>( &self, message_id: &str, attribute_id: &str, args: HashMap<S, V>, ) -> String

where S: Into<Cow<'a, str>> + Clone, V: Into<FluentValue<'a>> + Clone,

Get a localized attribute referenced by the message_id and attribute_id, and formatted with the specified args.

pub fn has(&self, message_id: &str) -> bool

available in any of the languages currently loaded (including the fallback language).

pub fn has_attr(&self, message_id: &str, attribute_id: &str) -> bool

Determines if an attribute associated with the specified message_id is available in any of the currently loaded languages, including the fallback language.

Returns true if at least one available instance was found, false otherwise.

Note that this also returns false if the message_id could not be found; use FluentLanguageLoader::has() to determine if the message_id is available.

pub fn with_fluent_message<OUT, C>( &self, message_id: &str, closure: C, ) -> Option<OUT>

where C: Fn(FluentMessage<'_>) -> OUT,

Run the closure with the message that matches the specified message_id (if it is available in any of the languages currently loaded, including the fallback language). Returns Some of whatever whatever the closure returns, or None if no messages were found matching the message_id.

pub fn with_fluent_message_and_bundle<OUT, C>( &self, message_id: &str, closure: C, ) -> Option<OUT>

where C: Fn(FluentMessage<'_>, &FluentBundle<Arc<FluentResource>, IntlLangMemoizer>) -> OUT,

Searches for a message named message_id in all languages that are currently loaded, including the fallback language. If the message is found, invokes the closure with the:

0. message
1. the language-specific bundle that owns it.

Returns Some of whatever the closure returns, or None if no messages were found matching the message_id.

pub fn with_message_iter<OUT, C>( &self, language: &LanguageIdentifier, closure: C, ) -> OUT

where C: Fn(&mut dyn Iterator<Item = &Message<&str>>) -> OUT,

Runs the provided closure with an iterator over the messages available for the specified language. There may be duplicate messages when they are duplicated in resources applicable to the language. Returns the result of the closure.

pub fn set_use_isolating(&self, value: bool)

Set whether the underlying Fluent logic should insert Unicode Directionality Isolation Marks around placeables.

See [fluent::bundle::FluentBundleBase::set_use_isolating] for more information.

Note: This function will have no effect if LanguageLoader::load_languages has not been called first.

Default: true.

pub fn with_bundles_mut<F>(&self, f: F)

where F: Fn(&mut FluentBundle<Arc<FluentResource>, IntlLangMemoizer>),

Apply some configuration to each budle in this loader.

Note: This function will have no effect if LanguageLoader::load_languages has not been called first.

pub fn select_languages<LI: AsRef<LanguageIdentifier>>( &self, languages: &[LI], ) -> FluentLanguageLoader

Create a new loader with a subset of currently loaded languages. This is a rather cheap operation and does not require any extensive copy operations. Cheap does not mean free so you should not call this message repeatedly in order to translate multiple strings for the same language.

pub fn select_languages_negotiate<LI: AsRef<LanguageIdentifier>>( &self, languages: &[LI], strategy: NegotiationStrategy, ) -> FluentLanguageLoader

Select the requested languages from the currently loaded languages using the supplied NegotiationStrategy.

Trait Implementations

impl Debug for FluentLanguageLoader

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

Formats the value using the given formatter.

impl LanguageLoader for FluentLanguageLoader

fn fallback_language(&self) -> &LanguageIdentifier

The fallback language for the module this loader is responsible for.

fn domain(&self) -> &str

The domain for the translation that this loader is associated with.

fn language_file_name(&self) -> String

The language file name to use for this loader.

fn current_language(&self) -> LanguageIdentifier

Get the language which is currently selected for this loader.

fn load_languages<'a>( &self, i18n_assets: &dyn I18nAssets, language_ids: &[LanguageIdentifier], ) -> Result<(), I18nEmbedError>

Load the languages language_ids using the resources packaged in the i18n_assets in order of fallback preference. This also sets the LanguageLoader::current_language() to the first in the language_ids slice. You can use select() to determine which fallbacks are actually available for an arbitrary slice of preferences.

fn reload(&self, i18n_assets: &dyn I18nAssets) -> Result<(), I18nEmbedError>

Reload the currently loaded languages.

fn language_files<'a>( &self, language_id: &LanguageIdentifier, i18n_assets: &'a dyn I18nAssets, ) -> (String, Vec<Cow<'a, [u8]>>)

The computed path to the language files, and data contained within the files at that path itself if they exist. There can be multiple files at a given path, in order of preference from high to low.

fn available_languages( &self, i18n_assets: &dyn I18nAssets, ) -> Result<Vec<LanguageIdentifier>, I18nEmbedError>

Calculate the languages which are available to be loaded.

fn load_available_languages( &self, i18n_assets: &dyn I18nAssets, ) -> Result<(), I18nEmbedError>

Load all available languages with LanguageLoader::load_languages().

fn load_fallback_language( &self, i18n_assets: &dyn I18nAssets, ) -> Result<(), I18nEmbedError>

Load the LanguageLoader::fallback_language().