hypospray 0.1.2

Lightweight dependency injection 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

use std::ops::{Deref, DerefMut};
use super::{Component, ComponentImp};

// TODO (DEVELOPMENT.md)
// [Ability to automatically derive traits on newtypes (RFC)](https://git.io/vMICm)
// [repr](https://doc.rust-lang.org/nomicon/repr-rust.html)
#[repr(C)]
pub struct Co<M, T>(pub M::ComponentImp)
    where M: ?Sized + Component<T>, 
          T: ?Sized;

impl<M, T> Co<M, T>
    where M: ?Sized + Component<T>, 
          T: ?Sized {
    
    pub fn new<'imp>(component_imp: &'imp M::ComponentImp) -> &'imp Co<M, T> {
        
        let ptr = component_imp as *const _ as *const Co<M, T>;
        
        unsafe {
            &*ptr
        }
    }
}

impl<M, T> Clone for Co<M, T>
    where M: ?Sized + Component<T>, 
          M::ComponentImp: Clone,
          T: ?Sized {
              
    fn clone(&self) -> Co<M, T> {
    
        let &Co(ref component_imp) = self;
        Co(component_imp.clone())
    }
       
    // TODO (DEVELOPMENT.md)
    // From [doc.rust-lang][1]: `clone_from` can be overridden to reuse the resources of a to avoid 
    // unnecessary allocations.
    //
    // [1]: https://doc.rust-lang.org/std/clone/trait.Clone.html
    fn clone_from(&mut self, source: &Co<M, T>) {
        
        self.0.clone_from(&source.0);
    }
}

impl<M, T> Copy for Co<M, T>
    where M: ?Sized + Component<T>, 
          M::ComponentImp: Clone + Copy,
          T: ?Sized {
              
}

impl<M, T> Deref for Co<M, T>
    where M: ?Sized + Component<T>, 
          T: ?Sized {
    
    type Target = T;
    
    fn deref(&self) -> &T {

        let &Co(ref component_imp) = self;
        component_imp.__as_ref()
    }
}

impl<M, T> DerefMut for Co<M, T>
    where M: ?Sized + Component<T>, 
          T: ?Sized {
    
    fn deref_mut(&mut self) -> &mut T {

        let &mut Co(ref mut component_imp) = self;
        component_imp.__as_mut()
    }
}