aboutsummaryrefslogtreecommitdiff
path: root/src/provider.rs
blob: eb5b5d89bc9d82cfe8f91e15add48492139d6e30 (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
#![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, TransientPtr};
use crate::DIContainer;

extern crate error_stack;

pub enum Providable
{
    Injectable(TransientPtr<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 InjectableTypeProvider<InjectableType>
where
    InjectableType: Injectable,
{
    injectable_phantom: PhantomData<InjectableType>,
}

impl<InjectableType> InjectableTypeProvider<InjectableType>
where
    InjectableType: Injectable,
{
    pub fn new() -> Self
    {
        Self {
            injectable_phantom: PhantomData,
        }
    }
}

impl<InjectableType> IProvider for InjectableTypeProvider<InjectableType>
where
    InjectableType: Injectable,
{
    fn provide(
        &self,
        di_container: &DIContainer,
    ) -> error_stack::Result<Providable, ResolveError>
    {
        Ok(Providable::Injectable(InjectableType::resolve(
            di_container,
        )?))
    }
}

#[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()))
    }
}