monster 0.1.28

Collection of random utilities
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

//!
//! # Example
//! ```
//! #[macro_use]
//! extern crate lazy_static;
//! extern crate monster;
//! 
//! use monster::incubation::global_init_cleanup::*;
//! 
//! lazy_static! {
//!     static ref INIT_HANDLE: GlobalInitHandle<MyLib> = InitHandle::new_global();
//! }
//! 
//! struct MyLib {
//!     init_handle: LocalInitHandle<MyLib>
//! }
//! 
//! impl MyLib {
//!     fn new() -> MyLib {
//!         MyLib {
//!             init_handle: InitHandle::from_global(&INIT_HANDLE)
//!         }
//!     }
//! }
//! 
//! impl InitCleanup for MyLib {
//!     fn init() { println!("LIB_INIT()"); }
//!     fn cleanup() { println!("LIB_CLEANUP()"); }
//! }
//! 
//! fn main() {
//!     let l1 = MyLib::new();
//!     let l2 = MyLib::new();
//!     let l3 = MyLib::new();
//! }
//! ```

use std::sync::{Arc,Weak,Mutex};
use std::marker;

pub trait InitCleanup {
    fn init();
    fn cleanup();
}

pub struct InitHandle<T: InitCleanup>(marker::PhantomData<T>);

impl <T: InitCleanup> InitHandle<T> {
    pub fn new_global() -> GlobalInitHandle<T> {
        Mutex::new(None)
    }

    pub fn from_global(handle: &Mutex<Option<Weak<InitHandle<T>>>>) -> LocalInitHandle<T> {
        let mut handle = handle.lock().unwrap();
        handle.as_ref()
        .and_then(Weak::upgrade)
        .unwrap_or_else(|| {
            let new_handle = Arc::new(InitHandle(marker::PhantomData));
            *handle = Some(Arc::downgrade(&new_handle));

            T::init();

            new_handle
        })
    }
}

impl <T: InitCleanup> Drop for InitHandle<T> {
    fn drop(&mut self) {
        T::cleanup()
    }
}


pub type GlobalInitHandle<T> = Mutex<Option<Weak<InitHandle<T>>>>;
pub type LocalInitHandle<T> = Arc<InitHandle<T>>;