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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::from_di::{DiFactory, FromDi};
use crate::resolver::Error;
use crate::runtime::TypeMeta;
use crate::runtime::{ErasedArc, ErasedUnsizer};
use crate::runtime::{ServiceFactory, ServiceFactoryOnce};
use crate::{DiFactoryOnce, Services};
use std::fmt::Debug;

#[derive(Debug)]
pub struct Binding {
    pub ty: TypeMeta,
    pub kind: BindingKind,
}

#[derive(Debug)]
pub enum BindingKind {
    Type {
        /// Whether this type should be exposed directly.
        bind_self: bool,
        lifetime: BindingLifetime,
        deps: &'static [TypeMeta],
    },
    Alias {
        impls: Vec<(TypeMeta, ErasedUnsizer)>,
    },
}

impl BindingKind {
    pub fn unwrap_alias(self) -> Vec<(TypeMeta, ErasedUnsizer)> {
        match self {
            BindingKind::Type { .. } => {
                panic!("Called unwrap_alias on a Type binding")
            }
            BindingKind::Alias { impls } => impls,
        }
    }

    pub fn unwrap_alias_mut(&mut self) -> &mut Vec<(TypeMeta, ErasedUnsizer)> {
        match self {
            BindingKind::Type { .. } => {
                panic!("Called unwrap_alias on a Type binding")
            }
            BindingKind::Alias { impls } => impls,
        }
    }
}

#[derive(Debug)]
pub enum SingletonProvider {
    Instance(ErasedArc),
    Factory(ServiceFactoryOnce),
}

impl SingletonProvider {
    pub fn to_instance(self, services: &Services) -> Result<ErasedArc, Error> {
        match self {
            SingletonProvider::Instance(x) => Ok(x),
            SingletonProvider::Factory(x) => x.produce(services),
        }
    }
}

#[derive(Debug)]
pub enum BindingLifetime {
    Singleton(SingletonProvider),
    Transient(ServiceFactory),
}

impl BindingLifetime {
    pub fn singleton_from<T>(service: T) -> Self
    where
        T: Send + Sync + 'static,
    {
        let arc = ErasedArc::from_instance(service);

        Self::Singleton(SingletonProvider::Instance(arc))
    }

    pub fn singleton_from_di<T>() -> Self
    where
        T: Send + Sync + FromDi + 'static,
    {
        Self::Singleton(SingletonProvider::Factory(
            ServiceFactoryOnce::from_container::<T>(),
        ))
    }

    pub fn singleton_from_default<T>() -> Self
    where
        T: Send + Sync + Default + 'static,
    {
        Self::Singleton(SingletonProvider::Factory(
            ServiceFactoryOnce::from_default::<T>(),
        ))
    }

    pub fn singleton_from_fn<F, T, Args>(factory: F) -> Self
    where
        F: DiFactoryOnce<T, Args> + Send + Sync,
        T: Send + Sync + 'static,
    {
        Self::Singleton(SingletonProvider::Factory(
            ServiceFactoryOnce::from_fn_once(factory),
        ))
    }

    pub fn transient_from_di<T>() -> Self
    where
        T: Send + Sync + FromDi + 'static,
    {
        Self::Transient(ServiceFactory::from_container::<T>())
    }

    pub fn transient_from_default<T>() -> Self
    where
        T: Send + Sync + Default + 'static,
    {
        Self::Transient(ServiceFactory::from_default::<T>())
    }

    pub fn transient_from_fn<F, T, Args>(factory: F) -> Self
    where
        F: DiFactory<T, Args> + Send + Sync,
        T: Send + Sync + 'static,
    {
        Self::Transient(ServiceFactory::from_fn(factory))
    }
}