Struct EventInterceptor

pub struct EventInterceptor<T: Event<E>, E>(/* private fields */);

Implementations

impl<T: Event<E>, E> EventInterceptor<T, E>

pub fn new(event: T) -> EventInterceptor<T, E>

Examples found in repository

examples/todo.rs (line 95)

    fn handle(self: Box<Self>, mut context: Context<()>) -> Box<Future<Item = Context<()>, Error = ()>> {
        {
            let db = context.coeffects.get::<Db<AppState>>().unwrap();
            match db.borrow().mode {
                Mode::Menu     => {
                    let interceptors: Vec<Box<Interceptor<Error = ()>>> = vec![
                        Box::new(EmptyInputHandler(Mode::Quitting)),
                        Box::new(EventInterceptor::new(MenuInput))
                    ];
                    context.queue.extend(interceptors);
                },
                Mode::Adding   => {
                    let interceptors: Vec<Box<Interceptor<Error = ()>>> = vec![
                        Box::new(EmptyInputHandler(Mode::Menu)),
                        Box::new(EventInterceptor::new(AddTodo))
                    ];
                    context.queue.extend(interceptors);
                },
                Mode::Removing => {
                    let interceptors: Vec<Box<Interceptor<Error = ()>>> = vec![
                        Box::new(EmptyInputHandler(Mode::Menu)),
                        Box::new(ParseIndex),
                        Box::new(EventInterceptor::new(RemoveTodo))
                    ];
                    context.queue.extend(interceptors);
                },
                Mode::Marking  => {
                    let interceptors: Vec<Box<Interceptor<Error = ()>>> = vec![
                        Box::new(EmptyInputHandler(Mode::Menu)),
                        Box::new(ParseIndex),
                        Box::new(EventInterceptor::new(ToggleMark))
                    ];
                    context.queue.extend(interceptors);
                },
                Mode::Quitting => context.queue.push_back(Box::new(EventInterceptor::new(Quit(0))) as Box<Interceptor<Error = ()>>),
            }
        }
        let input = *self;
        context.coeffects.insert(input);
        context.next()
    }
}

struct NonEmptyInput(String);

struct EmptyInputHandler(Mode);

impl Interceptor for EmptyInputHandler {
    type Error = ();

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

Trait Implementations

impl<E: 'static, T: Event<E>> Interceptor for EventInterceptor<T, E>

type Error = E

fn before( &self, context: Context<Self::Error>, ) -> Box<dyn Future<Item = Context<Self::Error>, Error = Self::Error>>

fn after( &self, context: Context<Self::Error>, ) -> Box<dyn Future<Item = Context<Self::Error>, Error = Self::Error>>