dose 0.1.3

Your daily dose of structs and functions.
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

use log::debug;
use std::any::Any;
use std::any::TypeId;
use std::collections::HashMap;
use std::rc::Rc;

pub struct Context<C> {
    pub instances: HashMap<TypeId, Rc<dyn Any + 'static>>,
    pub config: C,
}

pub fn instance_id<R>() -> TypeId
where
    R: 'static,
{
    TypeId::of::<R>()
}

impl<C> Context<C> {
    pub fn new(config: C) -> Self {
        Self {
            instances: HashMap::new(),
            config,
        }
    }

    pub fn resolve_singleton<T, F>(&mut self, func_factory: F, name: &str) -> T
    where
        T: Clone + 'static,
        F: Fn(&mut Context<C>) -> T,
    {
        let instance_id = instance_id::<T>();
        let state = self.resolve_state_singleton(instance_id, func_factory, name);

        with_cast::<T>(state)
    }

    fn resolve_state_singleton<F, T>(
        &mut self,
        key: TypeId,
        create_func: F,
        name: &str,
    ) -> Rc<dyn Any + 'static>
    where
        F: Fn(&mut Context<C>) -> T,
        T: 'static,
    {
        let result = self.instances.get(&key);
        match result {
            Some(val) => {
                debug!("Global type '{}' found, cloning same instance.", name);
                val.clone()
            }
            None => {
                debug!("Global type '{}' not found, creating new instance.", name);
                let instance = create_func(self);
                let instance = Rc::new(instance);
                self.instances.insert(key, instance.clone());
                instance
            }
        }
    }
}

fn with_cast<T>(obj: Rc<dyn Any + 'static>) -> T
where
    T: Clone + 'static,
{
    let val = match obj.downcast::<T>() {
        Ok(val) => val,
        Err(err) => panic!("Internal error, unable to cast {:?}", err),
    };
    val.as_ref().clone()
}