mproto-codegen 0.0.6

library to parse and generate code for mproto schemas
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
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

use std::collections::HashMap;

use crate::ast::{QualifiedIdentifier, TypeDef, TypeDefId};

pub struct Module {
    type_defs: Vec<TypeDef>,
    type_defs_by_name: HashMap<String, TypeDefId>,
}

impl Module {
    pub fn new() -> Self {
        Self {
            type_defs: Vec::new(),
            type_defs_by_name: HashMap::new(),
        }
    }

    pub fn type_defs(&self) -> impl Iterator<Item = &TypeDef> {
        self.type_defs.iter()
    }

    pub fn from_type_defs(type_defs: Vec<TypeDef>) -> Self {
        let type_defs_by_name = type_defs
            .iter()
            .enumerate()
            .map(|(i, type_def)| (type_def.name.clone(), TypeDefId(i)))
            .collect();

        Self {
            type_defs,
            type_defs_by_name,
        }
    }

    pub fn new_type_def(&mut self, type_def: TypeDef) -> TypeDefId {
        let id = TypeDefId(self.type_defs.len());

        self.type_defs_by_name.insert(type_def.name.clone(), id);
        self.type_defs.push(type_def);

        id
    }

    pub fn type_def(&self, id: TypeDefId) -> &TypeDef {
        &self.type_defs[id.0]
    }

    pub fn type_def_by_name<'a>(&'a self, name: &str) -> Option<&'a TypeDef> {
        Some(self.type_def(*self.type_defs_by_name.get(name)?))
    }
}

struct DatabaseImport {
    lib_suffix: String,
    module: Module,
}

pub struct Database {
    imports: HashMap<String, DatabaseImport>,
    local: Module,
}

impl Database {
    pub fn new(local: Module) -> Self {
        Self {
            imports: HashMap::new(),
            local,
        }
    }

    pub fn local(&self) -> &Module {
        &self.local
    }

    pub fn local_mut(&mut self) -> &mut Module {
        &mut self.local
    }

    pub fn add_module(&mut self, name: String, lib_suffix: impl Into<String>, module: Module) {
        self.imports.insert(
            name,
            DatabaseImport {
                lib_suffix: lib_suffix.into(),
                module,
            },
        );
    }

    pub fn imported_module_mut(&mut self, module_name: &str) -> Option<&mut Module> {
        Some(&mut self.imports.get_mut(module_name)?.module)
    }

    pub fn lookup_module_lib_suffix<'a>(&'a self, module_name: &str) -> Option<&'a str> {
        let import = self.imports.get(module_name)?;
        Some(&import.lib_suffix)
    }

    pub fn lookup_type_def<'a>(&'a self, identifier: &QualifiedIdentifier) -> Option<&'a TypeDef> {
        if let Some(ref module_name) = identifier.module {
            // Importing from another module.
            let import = self.imports.get(module_name)?;
            import.module.type_def_by_name(&identifier.name)
        } else {
            // It's a local definition.
            self.local.type_def_by_name(&identifier.name)
        }
    }
}