Macro icu_provider::impl_dyn_provider [−][src]
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) => { ... };
}
Expand description
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 asAny
SerdeSeDataStruct
if your provider returns objects implementingserde::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 forDataProvider
; 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);