Skip to main content

command_dispatch/
command_dispatch.rs

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}