1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
use super::private::Sealed; use super::*; /// Resolves dependencies. /// /// Dependencies have to be registered beforehand, how you do /// that depends on the implementing type. /// /// Dependencies can be shared across multiple use points. In /// garbage collected languages, these dependencies would /// naturally live on the heap and the garbage collector would /// take care of deallocating them. /// /// All dependencies will be cloned when resolving. If you would /// like to have a shared dependency, use Rc<T>. /// /// # Using a shared dependency /// /// ``` /// # use std::rc::Rc; /// # use kamikaze_di::{Container, ContainerBuilder, Resolver}; /// # /// # fn main() -> std::result::Result<(), String> { /// # /// // does not implement Clone or Copy /// struct Keeper { x: i32 } /// /// let mut builder = ContainerBuilder::new(); /// builder.register::<Rc<Keeper>>(Rc::new(Keeper{ x: 42 })); /// /// let container = builder.build(); /// /// let resolved = container.resolve::<Rc<Keeper>>()?; /// assert_eq!((*resolved).x, 42); /// # /// # Ok(()) /// # } /// ``` /// /// /// # If you need to resolve a trait, use Rc<Trait>. /// /// ``` /// # use std::rc::Rc; /// # use kamikaze_di::{Container, ContainerBuilder, Resolver}; /// # /// # fn main() -> std::result::Result<(), String> { /// # /// // does not implement Clone or Copy /// struct Keeper { x: i32 } /// trait XKeeper { fn get_x(&self) -> i32; } /// impl XKeeper for Keeper { fn get_x(&self) -> i32 { self.x } } /// /// let mut builder = ContainerBuilder::new(); /// builder.register::<Rc<XKeeper>>(Rc::new(Keeper{ x: 42 })); /// /// let container = builder.build(); /// /// let resolved = container.resolve::<Rc<XKeeper>>()?; /// assert_eq!(resolved.get_x(), 42); /// # /// # Ok(()) /// # } /// ``` pub trait Resolver: Sealed { /// Resolve a dependency. /// /// # Examples /// /// ``` /// # use kamikaze_di::{Container, ContainerBuilder, Resolver}; /// # /// # fn main() -> std::result::Result<(), String> { /// # /// let mut builder = ContainerBuilder::new(); /// builder.register::<u32>(42); /// /// let container = builder.build(); /// /// let resolved: u32 = container.resolve()?; /// assert_eq!(resolved, 42); /// # /// # Ok(()) /// # } /// ``` fn resolve<T: Clone + 'static>(&self) -> Result<T>; /// Returns true if a dependency is registered. /// /// # Examples /// /// ``` /// # use kamikaze_di::{Container, ContainerBuilder, Resolver}; /// # /// let mut builder = ContainerBuilder::new(); /// builder.register::<i16>(43); /// let container = builder.build(); /// /// assert!(container.has::<i16>()); /// assert!(!container.has::<i32>()); /// ``` fn has<T: 'static>(&self) -> bool; } impl Resolver for Container { fn resolve<T: Clone + 'static>(&self) -> Result<T> { self.get::<T>() } fn has<T: 'static>(&self) -> bool { self.has::<T>() } }