Struct icu_provider_adapters::filter::FilterDataProvider

pub struct FilterDataProvider<D, F>
where
    F: Fn(DataIdentifierBorrowed<'_>) -> bool,
{
    pub inner: D,
    pub predicate: F,
    pub filter_name: &'static str,
}

A data provider that selectively filters out data requests.

Data requests that are rejected by the filter will return a [DataError] with kind Filtered, and they will not be returned by [IterableDynamicDataProvider::iter_ids_for_marker].

Although this struct can be created directly, the traits in this module provide helper functions for common filtering patterns.

Fields

inner: D

The data provider to which we delegate requests.

predicate: F

The predicate function. A return value of true indicates that the request should proceed as normal; a return value of false will reject the request.

filter_name: &'static str

A name for this filter, used in error messages.

Implementations

impl<D> FilterDataProvider<D, fn(_: DataIdentifierBorrowed<'_>) -> bool>

pub fn new(provider: D, filter_name: &'static str) -> Self

Creates a FilterDataProvider that does not do any filtering.

Filters can be added using Self::with_filter.

impl<D, F> FilterDataProvider<D, F>

where F: Fn(DataIdentifierBorrowed<'_>) -> bool + Sync,

pub fn with_filter<'a>( self, predicate: impl Fn(DataIdentifierBorrowed<'_>) -> bool + Sync + 'a, ) -> FilterDataProvider<D, Box<dyn Fn(DataIdentifierBorrowed<'_>) -> bool + Sync + 'a>>

where F: 'a,

Filter out data requests with certain langids according to the predicate function. The predicate should return true to allow a langid and false to reject a langid.

Examples

use icu_locale::LanguageIdentifier;
use icu_locale::{langid, subtags::language};
use icu_provider::hello_world::*;
use icu_provider::prelude::*;
use icu_provider_adapters::filter::FilterDataProvider;

let provider =
    FilterDataProvider::new(HelloWorldProvider, "Demo no-English filter")
        .with_filter(|id| id.locale.language != language!("en"));

// German requests should succeed:
let de = DataIdentifierCow::from_locale(langid!("de").into());
let response: Result<DataResponse<HelloWorldV1Marker>, _> =
    provider.load(DataRequest {
        id: de.as_borrowed(),
        ..Default::default()
    });
assert!(matches!(response, Ok(_)));

// English requests should fail:
let en = DataIdentifierCow::from_locale(langid!("en-US").into());
let response: Result<DataResponse<HelloWorldV1Marker>, _> =
    provider.load(DataRequest {
        id: en.as_borrowed(),
        ..Default::default()
    });
let response: Result<DataResponse<HelloWorldV1Marker>, _> =
    provider.load(DataRequest {
        id: en.as_borrowed(),
        ..Default::default()
    });
assert!(matches!(
    response,
    Err(DataError {
        kind: DataErrorKind::IdentifierNotFound,
        ..
    })
));

// English should not appear in the iterator result:
let available_ids = provider
    .iter_ids()
    .expect("Should successfully make an iterator of supported locales");
assert!(available_ids
    .contains(&DataIdentifierCow::from_locale(langid!("de").into())));
assert!(!available_ids
    .contains(&DataIdentifierCow::from_locale(langid!("en").into())));

Trait Implementations

impl<D, F> AnyProvider for FilterDataProvider<D, F>

where F: Fn(DataIdentifierBorrowed<'_>) -> bool, D: AnyProvider,

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

Loads an [AnyPayload] according to the marker and request.

impl<D, F, M> DataProvider<M> for FilterDataProvider<D, F>

where F: Fn(DataIdentifierBorrowed<'_>) -> bool, M: DataMarker, D: DataProvider<M>,

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

Query the provider for data, returning the result.

impl<D: Debug, F> Debug for FilterDataProvider<D, F>

where F: Fn(DataIdentifierBorrowed<'_>) -> bool + Debug,

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

Formats the value using the given formatter.

impl<D, F, M> DryDataProvider<M> for FilterDataProvider<D, F>

where F: Fn(DataIdentifierBorrowed<'_>) -> bool, M: DataMarker, D: DryDataProvider<M>,

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

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

impl<D, F, M> DynamicDataProvider<M> for FilterDataProvider<D, F>

where F: Fn(DataIdentifierBorrowed<'_>) -> bool, M: DynamicDataMarker, D: DynamicDataProvider<M>,

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

Query the provider for data, returning the result.

impl<D, F, M> DynamicDryDataProvider<M> for FilterDataProvider<D, F>

where F: Fn(DataIdentifierBorrowed<'_>) -> bool, M: DynamicDataMarker, D: DynamicDryDataProvider<M>,

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.

impl<P0, F> ExportableProvider for FilterDataProvider<P0, F>

where P0: ExportableProvider, F: Fn(DataIdentifierBorrowed<'_>) -> bool + Sync,

fn supported_markers(&self) -> HashSet<DataMarkerInfo>

Returns the set of supported markers

impl<M, D, F> IterableDataProvider<M> for FilterDataProvider<D, F>

where M: DataMarker, F: Fn(DataIdentifierBorrowed<'_>) -> bool, D: IterableDataProvider<M>,

fn iter_ids(&self) -> Result<BTreeSet<DataIdentifierCow<'_>>, DataError>

Returns a set of [DataIdentifierCow].

impl<M, D, F> IterableDynamicDataProvider<M> for FilterDataProvider<D, F>

where M: DynamicDataMarker, F: Fn(DataIdentifierBorrowed<'_>) -> bool, D: IterableDynamicDataProvider<M>,

fn iter_ids_for_marker( &self, marker: DataMarkerInfo, ) -> Result<BTreeSet<DataIdentifierCow<'_>>, DataError>

Given a [DataMarkerInfo], returns a set of [DataIdentifierCow].