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
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

use crate::parser::RlError;
use std::collections::HashMap;

use super::*;

#[derive(Debug, Clone)]
pub struct Transition {
    src: Reference<StateId>,
    dst: Reference<StateId>,
}

impl Transition {
    pub fn new(src: Reference<StateId>, dst: Reference<StateId>) -> Self {
        Self { src, dst }
    }

    pub fn src(&self) -> &Reference<StateId> {
        &self.src
    }

    pub fn dst(&self) -> &Reference<StateId> {
        &self.dst
    }
}

impl Transition {
    pub fn resolve(&mut self, map: &HashMap<String, StateId>) -> Result<(), RlError> {
        self.resolve_src(map)?;
        self.resolve_dst(map)
    }

    pub fn resolve_src(&mut self, map: &HashMap<String, StateId>) -> Result<(), RlError> {
        match &self.src {
            Reference::Unresolved(name, pos) => match map.get(name) {
                Some(id) => {
                    self.src = Reference::Resolved(*id);
                    Ok(())
                }
                None => Err(RlError::Resolve {
                    element: format!("state '{}'", name),
                    position: pos.clone(),
                }),
            },
            Reference::Resolved(_) => Ok(()),
        }
    }
    pub fn resolve_dst(&mut self, map: &HashMap<String, StateId>) -> Result<(), RlError> {
        match &self.dst {
            Reference::Unresolved(name, pos) => match map.get(name) {
                Some(id) => {
                    self.dst = Reference::Resolved(*id);
                    Ok(())
                }
                None => Err(RlError::Resolve {
                    element: format!("state '{}'", name),
                    position: pos.clone(),
                }),
            },
            Reference::Resolved(_) => Ok(()),
        }
    }
}

impl ToLang for Transition {
    fn to_lang(&self, skillset: &Skillset) -> String {
        format!(
            "{} -> {}",
            self.src.to_lang(skillset),
            self.dst.to_lang(skillset)
        )
    }
}

//-------------------------------------------------- Transitions --------------------------------------------------

#[derive(Debug, Clone)]
pub enum Transitions {
    All,
    List(Vec<Transition>),
}

impl Transitions {
    pub fn resolve(&mut self, map: &HashMap<String, StateId>) -> Result<(), RlError> {
        match self {
            Transitions::All => Ok(()),
            Transitions::List(l) => {
                for x in l {
                    x.resolve(map)?;
                }
                Ok(())
            }
        }
    }
}

impl ToLang for Transitions {
    fn to_lang(&self, skillset: &Skillset) -> String {
        match self {
            Transitions::All => format!("\t\t\ttransition all\n"),
            Transitions::List(l) => {
                let mut s = String::from("\t\t\ttransition {\n");
                for x in l {
                    s.push_str(&format!("\t\t\t\t{}\n", x.to_lang(skillset)));
                }
                s.push_str("\t\t\t}\n");
                s
            }
        }
    }
}