Struct gooey::fluent::fluent::FluentArgs

pub struct FluentArgs<'args>(_);

A map of arguments passed from the code to the localization to be used for message formatting.

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() -> FluentArgs<'args>

pub fn with_capacity(capacity: usize) -> FluentArgs<'args>

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

pub fn set<K, V>(&mut self, key: K, value: V) where
    K: Into<Cow<'args, str>>,
    V: Into<FluentValue<'args>>, 

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

Trait Implementations

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

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

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) -> FluentArgs<'args> 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, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <FluentArgs<'args> as IntoIterator>::IntoIter

Creates an iterator from a value.