Struct jumpy::prelude::fluent::FluentMessage

pub struct FluentMessage<'m> {
    node: &'m Message<&'m str>,
}

FluentMessage is a basic translation unit of the Fluent system.

The instance of a message is returned from the FluentBundle::get_message method, for the lifetime of the FluentBundle instance.

Example

use fluent_bundle::{FluentResource, FluentBundle};

let source = r#"

hello-world = Hello World!

"#;

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("hello-world")
    .expect("Failed to retrieve a message.");

assert!(msg.value().is_some());

That value can be then passed to FluentBundle::format_pattern to be formatted within the context of a given FluentBundle instance.

Compound Message

A message may contain a value, but it can also contain a list of FluentAttribute elements.

If a message contains attributes, it is called a “compound” message.

In such case, the message contains a list of key-value attributes that represent different translation values associated with a single translation unit.

This is useful for scenarios where a FluentMessage is associated with a complex User Interface widget which has multiple attributes that need to be translated.

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

Fields

node: &'m Message<&'m str>

Implementations

impl<'m> FluentMessage<'m>

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

Retrieves an option of a ast::Pattern.

Example

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

if let Some(value) = msg.value() {
    let mut err = vec![];
    assert_eq!(
        bundle.format_pattern(value, None, &mut err),
        "Hello World!"
    );
}

pub fn attributes(&self) -> impl Iterator<Item = FluentAttribute<'m>>

An iterator over FluentAttribute elements.

Example

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

let mut err = vec![];

for attr in msg.attributes() {
    let _ = bundle.format_pattern(attr.value(), None, &mut err);
}

pub fn get_attribute(&self, key: &str) -> Option<FluentAttribute<'m>>

Retrieve a single FluentAttribute element.

Example

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

let mut err = vec![];

if let Some(attr) = msg.get_attribute("label") {
    assert_eq!(
        bundle.format_pattern(attr.value(), None, &mut err),
        "This is a label"
    );
}

Trait Implementations

impl<'m> Debug for FluentMessage<'m>

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

Formats the value using the given formatter.

impl<'m> From<&'m Message<&'m str>> for FluentMessage<'m>

fn from(msg: &'m Message<&'m str>) -> FluentMessage<'m>

Converts to this type from the input type.

impl<'m> PartialEq for FluentMessage<'m>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'m> StructuralPartialEq for FluentMessage<'m>