Macro icu_provider::impl_dyn_provider

macro_rules! impl_dyn_provider {
    ($provider : ty, { $($pat : pat => $struct_m : ty), +, }, ERASED) => { ... };
    ($provider : ty, { $($pat : pat => $struct_m : ty), +, }, SERDE_SE, $data :
 lifetime) => { ... };
    ($provider : ty, { $($pat : pat => $struct_m : ty), +, }, $dyn_m : path, $data
 : lifetime : $sb : lifetime) => { ... };
}

Implement DataProvider for a trait object S on a type that already implements DataProvider for one or more M, where M is a concrete type that implements the trait S.

Use this macro to add support to your data provider for:

• ErasedDataStruct if your provider can return typed objects as Any
• SerdeSeDataStruct if your provider returns objects implementing serde::Serialize

The second argument is a match-like construction mapping from resource keys to structs. To map multiple keys to a single data struct, use _ as the data key.

The third argument can be either the trait object marker, like SerdeSeDataStructMarker, or the shorthands ERASED or SERDE_SE.

Lifetimes:

• $data is the lifetime parameter for DataProvider; usually 'data.

Examples

Basic usage:

use icu_provider::prelude::*;
use icu_provider::erased::ErasedDataStructMarker;
use icu_provider::marker::CowStringMarker;
use std::borrow::Cow;
const DEMO_KEY: ResourceKey = icu_provider::resource_key!(x, "foo", "bar", 1);

// A small DataProvider that returns owned strings
struct MyProvider(pub String);
impl<'data> DataProvider<'static, CowStringMarker> for MyProvider {
    fn load_payload(&self, req: &DataRequest)
            -> Result<DataResponse<'static, CowStringMarker>, DataError> {
        req.resource_path.key.match_key(DEMO_KEY)?;
        Ok(DataResponse {
            metadata: Default::default(),
            payload: Some(DataPayload::from_owned(Cow::Owned(self.0.to_string())))
        })
    }
}

// Implement DataProvider<ErasedDataStructMarker>
icu_provider::impl_dyn_provider!(MyProvider, {
    DEMO_KEY => CowStringMarker,
}, ERASED);

// Usage example
let provider = MyProvider("demo".to_string());
let resp: DataResponse<ErasedDataStructMarker> = provider
    .load_payload(&DEMO_KEY.into())
    .expect("Loading should succeed");
let payload: DataPayload<CowStringMarker> = resp
    .take_payload()
    .expect("Payload should be present")
    .downcast()
    .expect("Type should downcast successfully");
assert_eq!("demo", payload.get());

Using the wildcard _ match:

// Send all keys to the `CowStringMarker` provider.
icu_provider::impl_dyn_provider!(MyProvider, {
    _ => CowStringMarker,
}, ERASED);