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

pub mod serialization {
    pub use serialization::libflo_serde::LibfloSerde;

    mod libflo_serde {
        use libflo_dynamic_event::serialization::DynamicEventMapperSerde;
        use libflo_func::serialization::FuncMapperSerde;
        use libflo_module::serialization::ModuleMapperSerde;


        #[allow(non_upper_case_globals,
                unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_LibfloSerde: () =
            {
                extern crate serde as _serde;
                #[automatically_derived]
                impl <'a, 'b, 'c> _serde::ser::Serialize for
                 LibfloSerde<'a, 'b, 'c> {
                    fn serialize<__S>(&self, _serializer: &mut __S)
                     -> ::std::result::Result<(), __S::Error> where
                     __S: _serde::ser::Serializer {
                        let mut __serde_state =
                            try!(_serializer . serialize_struct (
                                 "LibfloSerde" , 0 + 1 + 1 + 1 ));
                        try!(_serializer . serialize_struct_elt (
                             & mut __serde_state , "dynamic_event_mapper" , &
                             self . dynamic_event_mapper ));
                        try!(_serializer . serialize_struct_elt (
                             & mut __serde_state , "func_mapper" , & self .
                             func_mapper ));
                        try!(_serializer . serialize_struct_elt (
                             & mut __serde_state , "module_mapper" , & self .
                             module_mapper ));
                        _serializer.serialize_struct_end(__serde_state)
                    }
                }
            };
        #[derive(PartialEq, Eq, Debug, Clone)]
        pub struct LibfloSerde<'a, 'b, 'c> {
            dynamic_event_mapper: DynamicEventMapperSerde<'a>,
            func_mapper: FuncMapperSerde<'b>,
            module_mapper: ModuleMapperSerde<'c>,
        }
        impl <'a, 'b, 'c> LibfloSerde<'a, 'b, 'c> {
            pub fn new(dynamic_event_mapper: DynamicEventMapperSerde<'a>,
                       func_mapper: FuncMapperSerde<'b>,
                       module_mapper: ModuleMapperSerde<'c>) -> Self {
                LibfloSerde{dynamic_event_mapper: dynamic_event_mapper,
                            func_mapper: func_mapper,
                            module_mapper: module_mapper,}
            }
        }
    }
}