toni 0.1.0

Fast and modular web framework for scalable 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
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

use std::{collections::hash_map::Drain, sync::Arc};

use rustc_hash::{FxHashMap, FxHashSet};

use crate::traits_helpers::{Controller, ControllerTrait, ModuleMetadata, Provider, ProviderTrait};
pub struct Module {
    _token: String,
    _name: String,
    controllers: FxHashMap<String, Box<dyn Controller>>,
    providers: FxHashMap<String, Box<dyn Provider>>,
    imports: FxHashSet<String>,
    exports: FxHashSet<String>,
    controllers_instances: FxHashMap<String, Arc<Box<dyn ControllerTrait>>>,
    providers_instances: FxHashMap<String, Arc<Box<dyn ProviderTrait>>>,
    exports_instances: FxHashSet<String>,
    metadata: Box<dyn ModuleMetadata>,
}

impl Module {
    pub fn new(token: &str, name: &str, metadata: Box<dyn ModuleMetadata>) -> Self {
        Self {
            _token: token.to_owned(),
            _name: name.to_string(),
            controllers: FxHashMap::default(),
            providers: FxHashMap::default(),
            imports: FxHashSet::default(),
            exports: FxHashSet::default(),
            controllers_instances: FxHashMap::default(),
            providers_instances: FxHashMap::default(),
            exports_instances: FxHashSet::default(),
            metadata,
        }
    }
}
impl Module {
    pub fn add_controller(&mut self, controller: Box<dyn Controller>) {
        self.controllers.insert(controller.get_name(), controller);
    }

    pub fn add_provider(&mut self, provider: Box<dyn Provider>) {
        self.providers.insert(provider.get_name(), provider);
    }

    pub fn add_import(&mut self, module_token: String) {
        self.imports.insert(module_token);
    }

    pub fn add_export(&mut self, provider_token: String) {
        self.exports.insert(provider_token);
    }

    pub fn add_controller_instance(&mut self, controller: Arc<Box<dyn ControllerTrait>>) {
        self.controllers_instances
            .insert(controller.get_token(), controller);
    }
    pub fn add_provider_instance(&mut self, provider: Arc<Box<dyn ProviderTrait>>) {
        self.providers_instances
            .insert(provider.get_token(), provider);
    }
    pub fn add_export_instance(&mut self, provider_token: String) {
        self.exports_instances.insert(provider_token);
    }

    pub fn get_providers_manager(&self) -> &FxHashMap<String, Box<dyn Provider>> {
        &self.providers
    }

    pub fn get_providers_instances(&self) -> &FxHashMap<String, Arc<Box<dyn ProviderTrait>>> {
        &self.providers_instances
    }

    pub fn get_provider_by_token(&self, provider_token: &String) -> Option<&dyn Provider> {
        self.providers.get(provider_token).map(|provider| provider.as_ref())
    }

    pub fn get_provider_instance_by_token(
        &self,
        provider_token: &String,
    ) -> Option<&Arc<Box<dyn ProviderTrait>>> {
        self.providers_instances.get(provider_token)
    }

    pub fn get_controllers_manager(&self) -> &FxHashMap<String, Box<dyn Controller>> {
        &self.controllers
    }

    pub fn drain_controllers_instances(&mut self) -> Drain<'_, String, Arc<Box<dyn ControllerTrait>>> {
        self.controllers_instances.drain()
    }

    pub fn get_imported_modules(&self) -> &FxHashSet<String> {
        &self.imports
    }

    pub fn get_exports_instances_tokens(&self) -> &FxHashSet<String> {
        &self.exports_instances
    }

    pub fn get_exports_tokens(&self) -> &FxHashSet<String> {
        &self.exports
    }

    pub fn get_metadata(&self) -> &dyn ModuleMetadata {
        &*self.metadata
    }

    pub fn _get_name(&self) -> &String {
        &self._name
    }

    pub fn _get_token(&self) -> &String {
        &self._token
    }

    pub fn _get_controller_by_token(
        &self,
        controller_token: &String,
    ) -> Option<&dyn Controller> {
        self.controllers.get(controller_token).map(|controller| controller.as_ref())
    }

    pub fn _get_controllers_instances(&self) -> &FxHashMap<String, Arc<Box<dyn ControllerTrait>>> {
        &self.controllers_instances
    }

    pub fn _take_controllers_instances(&mut self) -> FxHashMap<String, Arc<Box<dyn ControllerTrait>>> {
        std::mem::take(&mut self.controllers_instances)
    }
}