chassis 0.2.0

Compile-time dependency injection framework
Documentation 
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

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

static INSTANCES: AtomicUsize = AtomicUsize::new(0);

pub struct InstanceCounter {
    instance: usize,
}

impl InstanceCounter {
    pub fn new() -> Self {
        Self {
            instance: INSTANCES.fetch_add(1, Ordering::SeqCst),
        }
    }

    pub fn instance(&self) -> usize {
        self.instance
    }

    pub fn instances() -> usize {
        INSTANCES.load(Ordering::SeqCst)
    }
}

#[derive(Default)]
pub struct TestProvider;

#[chassis::module]
impl TestProvider {
    #[chassis(singleton)]
    pub fn provide_singleton() -> Arc<InstanceCounter> {
        Arc::new(InstanceCounter::new())
    }
}

#[chassis::injector(modules = [TestProvider])]
pub trait TestFactory {
    fn provide_singleton(&self) -> Arc<InstanceCounter>;
}

// TODO: Test multiple singletons
//   Test cyclic singletons

#[test]
fn check() {
    let injector = <dyn TestFactory>::new().unwrap();
    injector.provide_singleton();
    injector.provide_singleton();
    let singleton = injector.provide_singleton();

    assert_eq!(0, singleton.instance());
    assert_eq!(1, InstanceCounter::instances());
}