dispatch-core 0.3.0

A small, no_std, table-driven dispatch core
Documentation
use dispatch_core::{Dispatcher, Matcher};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Command {
    Read,
    Write,
}

struct Request {
    command: Command,
    value: u32,
}

#[derive(Debug, PartialEq, Eq)]
struct Response {
    value: u32,
}

#[derive(Debug, PartialEq, Eq)]
enum Error {
    Overflow,
}

#[derive(Default)]
struct AppState {
    execution_count: u32,
}

type RouteHandler = fn(&Request, &mut AppState) -> Result<Response, Error>;

struct Route {
    command: Command,
    handler: RouteHandler,
}

struct CommandMatcher;

impl Matcher<Route, Request> for CommandMatcher {
    fn matches(&self, route: &Route, request: &Request) -> bool {
        route.command == request.command
    }
}

fn read(request: &Request, state: &mut AppState) -> Result<Response, Error> {
    state.execution_count += 1;
    Ok(Response {
        value: request.value,
    })
}

fn double(request: &Request, state: &mut AppState) -> Result<Response, Error> {
    state.execution_count += 1;
    let value = request.value.checked_mul(2).ok_or(Error::Overflow)?;
    Ok(Response { value })
}

fn main() {
    let routes = [
        Route {
            command: Command::Read,
            handler: read,
        },
        Route {
            command: Command::Write,
            handler: double,
        },
    ];
    let dispatcher = Dispatcher::new(&routes, CommandMatcher);
    let mut state = AppState::default();
    let request = Request {
        command: Command::Write,
        value: 21,
    };

    let response = dispatcher
        .dispatch(&request, |route, request| {
            (route.handler)(request, &mut state)
        })
        .unwrap();

    assert_eq!(response, Response { value: 42 });
    assert_eq!(state.execution_count, 1);
    println!(
        "value={}, execution_count={}",
        response.value, state.execution_count
    );
}