xdevs 0.4.0

An open source DEVS M&S framework.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use crate::{impl_coupled, modeling::Coupled};
use std::str::FromStr;

pub mod generator;
pub mod processor;
pub mod transducer;

pub use generator::Generator;
pub use processor::Processor;
pub use transducer::Transducer;

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Job(pub usize, pub f64);

impl std::fmt::Display for Job {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "({}, {})", self.0, self.1)
    }
}

pub struct ParseError();

impl FromStr for Job {
    type Err = ParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        // parse something like "(id, time)"
        let s = s.trim();
        if s.starts_with('(') && s.ends_with(')') {
            let s = &s[1..s.len() - 1];
            let mut parts = s.split(',');
            let id = parts
                .next()
                .ok_or(ParseError())?
                .trim()
                .parse()
                .map_err(|_| ParseError())?;
            let time = parts
                .next()
                .ok_or(ParseError())?
                .trim()
                .parse()
                .map_err(|_| ParseError())?;
            if parts.next().is_none() {
                Ok(Self(id, time))
            } else {
                Err(ParseError())
            }
        } else {
            Err(ParseError())
        }
    }
}

pub struct Gpt {
    coupled: Coupled,
}

impl Gpt {
    pub fn new(name: &str, req_period: f64, proc_time: f64, obs_time: f64) -> Self {
        let mut coupled = Coupled::new(name);

        let generator = Generator::new("generator", req_period);
        let processor = Processor::new("processor", proc_time);
        let transducer = Transducer::new("transducer", obs_time);

        coupled.add_component(Box::new(generator));
        coupled.add_component(Box::new(processor));
        coupled.add_component(Box::new(transducer));

        coupled.add_ic("generator", "output_req", "processor", "input_req");
        coupled.add_ic("generator", "output_req", "transducer", "input_req");
        coupled.add_ic("processor", "output_res", "transducer", "input_res");
        coupled.add_ic("transducer", "output_stop", "generator", "input_stop");

        Self { coupled }
    }
}

impl_coupled!(Gpt);

pub struct ExperimentalFrame {
    coupled: Coupled,
}

impl ExperimentalFrame {
    pub fn new(name: &str, req_period: f64, obs_time: f64) -> Self {
        let mut coupled = Coupled::new(name);

        coupled.add_in_port::<Job>("input_res");
        coupled.add_out_port::<usize>("output_req");

        let generator = Generator::new("generator", req_period);
        let transducer = Transducer::new("transducer", obs_time);

        coupled.add_component(Box::new(generator));
        coupled.add_component(Box::new(transducer));

        coupled.add_eic("input_res", "transducer", "input_res");
        coupled.add_ic("generator", "output_req", "transducer", "input_req");
        coupled.add_ic("transducer", "output_stop", "generator", "input_stop");
        coupled.add_eoc("generator", "output_req", "output_req");

        Self { coupled }
    }
}

impl_coupled!(ExperimentalFrame);

pub struct Efp {
    coupled: Coupled,
}

impl Efp {
    pub fn new(name: &str, req_period: f64, proc_time: f64, obs_time: f64) -> Self {
        let mut coupled = Coupled::new(name);

        let ef = ExperimentalFrame::new("ef", req_period, obs_time);
        let processor = Processor::new("processor", proc_time);

        coupled.add_component(Box::new(ef));
        coupled.add_component(Box::new(processor));

        coupled.add_ic("ef", "output_req", "processor", "input_req");
        coupled.add_ic("processor", "output_res", "ef", "input_res");

        Self { coupled }
    }
}

impl_coupled!(Efp);