aboutsummaryrefslogtreecommitdiff
path: root/src/provider.rs
blob: ad9458919b8241c9c06885f11e21101aa576e11c (plain)
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
#![allow(clippy::module_name_repetitions)]
use std::marker::PhantomData;

use crate::errors::injectable::InjectableError;
use crate::interfaces::any_factory::AnyFactory;
use crate::interfaces::injectable::Injectable;
use crate::ptr::{FactoryPtr, SingletonPtr, TransientPtr};
use crate::DIContainer;

#[derive(strum_macros::Display, Debug)]
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,
        dependency_history: Vec<&'static str>,
    ) -> Result<Providable, InjectableError>;
}

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,
        dependency_history: Vec<&'static str>,
    ) -> Result<Providable, InjectableError>
    {
        Ok(Providable::Transient(InjectableType::resolve(
            di_container,
            dependency_history,
        )?))
    }
}

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,
        _dependency_history: Vec<&'static str>,
    ) -> Result<Providable, InjectableError>
    {
        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,
        _dependency_history: Vec<&'static str>,
    ) -> Result<Providable, InjectableError>
    {
        Ok(Providable::Factory(self.factory.clone()))
    }
}