Struct icu_provider_adapters::fallback::LocaleFallbackProvider

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

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

Examples

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


let req = DataRequest {
    locale: &langid!("ja-JP").into(),
    metadata: Default::default(),
};

// The provider does not have data for "ja-JP":
DataProvider::<HelloWorldV1Marker>::load(&provider, req).expect_err("No fallback");

// But if we wrap the provider in a fallback provider...
let provider = LocaleFallbackProvider::try_new_unstable(provider)
    .expect("Fallback data present");

// ...then we can load "ja-JP" based on "ja" data
let response =
  DataProvider::<HelloWorldV1Marker>::load(&provider, req).expect("successful with vertical fallback");

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

Fields

inner: P

fallbacker: LocaleFallbacker

Implementations

impl<P> LocaleFallbackProvider<P>

where P: DataProvider<LocaleFallbackLikelySubtagsV1Marker> + DataProvider<LocaleFallbackParentsV1Marker> + DataProvider<CollationFallbackSupplementV1Marker>,

pub fn try_new_unstable(provider: P) -> Result<Self, DataError>

Create a LocaleFallbackProvider by wrapping another data provider and then loading fallback data from it.

If the data provider being wrapped does not contain fallback data, use LocaleFallbackProvider::new_with_fallbacker.

impl<P> LocaleFallbackProvider<P>

where P: AnyProvider,

pub fn try_new_with_any_provider(provider: P) -> Result<Self, DataError>

Create a LocaleFallbackProvider by wrapping another data provider and then loading fallback data from it.

If the data provider being wrapped does not contain fallback data, use LocaleFallbackProvider::new_with_fallbacker.

impl<P> LocaleFallbackProvider<P>

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

Wrap a provider with an arbitrary fallback engine.

This relaxes the requirement that the wrapped provider contains its own fallback data.

Examples

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

let provider = HelloWorldProvider;

let req = DataRequest {
    locale: &langid!("de-CH").into(),
    metadata: Default::default(),
};

// There is no "de-CH" data in the `HelloWorldProvider`
DataProvider::<HelloWorldV1Marker>::load(&provider, req)
    .expect_err("No data for de-CH");

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

// Now we can load the "de-CH" data via fallback to "de".
let german_hello_world: DataPayload<HelloWorldV1Marker> = provider
    .load(req)
    .expect("Loading should succeed")
    .take_payload()
    .expect("Data should be present");

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

pub fn inner(&self) -> &P

Returns a reference to the inner provider, bypassing fallback.

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

Returns a mutable reference to the inner provider.

pub fn into_inner(self) -> P

Returns ownership of the inner provider to the caller.

fn run_fallback<F1, F2, R>( &self, key: DataKey, 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

Trait Implementations

impl<P> AnyProvider for LocaleFallbackProvider<P>

where P: AnyProvider,

fn load_any( &self, key: DataKey, base_req: DataRequest<'_>, ) -> Result<AnyResponse, DataError>

Loads an AnyPayload according to the key and request.

impl<P> BufferProvider for LocaleFallbackProvider<P>

where P: BufferProvider,

fn load_buffer( &self, key: DataKey, base_req: DataRequest<'_>, ) -> Result<DataResponse<BufferMarker>, DataError>

Loads a DataPayload<BufferMarker> according to the key and request.

impl<P: Clone> Clone for LocaleFallbackProvider<P>

fn clone(&self) -> LocaleFallbackProvider<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, M> DataProvider<M> for LocaleFallbackProvider<P>

where P: DataProvider<M>, M: KeyedDataMarker,

fn load(&self, base_req: DataRequest<'_>) -> Result<DataResponse<M>, DataError>

Query the provider for data, returning the result.

impl<P: Debug> Debug for LocaleFallbackProvider<P>

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

Formats the value using the given formatter.

impl<P, M> DynamicDataProvider<M> for LocaleFallbackProvider<P>

where P: DynamicDataProvider<M>, M: DataMarker,

fn load_data( &self, key: DataKey, base_req: DataRequest<'_>, ) -> Result<DataResponse<M>, DataError>

Query the provider for data, returning the result.