dispatch-core 0.2.0

A small, no_std, table-driven dispatch core
Documentation
use core::cell::Cell;

use dispatch_core::{DispatchError, Dispatcher, Handler, Matcher};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TestError {
    Failed,
}

#[derive(Default)]
struct TestContext {
    total: u16,
}

struct Rule {
    key: u8,
    value: u8,
    fails: bool,
    calls: Cell<u8>,
}

impl Handler for Rule {
    type Input = u8;
    type Context = TestContext;
    type Output = u8;
    type Error = TestError;

    fn handle(
        &self,
        _input: &Self::Input,
        context: &mut Self::Context,
    ) -> Result<Self::Output, Self::Error> {
        self.calls.set(self.calls.get() + 1);

        if self.fails {
            return Err(TestError::Failed);
        }

        context.total += u16::from(self.value);
        Ok(self.value)
    }
}

struct CountingMatcher {
    calls: Cell<u8>,
}

impl Matcher<Rule, u8> for CountingMatcher {
    fn matches(&self, item: &Rule, input: &u8) -> bool {
        self.calls.set(self.calls.get() + 1);
        item.key == *input
    }
}

fn rule(key: u8, value: u8) -> Rule {
    Rule {
        key,
        value,
        fails: false,
        calls: Cell::new(0),
    }
}

#[test]
fn dispatches_to_the_first_matching_item() {
    let table = [rule(1, 10), rule(1, 20)];
    let matcher = CountingMatcher {
        calls: Cell::new(0),
    };
    let dispatcher = Dispatcher::new(&table, matcher);
    let mut context = TestContext::default();

    let output = dispatcher.dispatch(&1, &mut context).unwrap();

    assert_eq!(output, 10);
    assert_eq!(context.total, 10);
    assert_eq!(table[0].calls.get(), 1);
    assert_eq!(table[1].calls.get(), 0);
    assert_eq!(dispatcher.matcher().calls.get(), 1);
}

#[test]
fn select_does_not_execute_the_item() {
    let table = [rule(1, 10)];
    let dispatcher = Dispatcher::new(&table, |item: &Rule, input: &u8| item.key == *input);

    let selected = dispatcher.select(&1).unwrap();

    assert_eq!(selected.value, 10);
    assert_eq!(selected.calls.get(), 0);
}

#[test]
fn returns_not_found_without_changing_context() {
    let table = [rule(1, 10)];
    let dispatcher = Dispatcher::new(&table, |item: &Rule, input: &u8| item.key == *input);
    let mut context = TestContext::default();

    let result = dispatcher.dispatch(&2, &mut context);

    assert_eq!(result, Err(DispatchError::NotFound));
    assert_eq!(context.total, 0);
    assert_eq!(table[0].calls.get(), 0);
}

#[test]
fn wraps_handler_errors() {
    let mut failing_rule = rule(1, 10);
    failing_rule.fails = true;
    let table = [failing_rule];
    let dispatcher = Dispatcher::new(&table, |item: &Rule, input: &u8| item.key == *input);
    let mut context = TestContext::default();

    let result = dispatcher.dispatch(&1, &mut context);

    assert_eq!(result, Err(DispatchError::Execute(TestError::Failed)));
    assert_eq!(context.total, 0);
    assert_eq!(table[0].calls.get(), 1);
}

struct PureRule;

impl Handler for PureRule {
    type Input = u8;
    type Context = ();
    type Output = u8;
    type Error = TestError;

    fn handle(
        &self,
        input: &Self::Input,
        _context: &mut Self::Context,
    ) -> Result<Self::Output, Self::Error> {
        Ok(input.saturating_mul(2))
    }
}

#[test]
fn supports_handlers_without_runtime_context() {
    let table = [PureRule];
    let dispatcher = Dispatcher::new(&table, |_item: &PureRule, _input: &u8| true);

    assert_eq!(dispatcher.dispatch(&21, &mut ()), Ok(42));
}

#[test]
fn exposes_and_returns_its_configuration() {
    let table = [rule(1, 10)];
    let mut dispatcher = Dispatcher::new(
        &table,
        CountingMatcher {
            calls: Cell::new(0),
        },
    );

    assert_eq!(dispatcher.table().len(), 1);
    dispatcher.matcher_mut().calls.set(3);
    assert_eq!(dispatcher.matcher().calls.get(), 3);

    let (returned_table, returned_matcher) = dispatcher.into_parts();
    assert_eq!(returned_table.len(), 1);
    assert_eq!(returned_matcher.calls.get(), 3);
}