deorbit-core 0.1.4

A dependency injection framework for Rust
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
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

use crate::Error;
use crate::resolver::Services;
use crate::runtime::TypeMeta;

/// Represents an object that's capable of building itself from a DI instance.
pub trait FromDi: Sized {
    fn depends_on() -> &'static [TypeMeta];
    fn produce(services: &Services) -> Result<Self, Error>;
}

/// Represents an object that's capable of building T from a DI instance.
pub trait DiFactory<T, Args>: DiFactoryOnce<T, Args> {
    fn produce(&self, services: &Services) -> Result<T, Error>;
}

/// Represents an object that's capable of building T from a DI instance.
pub trait DiFactoryOnce<T, Args>: 'static {
    fn depends_on() -> &'static [TypeMeta];
    fn produce(self, services: &Services) -> Result<T, Error>;
}

macro_rules! impl_factory_once {
    ($($args:ident),*) => {
        impl<F, O, $($args),*> DiFactoryOnce<O, ($($args),*,)> for F
        where
            $($args: $crate::FromDi,)*
            F: FnOnce($($args),*) -> O + 'static,
            O: 'static,
            $($args: 'static),*
        {
            fn depends_on() -> &'static [$crate::runtime::TypeMeta] {
                const {
                    &[
                        $($crate::runtime::TypeMeta::of::<$args>()),*
                    ]
                }
            }

            fn produce(self, services: &$crate::Services) -> Result<O, $crate::Error> {
                Ok((self)(
                    $($args::produce(services)?),*
                ))
            }
        }
    };
}

macro_rules! impl_factory {
    ($($args:ident),*) => {
        impl<F, O, $($args),*> DiFactory<O, ($($args),*,)> for F
        where
            $($args: $crate::FromDi,)*
            F: Fn($($args),*) -> O + 'static,
            O: 'static,
            $($args: 'static),*
        {
            fn produce(&self, services: &$crate::Services) -> Result<O, $crate::Error> {
                Ok((&self)(
                    $($args::produce(services)?),*
                ))
            }
        }
    };
}

macro_rules! impl_all_for {
    ($macro:ident) => {
        $macro!(T1);
        $macro!(T1, T2);
        $macro!(T1, T2, T3);
        $macro!(T1, T2, T3, T4);
        $macro!(T1, T2, T3, T4, T5);
        $macro!(T1, T2, T3, T4, T5, T6);
        $macro!(T1, T2, T3, T4, T5, T6, T7);
        $macro!(T1, T2, T3, T4, T5, T6, T7, T8);
        $macro!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
    };
}

impl_all_for!(impl_factory_once);
impl_all_for!(impl_factory);

impl<F, O> DiFactoryOnce<O, ()> for F
where
    F: FnOnce() -> O + 'static,
    O: 'static,
{
    fn depends_on() -> &'static [TypeMeta] {
        &[]
    }

    fn produce(self, _: &Services) -> Result<O, Error> {
        Ok(self())
    }
}

impl<F, O> DiFactory<O, ()> for F
where
    F: Fn() -> O + 'static,
    O: 'static,
{
    fn produce(&self, _: &Services) -> Result<O, Error> {
        Ok(self())
    }
}