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


use item::Id;
use serde_json::Value;
use super::rc::{RcItem, RcChild, RcNode};
use super::Tree;

pub struct Inserter {}

impl Inserter {
    pub fn insert(tree: &mut Tree, id: Id, value: Value) {
        thread_trace!("insert id: {}", id);
        let rc_item = RcItem::new(id.clone(), value);
        tree.id_map.insert(id.clone(), rc_item.clone());
        let datas = rc_item.read().unwrap().datas.clone();

        for (field_int, rc_data) in datas {
            if rc_data.read().unwrap().can_index() {
                let mut is_min = true;
                let mut is_max = true;

                thread_trace!("current insert field data: {:?}",
                              rc_data.read().unwrap().get_value());

                let rc_child = RcChild::new(rc_data, rc_item.clone());
                let root_exists = tree.root.contains_key(&field_int);

                if root_exists {
                    let node_option = tree.root
                        .get(&field_int)
                        .unwrap()
                        .write()
                        .unwrap()
                        .insert(field_int.clone(),
                                id.clone(),
                                rc_child,
                                &mut is_min,
                                &mut is_max);

                    if node_option.is_some() {
                        let rc_node = node_option.unwrap();
                        if is_min {
                            thread_trace!("found min node: {:?}",
                                          rc_node.read().unwrap().get_value());
                            tree.min.insert(field_int, rc_node);
                        } else if is_max {
                            thread_trace!("found max node: {:?}",
                                          rc_node.read().unwrap().get_value());
                            tree.max.insert(field_int, rc_node);
                        } else {
                            unreachable!()
                        }
                    }
                } else {
                    let rc_node = RcNode::new(id.clone(), rc_child);
                    rc_node.write().unwrap().self_rc = Some(rc_node.clone());
                    rc_item.write().unwrap().nodes.insert(field_int.clone(), rc_node.clone());
                    tree.root.insert(field_int, rc_node);
                }
            }
        }
    }
}