Struct bevy_fluent::BundleAsset

pub struct BundleAsset(/* private fields */);

FluentBundle wrapper

Collection of FluentResources for a single locale

Methods from Deref<Target = FluentBundle<Arc<FluentResource>, IntlLangMemoizer>>

pub fn has_message(&self, id: &str) -> bool

where R: Borrow<FluentResource>,

Returns true if this bundle contains a message with the given id.

Examples

use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello = Hi!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");
let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);
bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");
assert_eq!(true, bundle.has_message("hello"));

pub fn get_message<'l>(&'l self, id: &str) -> Option<FluentMessage<'l>>

where R: Borrow<FluentResource>,

Retrieves a FluentMessage from a bundle.

Examples

use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello-world = Hello World!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");

let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);

bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");

let msg = bundle.get_message("hello-world");
assert_eq!(msg.is_some(), true);

pub fn write_pattern<'bundle, W>( &'bundle self, w: &mut W, pattern: &'bundle Pattern<&str>, args: Option<&'bundle FluentArgs<'_>>, errors: &mut Vec<FluentError> ) -> Result<(), Error>

where R: Borrow<FluentResource>, W: Write, M: MemoizerKind,

Writes a formatted pattern which comes from a FluentMessage.

Example

use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello-world = Hello World!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");

let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);

bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");

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

let pattern = msg.value()
    .expect("Missing Value.");
let mut errors = vec![];

let mut s = String::new();
bundle.write_pattern(&mut s, &pattern, None, &mut errors)
    .expect("Failed to write.");

assert_eq!(s, "Hello World!");

pub fn format_pattern<'bundle>( &'bundle self, pattern: &'bundle Pattern<&str>, args: Option<&'bundle FluentArgs<'_>>, errors: &mut Vec<FluentError> ) -> Cow<'bundle, str>

where R: Borrow<FluentResource>, M: MemoizerKind,

Formats a pattern which comes from a FluentMessage.

Example

use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello-world = Hello World!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");

let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);

bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");

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

let pattern = msg.value()
    .expect("Missing Value.");
let mut errors = vec![];

let result = bundle.format_pattern(&pattern, None, &mut errors);

assert_eq!(result, "Hello World!");

Trait Implementations

impl Clone for BundleAsset

fn clone(&self) -> BundleAsset

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for BundleAsset

type Target = FluentBundle<Arc<FluentResource>, IntlLangMemoizer>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl TypePath for BundleAsset

where Self: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl VisitAssetDependencies for BundleAsset

fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId))

impl Asset for BundleAsset