Struct LocaleFallbackProvider

Source

pub struct LocaleFallbackProvider<P> {
    inner: P,
    fallbacker: LocaleFallbacker,
}

Expand description

A data provider wrapper that performs locale fallback. This enables arbitrary locales to be handled at runtime.

§Examples

use icu_locale::langid;
use icu_provider::hello_world::*;
use icu_provider::prelude::*;
use icu_provider_adapters::fallback::LocaleFallbackProvider;

let provider = HelloWorldProvider;

let id = DataIdentifierCow::from_locale(langid!("ja-JP").into());

// The provider does not have data for "ja-JP":
DataProvider::<HelloWorldV1>::load(
    &provider,
    DataRequest {
        id: id.as_borrowed(),
        ..Default::default()
    },
)
.expect_err("No fallback");

// But if we wrap the provider in a fallback provider...
let provider = LocaleFallbackProvider::new(
    provider,
    icu_locale::LocaleFallbacker::new().static_to_owned(),
);

// ...then we can load "ja-JP" based on "ja" data
let response = DataProvider::<HelloWorldV1>::load(
    &provider,
    DataRequest {
        id: id.as_borrowed(),
        ..Default::default()
    },
)
.expect("successful with vertical fallback");

assert_eq!(response.metadata.locale.unwrap(), langid!("ja").into(),);
assert_eq!(response.payload.get().message, "こんにちは世界",);

Fields§

§inner: P§fallbacker: LocaleFallbacker

Implementations§

Source §

impl LocaleFallbackProvider

Source

pub fn new(provider: P, fallbacker: LocaleFallbacker) -> Self

Wraps a provider with a provider performing fallback under the given fallbacker.

If the underlying provider contains deduplicated data, it is important to use the same fallback data that ExportDriver used.

§Examples

use icu_locale::langid;
use icu_locale::LocaleFallbacker;
use icu_provider::hello_world::*;
use icu_provider::prelude::*;
use icu_provider_adapters::fallback::LocaleFallbackProvider;

let provider = HelloWorldProvider;

let id = DataIdentifierCow::from_locale(langid!("de-CH").into());

// There is no "de-CH" data in the `HelloWorldProvider`
DataProvider::<HelloWorldV1>::load(
    &provider,
    DataRequest {
        id: id.as_borrowed(),
        ..Default::default()
    },
)
.expect_err("No data for de-CH");

// `HelloWorldProvider` does not contain fallback data,
// but we can construct a fallbacker with `icu_locale`'s
// compiled data.
let provider = LocaleFallbackProvider::new(
    provider,
    LocaleFallbacker::new().static_to_owned(),
);

// Now we can load the "de-CH" data via fallback to "de".
let german_hello_world: DataResponse<HelloWorldV1> = provider
    .load(DataRequest {
        id: id.as_borrowed(),
        ..Default::default()
    })
    .expect("Loading should succeed");

assert_eq!("Hallo Welt", german_hello_world.payload.get().message);

Source

pub fn inner(&self) -> &P

Returns a reference to the inner provider, bypassing fallback.

Source

pub fn inner_mut(&mut self) -> &mut P

Returns a mutable reference to the inner provider.

Source

pub fn into_inner(self) -> P

Returns ownership of the inner provider to the caller.

Source

fn run_fallback<F1, F2, R>( &self, marker: DataMarkerInfo, base_req: DataRequest<'_>, f1: F1, f2: F2, ) -> Result<R, DataError>
where F1: FnMut(DataRequest<'_>) -> Result<R, DataError>, F2: FnMut(&mut R) -> &mut DataResponseMetadata,

Run the fallback algorithm with the data request using the inner data provider. Internal function; external clients should use one of the trait impls below.

Function arguments:

F1 should perform a data load for a single DataRequest and return the result of it
F2 should map from the provider-specific response type to DataResponseMetadata