1use dispatch_core::{
2 CommandEntry, CommandKey, Dispatcher, KeyMatcher, Res, ResMut, command, resources,
3};
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6enum Opcode {
7 Version,
8 Send,
9 SignAndSend,
10}
11
12struct Context {
13 opcode: Opcode,
14 payload: u32,
15}
16
17impl CommandKey<Opcode> for Context {
18 fn command_key(&self) -> &Opcode {
19 &self.opcode
20 }
21}
22
23#[derive(Default)]
24struct Io {
25 last_value: u32,
26 writes: u32,
27}
28
29struct Crypto {
30 key: u32,
31}
32
33#[derive(Default)]
34struct Audit {
35 before_calls: u32,
36 after_calls: u32,
37 response_calls: u32,
38}
39
40resources! {
41 struct Resources {
42 io: Io,
43 crypto: Crypto,
44 audit: Audit,
45 }
46}
47
48#[derive(Debug, PartialEq, Eq)]
49struct Response {
50 value: u32,
51}
52
53#[derive(Debug, PartialEq, Eq)]
54struct WireResponse {
55 status: u8,
56 value: u32,
57}
58
59#[derive(Debug, PartialEq, Eq)]
60enum Error {
61 Overflow,
62}
63
64fn version(_context: &mut Context) -> Result<Response, Error> {
65 Ok(Response { value: 3 })
66}
67
68fn send(context: &mut Context, mut io: ResMut<'_, Io>) -> Result<Response, Error> {
69 io.last_value = context.payload;
70 io.writes += 1;
71 Ok(Response {
72 value: io.last_value,
73 })
74}
75
76fn sign_and_send(
77 context: &mut Context,
78 crypto: Res<'_, Crypto>,
79 mut io: ResMut<'_, Io>,
80) -> Result<Response, Error> {
81 let signed = context
82 .payload
83 .checked_add(crypto.key)
84 .ok_or(Error::Overflow)?;
85 io.last_value = signed;
86 io.writes += 1;
87 Ok(Response { value: signed })
88}
89
90fn before(_context: &mut Context, mut audit: ResMut<'_, Audit>) -> Result<(), Error> {
91 audit.before_calls += 1;
92 Ok(())
93}
94
95fn after(
96 _context: &mut Context,
97 _response: &mut Response,
98 mut audit: ResMut<'_, Audit>,
99) -> Result<(), Error> {
100 audit.after_calls += 1;
101 Ok(())
102}
103
104fn response(
105 _context: &mut Context,
106 response: Response,
107 mut audit: ResMut<'_, Audit>,
108) -> Result<WireResponse, Error> {
109 audit.response_calls += 1;
110 Ok(WireResponse {
111 status: 0,
112 value: response.value,
113 })
114}
115
116type Entry = CommandEntry<Opcode, Context, Resources, Response, Error>;
117
118static COMMANDS: &[Entry] = &[
119 command!(Opcode::Version => version),
120 command!(Opcode::Send => send),
121 command!(Opcode::SignAndSend => sign_and_send),
122];
123
124fn main() {
125 let mut context = Context {
126 opcode: Opcode::SignAndSend,
127 payload: 40,
128 };
129 let mut resources = Resources {
130 io: Io::default(),
131 crypto: Crypto { key: 2 },
132 audit: Audit::default(),
133 };
134
135 let dispatcher = Dispatcher::new(COMMANDS, KeyMatcher)
136 .with_before(before)
137 .with_after(after)
138 .with_response(response);
139 let response = dispatcher.dispatch(&mut context, &mut resources).unwrap();
140
141 assert_eq!(
142 response,
143 WireResponse {
144 status: 0,
145 value: 42,
146 }
147 );
148 assert_eq!(resources.io.last_value, 42);
149 assert_eq!(resources.io.writes, 1);
150 assert_eq!(resources.audit.before_calls, 1);
151 assert_eq!(resources.audit.after_calls, 1);
152 assert_eq!(resources.audit.response_calls, 1);
153 println!(
154 "status={}, value={}, writes={}",
155 response.status, response.value, resources.io.writes
156 );
157}