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
|
#![allow(clippy::module_name_repetitions)]
use std::marker::PhantomData;
use crate::errors::injectable::ResolveError;
use crate::interfaces::any_factory::AnyFactory;
use crate::interfaces::injectable::Injectable;
use crate::ptr::{FactoryPtr, SingletonPtr, TransientPtr};
use crate::DIContainer;
extern crate error_stack;
pub enum Providable
{
Transient(TransientPtr<dyn Injectable>),
Singleton(SingletonPtr<dyn Injectable>),
#[allow(dead_code)]
Factory(FactoryPtr<dyn AnyFactory>),
}
pub trait IProvider
{
fn provide(
&self,
di_container: &DIContainer,
) -> error_stack::Result<Providable, ResolveError>;
}
pub struct TransientTypeProvider<InjectableType>
where
InjectableType: Injectable,
{
injectable_phantom: PhantomData<InjectableType>,
}
impl<InjectableType> TransientTypeProvider<InjectableType>
where
InjectableType: Injectable,
{
pub fn new() -> Self
{
Self {
injectable_phantom: PhantomData,
}
}
}
impl<InjectableType> IProvider for TransientTypeProvider<InjectableType>
where
InjectableType: Injectable,
{
fn provide(
&self,
di_container: &DIContainer,
) -> error_stack::Result<Providable, ResolveError>
{
Ok(Providable::Transient(InjectableType::resolve(
di_container,
)?))
}
}
pub struct SingletonProvider<InjectableType>
where
InjectableType: Injectable,
{
singleton: SingletonPtr<InjectableType>,
}
impl<InjectableType> SingletonProvider<InjectableType>
where
InjectableType: Injectable,
{
pub fn new(singleton: SingletonPtr<InjectableType>) -> Self
{
Self { singleton }
}
}
impl<InjectableType> IProvider for SingletonProvider<InjectableType>
where
InjectableType: Injectable,
{
fn provide(
&self,
_di_container: &DIContainer,
) -> error_stack::Result<Providable, ResolveError>
{
Ok(Providable::Singleton(self.singleton.clone()))
}
}
#[cfg(feature = "factory")]
pub struct FactoryProvider
{
factory: FactoryPtr<dyn AnyFactory>,
}
#[cfg(feature = "factory")]
impl FactoryProvider
{
pub fn new(factory: FactoryPtr<dyn AnyFactory>) -> Self
{
Self { factory }
}
}
#[cfg(feature = "factory")]
impl IProvider for FactoryProvider
{
fn provide(
&self,
_di_container: &DIContainer,
) -> error_stack::Result<Providable, ResolveError>
{
Ok(Providable::Factory(self.factory.clone()))
}
}
|
