sword-core 0.3.0

Structured web framework built on top of tokio ecosystem, providing powerful features for building robust web applications.
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

use crate::{Injectable, RwMap};
use std::{any::TypeId, collections::HashMap, sync::Arc};

/// Marker trait for pre-instantiated dependencies (providers).
///
/// Providers are dependencies that have been pre-constructed and registered
/// into the State. Unlike Components which are built from their dependencies,
/// Providers are already complete instances that only need to be retrieved
/// from the State.
///
/// Providers are injected as `Arc<T>` (via `State::borrow`), so they do not
/// need to be `Clone`. Common use cases: database connections, external API
/// clients, or any resource that requires async initialization or complex setup.
pub trait Provider: Send + Sync {}

pub struct ProviderRegistry {
    providers: RwMap<TypeId, Injectable>,
}

impl ProviderRegistry {
    pub(crate) fn new() -> Self {
        Self {
            providers: RwMap::new(HashMap::new()),
        }
    }

    /// Registers a provider instance.
    ///
    /// Providers are instances that have already been constructed and are ready
    /// to be injected into other components. Typical use cases include database
    /// connections, HTTP clients, or external service configurations that cannot
    /// be auto-constructed from the State.
    pub fn register<T>(&self, provider: T)
    where
        T: Provider + 'static,
    {
        self.providers
            .write()
            .insert(TypeId::of::<T>(), Arc::new(provider));
    }

    pub(crate) fn get_providers(&self) -> &RwMap<TypeId, Injectable> {
        &self.providers
    }
}