Macro icu_provider::impl_dyn_provider

macro_rules! impl_dyn_provider {
    ($provider:ty, $struct:ty, ERASED, $d:lifetime, $s:lifetime) => { ... };
    ($provider:ty, $struct:ty, SERDE_SE, $d:lifetime, $s:lifetime) => { ... };
    ($provider:ty, $struct:ty, $struct_trait:path, $d:lifetime, $s:lifetime) => { ... };
}

Implement DataProvider<dyn S> on a type that already implements DataProvider<T> where T is a Sized 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 third argument can be either the trait expression, like [SerdeSeDataStruct<’s>], or the shorthands ERASEDorSERDE_SE`.

Lifetimes:

• $d is the lifetime parameter for DataProvider; usually 'd
• $s is the lifetime bound for the struct trait; usually 's

Examples

use icu_provider::prelude::*;
use icu_provider::erased::ErasedDataStruct;
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<'d> DataProvider<'d, String> for MyProvider {
    fn load_payload(&self, req: &DataRequest) -> Result<DataResponse<'d, String>, DataError> {
        req.resource_path.key.match_key(DEMO_KEY)?;
        Ok(DataResponse {
            metadata: Default::default(),
            payload: DataPayload {
                cow: Some(Cow::Owned(self.0.to_string()))
            }
        })
    }
}

// Since `String` is `'static`, we can implement `DataProvider<dyn ErasedDataStruct>`
icu_provider::impl_dyn_provider!(MyProvider, String, ERASED, 'd, 's);

// Usage example
let provider = MyProvider("demo".to_string());
let resp: DataResponse<dyn ErasedDataStruct> = provider
    .load_payload(&DEMO_KEY.into())
    .expect("Loading should succeed");