diode 0.2.0

Core diode library
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
129
130
131
132
133
134
135

use std::ops::{Deref, DerefMut};

use crate::{
    AppContext, AppError, ComponentMut, ComponentRef, Dependencies, Service, ServiceDependencyExt,
};

/// Trait for extracting owned values from the application context.
pub trait Extract<T> {
    fn extract(ctx: &AppContext) -> Result<T, AppError>;

    fn dependencies() -> Dependencies {
        Dependencies::new()
    }
}

/// Trait for extracting borrowed references from the application context.
///
/// The associated type `Ref` allows each implementation to choose its
/// return type — `ComponentRef<T>` for stored components, `&T` for
/// values available directly (e.g. `AppContext` itself).
pub trait ExtractRef<T> {
    type Ref<'a>: Deref<Target = T> + 'a;

    fn extract_ref(ctx: &AppContext) -> Result<Self::Ref<'_>, AppError>;

    fn dependencies() -> Dependencies {
        Dependencies::new()
    }
}

/// Trait for extracting mutable references from the application context.
///
/// Similar to [`ExtractRef`], but provides `DerefMut` access to the component.
///
/// # Deadlock warning
///
/// The returned guard holds a write lock on the underlying storage shard.
/// Combining a `&mut` inject parameter with other `&` or `&mut` inject
/// parameters in the same `#[factory]` method may deadlock if the components
/// are stored in the same shard. The `#[service]` macro rejects such
/// combinations at compile time.
///
/// If you need multiple references where at least one is mutable, inject
/// `&AppContext` and manage guards manually:
///
/// ```rust,ignore
/// #[factory]
/// fn new(#[inject(AppContext)] ctx: &AppContext) -> Arc<Self> {
///     {
///         let mut registry = ctx.get_component_mut::<Registry>().unwrap();
///         registry.register("my_service");
///     } // guard dropped before next acquisition
///     let config = ctx.get_component_ref::<Config>().unwrap();
///     Arc::new(Self { /* ... */ })
/// }
/// ```
pub trait ExtractMut<T>: ExtractRef<T> {
    type RefMut<'a>: DerefMut<Target = T> + 'a;

    fn extract_mut(ctx: &AppContext) -> Result<Self::RefMut<'_>, AppError>;
}

impl<T, S> Extract<T> for S
where
    T: Clone + Send + Sync + 'static,
    S: Service<Handle = T> + 'static,
{
    fn extract(ctx: &AppContext) -> Result<T, AppError> {
        ctx.get_component::<T>().ok_or(AppError::MissingComponent(std::any::type_name::<T>()))
    }

    fn dependencies() -> Dependencies {
        Dependencies::new().service::<S>()
    }
}

impl<T, S> ExtractRef<T> for S
where
    T: Send + Sync + 'static,
    S: Service<Handle = T> + 'static,
{
    type Ref<'a> = ComponentRef<'a, T>;

    fn extract_ref(ctx: &AppContext) -> Result<Self::Ref<'_>, AppError> {
        ctx.get_component_ref::<T>().ok_or(AppError::MissingComponent(std::any::type_name::<T>()))
    }

    fn dependencies() -> Dependencies {
        Dependencies::new().service::<S>()
    }
}

impl ExtractRef<AppContext> for AppContext {
    type Ref<'a> = &'a AppContext;

    fn extract_ref(ctx: &AppContext) -> Result<&AppContext, AppError> {
        Ok(ctx)
    }
}

/// Generic extractor for any component stored in the application.
pub struct Component;

impl<T> Extract<T> for Component
where
    T: Clone + Send + Sync + 'static,
{
    fn extract(ctx: &AppContext) -> Result<T, AppError> {
        ctx.get_component::<T>().ok_or(AppError::MissingComponent(std::any::type_name::<T>()))
    }
}

impl<T> ExtractRef<T> for Component
where
    T: Send + Sync + 'static,
{
    type Ref<'a> = ComponentRef<'a, T>;

    fn extract_ref(ctx: &AppContext) -> Result<Self::Ref<'_>, AppError> {
        ctx.get_component_ref::<T>()
            .ok_or(AppError::MissingComponent(std::any::type_name::<T>()))
    }
}

impl<T> ExtractMut<T> for Component
where
    T: Send + Sync + 'static,
{
    type RefMut<'a> = ComponentMut<'a, T>;

    fn extract_mut(ctx: &AppContext) -> Result<Self::RefMut<'_>, AppError> {
        ctx.get_component_mut::<T>()
            .ok_or(AppError::MissingComponent(std::any::type_name::<T>()))
    }
}