lockjaw 0.3.3

Compile time dependency injection framework inspired by dagger
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

Similar to [`#[into_vec]`](into_vec) but instead of a single element, all elements in the returned
`Vec<T>` is merged into the `Vec<T>` binding.

This allows the module to inject multiple elements into the `Vec<T>`, or conditionally inject no
elements.

```
# use lockjaw::*;
struct MyModule;

#[module]
impl MyModule {

    #[provides]
    #[into_vec]
    pub fn provide_string1() -> String {
        "string1".to_owned()
    }

    #[provides]
    #[elements_into_vec]
    pub fn provide_string2() -> Vec<String> {
        vec!["string2".to_owned(), "string3".to_owned()]
    }
    
    #[provides]
    #[elements_into_vec]
    pub fn provide_string4() -> Vec<String> {
        if true {
            vec![]        
        } else {
            vec!["string4".to_owned()]
        }
    }
}

#[component(modules: MyModule)]
pub trait MyComponent {
    fn vec_string(&self) -> Vec<String>;
}

pub fn main() {
    let component: Box<dyn MyComponent> = <dyn MyComponent>::new();
    let v = component.vec_string();
    assert!(v.contains(&"string1".to_owned()));
    assert!(v.contains(&"string2".to_owned()));
    assert!(v.contains(&"string3".to_owned()));
    
    assert!(!v.contains(&"string4".to_owned()));
}

epilogue!();
```