Struct fluent_bundle::FluentArgs

pub struct FluentArgs<'args>(/* private fields */);

Fluent messages can use arguments in order to programmatically add values to a translated string. For instance, in a localized application you may wish to display a user’s email count. This could be done with the following message.

msg-key = Hello, { $user }. You have { $emailCount } messages.

Here $user and $emailCount are the arguments, which can be filled with values.

The FluentArgs struct is the map from the argument name (for example $user) to the argument value (for example “John”.) The logic to apply these to write these to messages is elsewhere, this struct just stores the value.

Example

use fluent_bundle::{FluentArgs, FluentBundle, FluentResource};

let mut args = FluentArgs::new();
args.set("user", "John");
args.set("emailCount", 5);

let res = FluentResource::try_new(r#"

msg-key = Hello, { $user }. You have { $emailCount } messages.

"#.to_string())
    .expect("Failed to parse FTL.");

let mut bundle = FluentBundle::default();

// For this example, we'll turn on BiDi support.
// Please, be careful when doing it, it's a risky move.
bundle.set_use_isolating(false);

bundle.add_resource(res)
    .expect("Failed to add a resource.");

let mut err = vec![];

let msg = bundle.get_message("msg-key")
    .expect("Failed to retrieve a message.");
let value = msg.value()
    .expect("Failed to retrieve a value.");

assert_eq!(
    bundle.format_pattern(value, Some(&args), &mut err),
    "Hello, John. You have 5 messages."
);

Implementations

impl<'args> FluentArgs<'args>

pub fn new() -> Self

Creates a new empty argument map.

pub fn with_capacity(capacity: usize) -> Self

Pre-allocates capacity for arguments.

pub fn get<K>(&self, key: K) -> Option<&FluentValue<'args>>

where K: Into<Cow<'args, str>>,

Gets the FluentValue at the key if it exists.

pub fn set<K, V>(&mut self, key: K, value: V)

where K: Into<Cow<'args, str>>, V: Into<FluentValue<'args>>,

Sets the key value pair.

pub fn iter(&self) -> impl Iterator<Item = (&str, &FluentValue<'_>)>

Iterate over a tuple of the key an FluentValue.

Trait Implementations

impl<'args> Debug for FluentArgs<'args>

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

Formats the value using the given formatter.

impl<'args> Default for FluentArgs<'args>

fn default() -> FluentArgs<'args>

Returns the “default value” for a type.

impl<'args, K, V> FromIterator<(K, V)> for FluentArgs<'args>

where K: Into<Cow<'args, str>>, V: Into<FluentValue<'args>>,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<'args> IntoIterator for FluentArgs<'args>

type Item = (Cow<'args, str>, FluentValue<'args>)

The type of the elements being iterated over.

type IntoIter = IntoIter<<FluentArgs<'args> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.