Trait for requesting values by type from a given object.

Examples

Using a Provider

# use object_provider::*;
# use std::path::{Path, PathBuf};
# use std::fmt::Debug;
# struct MyProvider {
#     path: PathBuf,
# }
# impl ObjectProvider for MyProvider {
#     fn provide<'r, 'a>(&'a self, request: Request<'r, 'a>) -> ProvideResult<'r, 'a> {
#         request
#             .provide::<PathBuf>(&self.path)?
#             .provide::<Path>(&self.path)?
#             .provide::<dyn Debug>(&self.path)
#     }
# }
# let my_path = Path::new("hello/world");
# let my_provider = MyProvider { path: my_path.to_owned() };
let provider: &dyn ObjectProvider;
# provider = &my_provider;

// It's possible to request concrete types like `PathBuf`
let path_buf = provider.request::<PathBuf>().unwrap();
assert_eq!(path_buf, my_path);

// Requesting `!Sized` types, like slices and trait objects, is also supported.
let path = provider.request::<Path>().unwrap();
assert_eq!(path, my_path);

let debug = provider.request::<dyn Debug>().unwrap();
assert_eq!(
format!("{:?}", debug),
format!("{:?}", my_path),
);

// Types or interfaces not explicitly provided return `None`.
assert!(provider.request::<i32>().is_none());
assert!(provider.request::<dyn AsRef<Path>>().is_none());

Implementing a Provider

# use object_provider::*;
# use std::path::{Path, PathBuf};
# use std::fmt::Debug;
struct MyProvider {
path: PathBuf,
}

impl ObjectProvider for MyProvider {
fn provide<'r, 'a>(&'a self, request: Request<'r, 'a>) -> ProvideResult<'r, 'a> {
request
.provide::<PathBuf>(&self.path)?
.provide::<Path>(&self.path)?
.provide::<dyn Debug>(&self.path)
}
}