Struct icu_provider_adapters::fallback::LocaleFallbackProvider

pub struct LocaleFallbackProvider<P> { /* private fields */ }

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::prelude::*;
use icu_provider::hello_world::*;
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::<HelloWorldV1Marker>::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::<HelloWorldV1Marker>::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,
    "こんにちは世界",
);

Implementations

impl<P> LocaleFallbackProvider<P>

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::<HelloWorldV1Marker>::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<HelloWorldV1Marker> = provider
    .load(DataRequest {
        id: id.as_borrowed(),
        ..Default::default()
    })
    .expect("Loading should succeed");

assert_eq!("Hallo Welt", german_hello_world.payload.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.

Trait Implementations

impl<P> AnyProvider for LocaleFallbackProvider<P>

where P: AnyProvider,

fn load_any( &self, marker: DataMarkerInfo, req: DataRequest<'_>, ) -> Result<AnyResponse, DataError>

Loads an [AnyPayload] according to the marker 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: DataMarker,

fn load(&self, 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> DryDataProvider<M> for LocaleFallbackProvider<P>

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

fn dry_load( &self, req: DataRequest<'_>, ) -> Result<DataResponseMetadata, DataError>

This method goes through the motions of load, but only returns the metadata.

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

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

fn load_data( &self, marker: DataMarkerInfo, req: DataRequest<'_>, ) -> Result<DataResponse<M>, DataError>

Query the provider for data, returning the result.

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

where P: DynamicDryDataProvider<M>, M: DynamicDataMarker,

fn dry_load_data( &self, marker: DataMarkerInfo, req: DataRequest<'_>, ) -> Result<DataResponseMetadata, DataError>

This method goes through the motions of load_data, but only returns the metadata.