Struct Dispatcher

pub struct Dispatcher<E> { /* private fields */ }

Implementations

impl<E> Dispatcher<E>

where E: 'static,

pub fn new( handle: &Handle, dispatcher: &Rc<RefCell<EventDispatcher<E>>>, ) -> Dispatcher<E>

pub fn dispatch<Ev>(&self, event: Ev) -> Box<dyn Effect>

where Ev: 'static + Event<E>,

Examples found in repository

examples/todo.rs (line 146)

    fn before(&self, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        match context.coeffects.remove::<Input>().unwrap().0.as_ref() {
            "" => {
                context.queue.clear();
                let db = context.coeffects.get::<Db<AppState>>().unwrap();
                let mode = self.0;
                context.effects.push(Box::new(db.mutate(move |state: &mut AppState| state.mode = mode)));
                let dispatcher = context.coeffects.get::<Dispatcher<()>>().unwrap();
                context.effects.push(dispatcher.dispatch(ShowMenu));
            },
            input => {
                context.coeffects.insert(NonEmptyInput(input.to_string()));
            }
        };

        context.next()
    }
}

struct Index(Result<usize, RemoveError<std::num::ParseIntError>>);

struct ParseIndex;

impl Interceptor for ParseIndex {
    type Error = ();

    fn before(&self, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        let max = {
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            db.borrow().todos.len()
        };
        let index_res = context.coeffects.remove::<NonEmptyInput>().unwrap()
            .0.parse::<isize>()
            .map_err(RemoveError::ParseError)
            .and_then(|index| {
                if index >= 0 && (index as usize) < max {
                    Ok(index as usize)
                } else {
                    Err(RemoveError::OutOfRange(index))
                }
            });
        context.coeffects.insert(Index(index_res));
        context.next()
    }
}

struct MenuInput;

impl Event<()> for MenuInput {
    fn handle(self: Box<Self>, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let input = context.coeffects.get::<NonEmptyInput>().unwrap();
            let next_mode = match input.0.as_ref() {
                "1" => {
                    let dispatcher = context.coeffects.get::<Dispatcher<()>>().unwrap();
                    context.effects.push(dispatcher.dispatch(ShowTodos));
                    Mode::Menu
                },
                "2" => Mode::Adding,
                "3" => Mode::Marking,
                "4" => Mode::Removing,
                _ => Mode::Menu,
            };
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            context.effects.push(Box::new(db.mutate(move |state: &mut AppState| state.mode = next_mode)));
        }
        context.next()
    }
}

struct ShowTodos;

impl Event<()> for ShowTodos {
    fn handle(self: Box<Self>, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            context.effects.push(Box::new(Print(format!("\nTODO:"))));
            let todos = &db.borrow().todos;
            if 0 == todos.len() {
                context.effects.push(Box::new(Print("  Nothing to do.".to_string())));
            }
            for (i, todo) in todos.iter().enumerate() {
                let status = if todo.0 { "✔" } else { " " };
                context.effects.push(Box::new(Print(format!("  - {}: [{}] {}", i, status, todo.1))));
            }
            context.effects.push(Box::new(Print("".to_string())));
        }
        context.next()
    }
}

struct AddTodo;

impl Event<()> for AddTodo {
    fn handle(self: Box<Self>, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let input = context.coeffects.remove::<NonEmptyInput>().unwrap().0;
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            context.effects.push(Box::new(db.mutate(move |state: &mut AppState| state.todos.push((false, input)))));
        }
        context.next()
    }
}

struct RemoveTodo;

#[derive(Debug)]
enum RemoveError<E> {
    ParseError(E),
    OutOfRange(isize),
}

impl Event<()> for RemoveTodo {
    fn handle(self: Box<Self>, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let index_res = context.coeffects.remove::<Index>().unwrap().0;
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            match index_res {
                Ok(index) => {
                    context.effects.push(Box::new(db.mutate(move |state: &mut AppState| {
                        state.todos.remove(index);
                    })));
                },
                Err(e) => {
                    context.effects.push(Box::new(Print(format!("Error removing: {:?}", e))))
                },
            };
        }
        context.next()
    }
}

struct ToggleMark;

impl Event<()> for ToggleMark {
    fn handle(self: Box<Self>, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let index_res = context.coeffects.remove::<Index>().unwrap().0;
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            match index_res {
                Ok(index) => {
                    context.effects.push(Box::new(db.mutate(move |state: &mut AppState| {
                        let todo = state.todos.get_mut(index).unwrap();
                        todo.0 = ! todo.0;
                    })));
                },
                Err(e) => {
                    context.effects.push(Box::new(Print(format!("Error marking: {:?}", e))))
                },
            };
        }
        context.next()
    }
}

struct ShowPrompt;

impl Event<()> for ShowPrompt {
    fn handle(self: Box<Self>, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            let dispatcher = context.coeffects.get::<Dispatcher<()>>().unwrap();
            match db.borrow().mode {
                Mode::Menu => context.effects.push(dispatcher.dispatch(ShowMenu)),
                Mode::Adding => {
                    context.effects.push(dispatcher.dispatch(ShowTodos));
                },
                Mode::Removing => {
                    context.effects.push(dispatcher.dispatch(ShowTodos));
                },
                Mode::Marking => {
                    context.effects.push(dispatcher.dispatch(ShowTodos));
                },
                Mode::Quitting => {
                    context.queue.push_back(Box::new(EventInterceptor::new(Quit(0))) as Box<Interceptor<Error = ()>>);
                }
            }
        }
        context.next()
    }
}

impl Interceptor for ShowPrompt {
    type Error = ();

    fn after(&self, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let dispatcher = context.coeffects.get::<Dispatcher<()>>().unwrap();
            context.effects.push(dispatcher.dispatch(ShowPrompt));
        }
        context.next()
    }

Trait Implementations

impl<E> Clone for Dispatcher<E>

where E: 'static,

fn clone(&self) -> Dispatcher<E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: 'static> NewCoeffect for Dispatcher<E>

type Instance = Dispatcher<E>

fn new_coeffect(&self) -> Dispatcher<E>

impl<E: 'static> Coeffect for Dispatcher<E>