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
78
79
80
81
82
83
84
85
86
87

use error::*;
use appscraps_module::util::ModuleList;
use appscraps_module::util::ModuleMap;
use appscraps_module::util::PathResolver;
use load::file_funcs;
use load::Payload;
use serialization::DynamicEvents;
use std::collections::BTreeMap;
use string;
use util::DynamicEventList;
use util::DynamicEventMap;

pub struct DynamicEventLoader { }

impl DynamicEventLoader {
    pub fn load(
        module_list: &ModuleList,
        module_map: &ModuleMap,
        path_resolver: &PathResolver
    ) -> Result<Payload> {
        Self::load_events(
            module_list,
            module_map,
            path_resolver,
        )
    }

    fn create_dynamic_events(
        module_index: usize,
        dynamic_events_json: DynamicEvents,
        pre_dynamic_event_list: &mut Vec<String>,
        pre_dynamic_event_map: &mut BTreeMap<(usize, String), usize>,
    ) -> Result<()> {
        for dynamic_event in dynamic_events_json.destructure() {
            let dynamic_event_id = pre_dynamic_event_list.len();
            let dynamic_event_key = (module_index, dynamic_event.clone());

            if let Some(_) = pre_dynamic_event_map.insert(dynamic_event_key, dynamic_event_id) {
                return Err(ErrorKind::EventAlreadyExists(dynamic_event, module_index).into())
            }

            pre_dynamic_event_list.push(dynamic_event);
        }

        Ok(())
    }

    fn load_events(
        module_list: &ModuleList,
        module_map: &ModuleMap,
        path_resolver: &PathResolver,
    ) -> Result<Payload> {
        let my_index = try!(module_map.get_index(string::self_appscraps_module_name()));
        let dynamic_events_file_name = string::dynamic_events_file_name();

        let mut pre_dynamic_event_list = Vec::new();
        let mut pre_dynamic_event_map = BTreeMap::new();

        for module in module_list {
            let module_index = module.get_index();

            if let Some(dynamic_events_json_path) =
                try!(
                    path_resolver.try_find_submodule_file_path(
                        dynamic_events_file_name,
                        module_index,
                        my_index
                    )
                ) {
                let dynamic_events_json = try!(file_funcs::dynamic_events_from_path(dynamic_events_json_path));
                try!(
                    Self::create_dynamic_events(module_index, dynamic_events_json, &mut pre_dynamic_event_list, &mut pre_dynamic_event_map)
                );
            }
        }

        let dynamic_event_list = DynamicEventList::new(pre_dynamic_event_list);
        let dynamic_event_map = DynamicEventMap::new(pre_dynamic_event_map);

        let result =
            Payload::new(
                dynamic_event_list,
                dynamic_event_map
            );
        Ok(result)
    }
}