rl_model-rs 0.2.2

'Robot Language' parser and rust model
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

use super::*;
use crate::parser::Position;
use std::collections::HashMap;

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub enum Reference<I: Id> {
    Unresolved(String, Option<Position>),
    Resolved(I),
}

impl<I: Id> Reference<I> {
    pub fn resolved(&self) -> I {
        match self {
            Reference::Unresolved(_, _) => panic!("reference must be resolved"),
            Reference::Resolved(id) => *id,
        }
    }

    pub fn resolve(&self, map: &HashMap<String, I>, info: &str) -> Result<Self, RlError> {
        match self {
            Reference::Unresolved(name, pos) => match map.get(name) {
                Some(id) => Ok(Self::Resolved(*id)),
                None => Err(RlError::Resolve {
                    element: format!("{} '{}'", info, name),
                    position: pos.clone(),
                }),
            },
            Reference::Resolved(_) => Ok(self.clone()),
        }
    }
}

impl ToLang for Reference<TypeId> {
    fn to_lang(&self, skillset: &Skillset) -> String {
        match self {
            Reference::Unresolved(name, _) => format!("{}/* ? */", name),
            Reference::Resolved(id) => format!("{}", skillset.get(*id).unwrap()),
        }
    }
}
impl ToLang for Reference<ResourceId> {
    fn to_lang(&self, skillset: &Skillset) -> String {
        match self {
            Reference::Unresolved(name, _) => format!("{}/* ? */", name),
            Reference::Resolved(id) => format!("{}", skillset.get(*id).unwrap()),
        }
    }
}

impl ToLang for Reference<StateId> {
    fn to_lang(&self, skillset: &Skillset) -> String {
        match self {
            Reference::Unresolved(name, _) => format!("{}/* ? */", name),
            Reference::Resolved(id) => format!("{}", skillset.get(*id).unwrap()),
        }
    }
}

// impl ToLang for Reference<DataId> {
//     fn to_lang(&self, skillset: &crate::Skillset) -> String {
//         match self {
//             Reference::Unresolved(name, _) => format!("{}/* ? */", name),
//             Reference::Resolved(id) => format!("{}", skillset.get(*id).unwrap()),
//         }
//     }
// }

// impl ToLang for Reference<SkillsetId> {
//     fn to_lang(&self, skillset: &crate::Model) -> String {
//         match self {
//             Reference::Unresolved(name, _) => format!("{}/* ? */", name),
//             Reference::Resolved(id) => format!("{}", skillset.get(*id).unwrap()),
//         }
//     }
// }

// impl ToLang for Reference<EventId> {
//     fn to_lang(&self, skillset: &Model) -> String {
//         match self {
//             Reference::Unresolved(name, _) => format!("{}/* ? */", name),
//             Reference::Resolved(id) => format!("{}", skillset.get(*id).unwrap()),
//         }
//     }
// }