apis/
example.rs

1//! Example generated program and sessions
2
3use super::*;
4
5def_program! {
6  program Myprogram where
7    let result = session.run()
8  {
9    MODES [
10      mode session_a::SessionA
11      mode session_b::SessionB
12    ]
13    TRANSITIONS  [
14      transition AtoB <session_a::SessionA> => <session_b::SessionB>
15    ]
16    initial_mode: SessionA
17  }
18}
19
20pub mod session_a {
21  use crate::*;
22
23  def_session! {
24    context SessionA {
25      PROCESSES where
26        let process    = self,
27        let message_in = message_in
28      [
29        process Chargen (update_count : u64) {
30          kind {
31            process::Kind::Isochronous { tick_ms: 20, ticks_per_update: 1 }
32          }
33          sourcepoints   [Charstream]
34          endpoints      []
35          handle_message { unreachable!() }
36          update {
37            let mut result = process::ControlFlow::Continue;
38            if process.update_count % 5 == 0 {
39              result = process.send (
40                ChannelId::Charstream, Charstreammessage::Achar ('z')
41              ).into();
42            }
43            if process.update_count % 7 == 0 {
44              result = process.send (
45                ChannelId::Charstream, Charstreammessage::Achar ('y')
46              ).into();
47            }
48            if process.update_count % 9 == 0 {
49              result = process.send (
50                ChannelId::Charstream, Charstreammessage::Achar ('x')
51              ).into();
52            }
53            process.update_count += 1;
54            const MAX_UPDATES : u64 = 5;
55            assert!(process.update_count <= MAX_UPDATES);
56            if result == process::ControlFlow::Continue
57              && process.update_count == MAX_UPDATES
58            {
59              let _
60                = process.send (ChannelId::Charstream, Charstreammessage::Quit);
61              result = process::ControlFlow::Break;
62            }
63            result
64          }
65        }
66        //
67        //  process Upcase
68        //
69        process Upcase (history : String) {
70          kind           { process::Kind::asynchronous_default() }
71          sourcepoints   []
72          endpoints      [Charstream]
73          handle_message {
74            match message_in {
75              GlobalMessage::Charstreammessage (charstreammessage) => {
76                match charstreammessage {
77                  Charstreammessage::Quit => {
78                    process::ControlFlow::Break
79                  }
80                  Charstreammessage::Achar (ch) => {
81                    process.history.push (ch.to_uppercase().next().unwrap());
82                    process::ControlFlow::Continue
83                  }
84                }
85              }
86            }
87          }
88          update {
89            if *process.inner.state().id() == process::inner::StateId::Ended {
90              println!("upcase history final: {}", process.history);
91            } else {
92              println!("upcase history: {}", process.history);
93            }
94            process::ControlFlow::Continue
95          }
96        }
97      ]
98      CHANNELS  [
99        channel Charstream <Charstreammessage> (Simplex) {
100          producers [Chargen]
101          consumers [Upcase]
102        }
103      ]
104      MESSAGES [
105        message Charstreammessage {
106          Achar (char),
107          Quit
108        }
109      ]
110    }
111  }
112
113} // end context SessionA
114
115pub mod session_b {
116  use crate::*;
117
118  def_session! {
119    context SessionB {
120      PROCESSES where
121        let process    = self,
122        let message_in = message_in
123      [
124        //
125        //  process SeqGen
126        //
127        process SeqGen (update_count : u64) {
128          kind {
129            process::Kind::Isochronous { tick_ms: 20, ticks_per_update: 1 }
130          }
131          sourcepoints   [Seqints]
132          endpoints      []
133          handle_message { unreachable!() }
134          update {
135            let id = update_count % 4;
136            let mut result = process.send_to (
137              ChannelId::Seqints, id, Seqintsmessage::Anint (update_count)
138            ).into();
139            process.update_count += 1;
140            const MAX_UPDATES : u64 = 5;
141            if result == process::ControlFlow::Break
142              || MAX_UPDATES < process.update_count
143            {
144              // quit
145              let _ = process.send_to (
146                ChannelId::Seqints, ProcessId::Sum1, Seqintsmessage::Quit);
147              let _ = process.send_to (
148                ChannelId::Seqints, ProcessId::Sum2, Seqintsmessage::Quit);
149              let _ = process.send_to (
150                ChannelId::Seqints, ProcessId::Sum3, Seqintsmessage::Quit);
151              let _ = process.send_to (
152                ChannelId::Seqints, ProcessId::Sum4, Seqintsmessage::Quit);
153              result = process::ControlFlow::Break
154            }
155            result
156          }
157        }
158        //
159        //  process Sum1
160        //
161        process Sum1 (sum : u64) {
162          kind           { process::Kind::asynchronous_default() }
163          sourcepoints   []
164          endpoints      [Seqints]
165          handle_message {
166            match message_in {
167              GlobalMessage::Seqintsmessage (Seqintsmessage::Anint (anint)) => {
168                // continue
169                process.sum += anint;
170                process::ControlFlow::Continue
171              }
172              GlobalMessage::Seqintsmessage (Seqintsmessage::Quit) => {
173                // quit
174                process::ControlFlow::Break
175              }
176            }
177          }
178          update {
179            if *process.inner.state().id() == process::inner::StateId::Ended {
180              println!("sum 1 final: {}", process.sum);
181            } else {
182              println!("sum 1: {}", process.sum);
183            }
184            process::ControlFlow::Continue
185          }
186        }
187        //
188        //  process Sum2
189        //
190        process Sum2 (sum : u64) {
191          kind           { process::Kind::asynchronous_default() }
192          sourcepoints   []
193          endpoints      [Seqints]
194          handle_message {
195            match message_in {
196              GlobalMessage::Seqintsmessage (Seqintsmessage::Anint (anint)) => {
197                // continue
198                process.sum += anint;
199                process::ControlFlow::Continue
200              }
201              GlobalMessage::Seqintsmessage (Seqintsmessage::Quit) => {
202                // quit
203                process::ControlFlow::Break
204              }
205            }
206          }
207          update {
208            if *process.inner.state().id() == process::inner::StateId::Ended {
209              println!("sum 2 final: {}", process.sum);
210            } else {
211              println!("sum 2: {}", process.sum);
212            }
213            process::ControlFlow::Continue
214          }
215        }
216        //
217        //  process Sum3
218        //
219        process Sum3 (sum : u64) {
220          kind           { process::Kind::asynchronous_default() }
221          sourcepoints   []
222          endpoints      [Seqints]
223          handle_message {
224            match message_in {
225              GlobalMessage::Seqintsmessage (Seqintsmessage::Anint (anint)) => {
226                // continue
227                process.sum += anint;
228                process::ControlFlow::Continue
229              }
230              GlobalMessage::Seqintsmessage (Seqintsmessage::Quit) => {
231                // quit
232                process::ControlFlow::Break
233              }
234            }
235          }
236          update {
237            if *process.inner.state().id() == process::inner::StateId::Ended {
238              println!("sum 3 final: {}", process.sum);
239            } else {
240              println!("sum 3: {}", process.sum);
241            }
242            process::ControlFlow::Continue
243          }
244        }
245        //
246        //  process Sum4
247        //
248        process Sum4 (sum : u64) {
249          kind           { process::Kind::asynchronous_default() }
250          sourcepoints   []
251          endpoints      [Seqints]
252          handle_message {
253            match message_in {
254              GlobalMessage::Seqintsmessage (Seqintsmessage::Anint (anint)) => {
255                // continue
256                process.sum += anint;
257                process::ControlFlow::Continue
258              }
259              GlobalMessage::Seqintsmessage (Seqintsmessage::Quit) => {
260                // quit
261                process::ControlFlow::Break
262              }
263            }
264          }
265          update {
266            if *process.inner.state().id() == process::inner::StateId::Ended {
267              println!("sum 4 final: {}", process.sum);
268            } else {
269              println!("sum 4: {}", process.sum);
270            }
271            process::ControlFlow::Continue
272          }
273        }
274      ]
275      CHANNELS  [
276        channel Seqints <Seqintsmessage> (Source) {
277          producers [SeqGen]
278          consumers [Sum1, Sum2, Sum3, Sum4]
279        }
280      ]
281      MESSAGES [
282        message Seqintsmessage {
283          Anint (u64),
284          Quit
285        }
286      ]
287    }
288  } // end context SessionB
289}
apis/example.rs

apis/
example.rs
