arthas 0.3.0

Arthas is an in-memory structure database.
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


mod config;

use std::sync::{RwLock, Once, ONCE_INIT};
use std::mem;
use std::collections::HashMap;
use std::path::PathBuf;
use self::config::Config;
use memory::Memory;
use persistence::Persistence;
use traits::Structure;


pub type MemoryStore = HashMap<String, RwLock<Memory>>;
pub type PersistenceStore = HashMap<String, RwLock<Persistence>>;

pub trait MemoryGetter {
    fn get_memory<T: Structure>(&self) -> &RwLock<Memory>;
}

impl MemoryGetter for MemoryStore {
    fn get_memory<T: Structure>(&self) -> &RwLock<Memory> {
        self.get(&T::get_struct_name()).unwrap()
    }
}


pub fn memories<'a>() -> &'a RwLock<MemoryStore> {
    static mut MEMORIES: *const RwLock<MemoryStore> = 0 as *const RwLock<MemoryStore>;
    static ONCE: Once = ONCE_INIT;

    unsafe {
        ONCE.call_once(|| MEMORIES = mem::transmute(Box::new(RwLock::new(MemoryStore::new()))));
        &*MEMORIES
    }
}

pub fn persistences<'a>() -> &'a RwLock<PersistenceStore> {
    static mut PERSISTENCES: *const RwLock<PersistenceStore> = 0 as *const RwLock<PersistenceStore>;
    static ONCE: Once = ONCE_INIT;

    unsafe {
        ONCE.call_once(|| {
            PERSISTENCES = mem::transmute(Box::new(RwLock::new(PersistenceStore::new())))
        });
        &*PERSISTENCES
    }
}

pub fn config<'a>() -> &'a RwLock<Config> {
    static mut CONFIG: *const RwLock<Config> = 0 as *const RwLock<Config>;
    static ONCE: Once = ONCE_INIT;

    unsafe {
        ONCE.call_once(|| CONFIG = mem::transmute(Box::new(RwLock::new(Config::new()))));
        &*CONFIG
    }
}

#[inline]
pub fn is_persistence() -> bool {
    config().read().unwrap().persistence
}

#[inline]
pub fn get_path() -> PathBuf {
    config().read().unwrap().path.clone()
}

#[inline]
pub fn get_extension_path(struct_name: &str, ext: &'static str) -> PathBuf {
    PathBuf::from(format!("{}/{}.{}", get_path().display(), struct_name, ext))
}