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
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use { EventMapper, Payload, string };
use error::*;
use event::Event;
use event_handler_map::EventHandlerMap;
use file_funcs;
use libflo_func::{ FuncMapper, Parameter, Result as FuncResult };
use libflo_func::serialization::ParameterSerde;
use libflo_module::{ ModuleMapper, PathResolver, self_module_name };
use serialization::{ EventHandlersSerde, EventsSerde };
use std::collections::HashMap;

pub fn load(
    func_mapper: &FuncMapper,
    module_mapper: &ModuleMapper,
    path_resolver: &PathResolver
) -> Result<Payload> {
    let event_handlers = load_event_handlers(
        func_mapper,
        module_mapper,
        path_resolver
    )?;

    load_events(
        module_mapper,
        path_resolver,
        event_handlers
    )
}

fn create_event_handlers(
    func_mapper: &FuncMapper,
    module_mapper: &ModuleMapper,
    event_handlers_json: EventHandlersSerde,
    event_handler_map: &mut EventHandlerMap
) -> Result<()> {
    for event_handler in event_handlers_json.destructure() {
        let (event, functions, module) = event_handler.destructure();
        let handler_module_id = module_mapper.get(module)?;
        for function_json in functions {
            let (func_module, func) = function_json.destructure();
            let func_module_id = module_mapper.get(func_module)?;
            let func_id = func_mapper.get_id(func_module_id, func)?;
            let func = func_mapper.get(func_id)?;

            event_handler_map.add_function(handler_module_id, event.clone(), func.clone_into_box())?;
        }
    }

    Ok(())
}

fn create_events(
    module_name: &String,
    module_id: usize,
    events_json: EventsSerde,
    event_handlers: &mut EventHandlerMap,
    pre_event_list: &mut Vec<Event>,
    pre_event_map: &mut Vec<Option<HashMap<String, usize>>>,
) -> Result<()> {
    for event in events_json.destructure() {
        let (input, output, name) = event.destructure();

        let input = input.unwrap_or(ParameterSerde::none);
        let output = output.unwrap_or(ParameterSerde::none);
        let input =  FuncResult::<Parameter>::from(&input)?;
        let output =  FuncResult::<Parameter>::from(&output)?;
        let event_id = pre_event_list.len();

        if let Some(&None) = pre_event_map.get(module_id) {
            pre_event_map[module_id] = Some(HashMap::new());
        }

        if let Some(&mut Some(ref mut inner_event_map)) = pre_event_map.get_mut(module_id) {
            if let Some(_) = inner_event_map.insert(name.clone(), event_id) {
                return Err(ErrorKind::EventLoadNameCollision(name, module_name.clone()).into());
            }
        }

        let functions = event_handlers.take_functions(module_id, name);
        for function in &functions {
            let func_type = function.get_type();
            let event_type = (input, output);
            if func_type != event_type {
                return Err(ErrorKind::EventTypeFailure(func_type, event_type).into());
            }
        }

        let event = Event::new(functions);
        pre_event_list.push(event);
    }

    Ok(())
}

fn load_event_handlers(
    func_mapper: &FuncMapper,
    module_mapper: &ModuleMapper,
    path_resolver: &PathResolver,
) -> Result<EventHandlerMap> {
    let my_id = module_mapper.get(self_module_name())?;
    let event_handlers_file_name = string::event_handlers_file_name();

    let mut event_handlers = EventHandlerMap::new();

    for (_, module_id) in module_mapper.get_raw_map() {
        if let Some(event_handlers_json_path) = path_resolver.try_find_submodule_file_path(
            event_handlers_file_name,
            *module_id,
            my_id
        )? {
            let event_handlers_json = file_funcs::event_handlers_from_path(event_handlers_json_path)?;
            create_event_handlers(
                func_mapper,
                module_mapper,
                event_handlers_json,
                &mut event_handlers
            )?
        }
    }

    Ok(event_handlers)
}

fn load_events(
    module_mapper: &ModuleMapper,
    path_resolver: &PathResolver,
    mut event_handlers: EventHandlerMap
) -> Result<Payload> {
    let my_id = module_mapper.get(self_module_name())?;
    let events_file_name = string::events_file_name();

    let mut pre_event_list = Vec::new();
    let mut pre_event_map = module_mapper.get_raw_map().into_iter().map(|_| None).collect();

    for (module_name, module_id) in module_mapper.get_raw_map() {
        if let Some(events_json_path) = path_resolver.try_find_submodule_file_path(
            events_file_name,
            *module_id,
            my_id
        )? {
            let events_json = file_funcs::events_from_path(events_json_path)?;
            create_events(module_name, *module_id, events_json, &mut event_handlers, &mut pre_event_list, &mut pre_event_map)?;
        }
    }

    let event_mapper = EventMapper::new(pre_event_map, pre_event_list);

    let result =
        Payload::new(
            event_mapper
        );
    Ok(result)
}