Struct kamikaze_di::ContainerBuilder

pub struct ContainerBuilder { /* fields omitted */ }

Dependency container builder.

You can register shared dependencies (they will act like singletons) with the register() and register_builder() functions.

You can register factories for dependencies (each request for them will produce a new instance) with the register_factory() and register_automatic_factory() functions.

Examples

let mut builder = ContainerBuilder::new();
let first_register_works = builder.register::<u32>(42);
let re_registering_doesnt_work = builder.register::<u32>(43);

assert!(first_register_works.is_ok());
assert!(!re_registering_doesnt_work.is_ok());

let container = builder.build();
assert_eq!(container.resolve::<u32>()?, 42);

Circular dependencies will cause continer.resolve() to panic:

let mut builder = ContainerBuilder::new();

builder.register_factory::<i32, _>(|container| {
    use std::convert::TryInto;

    let base: i64 = container.resolve().unwrap();
    let base: i32 = base.try_into().unwrap();
    base - 1
});

builder.register_factory::<i64, _>(|container| {
    let base: i32 = container.resolve().unwrap();
    let base: i64 = base.into();
    base - 1
});

let container = builder.build();

let forty_one: i64 = container.resolve()?;

Methods

impl ContainerBuilder

pub fn new() -> ContainerBuilder

Constructor.

pub fn build(self) -> Container

Creates a Container from the builder.

pub fn register<T: 'static>(&mut self, item: T) -> Result<()>

Registeres a dependency directly.

Examples

let mut builder = ContainerBuilder::new();
let result = builder.register::<u32>(42);

assert!(result.is_ok());

pub fn register_factory<T, F>(&mut self, factory: F) -> Result<()> where
    F: FnMut(&Container) -> T + 'static,
    T: 'static, 

Registers a factory.

Every time a dependency is resolved, a new item will be created.

Examples

let mut builder = ContainerBuilder::new();
builder.register::<i16>(43);

let mut i = 0;
builder.register_factory::<i32, _>(move |container| {
    i += 1;
    let base: i16 = container.resolve().unwrap();
    let base: i32 = base.into();
    base - i
});

let container = builder.build();

let forty_two: i32 = container.resolve()?;
let forty_one: i32 = container.resolve()?;

assert_eq!(forty_two, 42);
assert_eq!(forty_one, 41);

pub fn register_automatic_factory<T: Inject + 'static>(&mut self) -> Result<()>

Every time a dependency is resolved, a new item will be created.

Examples

#[derive(Clone)]
struct X {}
impl Inject for X {
    fn resolve(container: &Container) -> Result<Self> {
        Ok(X {})
    }
}
let mut builder = ContainerBuilder::new();
builder.register::<Rc<usize>>(Rc::new(42));
builder.register_automatic_factory::<X>();

let container = builder.build();

let x1 = container.resolve::<X>()?;
let x2 = container.resolve::<X>()?;

pub fn register_builder<T, B>(&mut self, builder: B) -> Result<()> where
    B: FnOnce(&Container) -> T + 'static,
    T: 'static, 

Registers a builder.

The dependency is created only when needed and after that it behaves as if registered via register(item).

Examples

let mut builder = ContainerBuilder::new();
builder.register::<i16>(43);

builder.register_builder::<i32, _>(|container| {
    let base = container.resolve::<i16>().unwrap();
    let base: i32 = base.into();
    base - 1
});

builder.register_builder::<i64, _>(|container| {
    let base = container.resolve::<i32>().unwrap();
    let base: i64 = base.into();
    base - 1
});

let container = builder.build();

let forty_one = container.resolve::<i64>()?;
let forty_two = container.resolve::<i32>()?;

assert_eq!(forty_one, 41);
assert_eq!(forty_two, 42);

pub fn has<T: 'static>(&self) -> bool

Returns true if a dependency is registered.

Examples

let mut builder = ContainerBuilder::new();
builder.register::<i16>(43);

assert!(builder.has::<i16>());
assert!(!builder.has::<i32>());

Trait Implementations

impl Default for ContainerBuilder

fn default() -> ContainerBuilder

Returns the "default value" for a type.

impl Debug for ContainerBuilder

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.