Struct FluentAttribute

pub struct FluentAttribute<'m> { /* private fields */ }

FluentAttribute is a component of a compound FluentMessage.

It represents a key-value pair providing a translation of a component of a user interface widget localized by the given message.

Example

use fluent_bundle::{FluentResource, FluentBundle};

let source = r#"

confirm-modal = Are you sure?
    .confirm = Yes
    .cancel = No
    .tooltip = Closing the window will lose all unsaved data.

"#;

let resource = FluentResource::try_new(source.to_string())
    .expect("Failed to parse the resource.");

let mut bundle = FluentBundle::default();
bundle.add_resource(resource)
    .expect("Failed to add a resource.");

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

let mut err = vec![];

let attributes = msg.attributes().map(|attr| {
    bundle.format_pattern(attr.value(), None, &mut err)
}).collect::<Vec<_>>();

assert_eq!(attributes[0], "Yes");
assert_eq!(attributes[1], "No");
assert_eq!(attributes[2], "Closing the window will lose all unsaved data.");

Implementations

impl<'m> FluentAttribute<'m>

pub fn id(&self) -> &'m str

Retrieves an id of an attribute.

Example

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

let attr1 = msg.attributes().next()
    .expect("Failed to retrieve an attribute.");

assert_eq!(attr1.id(), "confirm");

pub fn value(&self) -> &'m Pattern<&'m str>

Retrieves an value of an attribute.

Example

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

let attr1 = msg.attributes().next()
    .expect("Failed to retrieve an attribute.");

let mut err = vec![];

let value = attr1.value();
assert_eq!(
    bundle.format_pattern(value, None, &mut err),
    "Yes"
);

Trait Implementations

impl<'m> Debug for FluentAttribute<'m>

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

Formats the value using the given formatter.

impl<'m> From<&'m Attribute<&'m str>> for FluentAttribute<'m>

fn from(attr: &'m Attribute<&'m str>) -> FluentAttribute<'m>

Converts to this type from the input type.

impl<'m> PartialEq for FluentAttribute<'m>

fn eq(&self, other: &FluentAttribute<'m>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'m> StructuralPartialEq for FluentAttribute<'m>