dispatch-core 0.3.0

A small, no_std, table-driven dispatch core
Documentation
use core::{cell::Cell, convert::Infallible, ptr};

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

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

struct Rule {
    key: u8,
    value: u8,
}

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 }
}

#[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 executor_calls = Cell::new(0);

    let output = dispatcher
        .dispatch(&1, |item, input| {
            executor_calls.set(executor_calls.get() + 1);
            assert_eq!(*input, 1);
            Ok::<_, Infallible>(item.value)
        })
        .unwrap();

    assert_eq!(output, 10);
    assert_eq!(executor_calls.get(), 1);
    assert_eq!(dispatcher.matcher().calls.get(), 1);
}

#[test]
fn select_does_not_execute_application_logic() {
    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);
}

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

    let result = dispatcher.dispatch(&2, |_item, _input| {
        executor_called.set(true);
        Ok::<_, Infallible>(())
    });

    assert_eq!(result, Err(DispatchError::NotFound));
    assert!(!executor_called.get());
}

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

    let result: Result<(), DispatchError<TestError>> =
        dispatcher.dispatch(&1, |_item, _input| Err(TestError::Failed));

    assert_eq!(result, Err(DispatchError::Execute(TestError::Failed)));
}

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

    let output = dispatcher
        .dispatch(&1, |item, _input| {
            total += u16::from(item.value);
            Ok::<_, Infallible>(item.value)
        })
        .unwrap();

    assert_eq!(output, 10);
    assert_eq!(total, 15);
}

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

    let value = dispatcher
        .dispatch(&1, |item, _input| Ok::<_, Infallible>(&item.value))
        .unwrap();

    assert!(ptr::eq(value, &table[0].value));
}

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

    let returned_input = dispatcher
        .dispatch(&input, |_item, input| Ok::<_, Infallible>(input))
        .unwrap();

    assert!(ptr::eq(returned_input, &input));
}

#[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);
}