Skip to main content

command_dispatch/
command_dispatch.rs

1use dispatch_core::{Dispatcher, Handler, Matcher};
2
3#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4enum Command {
5    Read,
6    Write,
7}
8
9struct Request {
10    command: Command,
11    value: u32,
12}
13
14#[derive(Debug, PartialEq, Eq)]
15struct Response {
16    value: u32,
17}
18
19#[derive(Debug, PartialEq, Eq)]
20enum Error {
21    Overflow,
22}
23
24#[derive(Default)]
25struct AppContext {
26    execution_count: u32,
27}
28
29type RouteHandler = fn(&Request, &mut AppContext) -> Result<Response, Error>;
30
31struct Route {
32    command: Command,
33    handler: RouteHandler,
34}
35
36impl Handler for Route {
37    type Input = Request;
38    type Context = AppContext;
39    type Output = Response;
40    type Error = Error;
41
42    fn handle(
43        &self,
44        request: &Self::Input,
45        context: &mut Self::Context,
46    ) -> Result<Self::Output, Self::Error> {
47        (self.handler)(request, context)
48    }
49}
50
51struct CommandMatcher;
52
53impl Matcher<Route, Request> for CommandMatcher {
54    fn matches(&self, route: &Route, request: &Request) -> bool {
55        route.command == request.command
56    }
57}
58
59fn read(request: &Request, context: &mut AppContext) -> Result<Response, Error> {
60    context.execution_count += 1;
61    Ok(Response {
62        value: request.value,
63    })
64}
65
66fn double(request: &Request, context: &mut AppContext) -> Result<Response, Error> {
67    context.execution_count += 1;
68    let value = request.value.checked_mul(2).ok_or(Error::Overflow)?;
69    Ok(Response { value })
70}
71
72fn main() {
73    let routes = [
74        Route {
75            command: Command::Read,
76            handler: read,
77        },
78        Route {
79            command: Command::Write,
80            handler: double,
81        },
82    ];
83    let dispatcher = Dispatcher::new(&routes, CommandMatcher);
84    let mut context = AppContext::default();
85    let request = Request {
86        command: Command::Write,
87        value: 21,
88    };
89
90    let response = dispatcher.dispatch(&request, &mut context).unwrap();
91
92    assert_eq!(response, Response { value: 42 });
93    assert_eq!(context.execution_count, 1);
94    println!(
95        "value={}, execution_count={}",
96        response.value, context.execution_count
97    );
98}