Struct reducer::AsyncDispatcher

pub struct AsyncDispatcher<A, E>(_);

A handle that allows dispatching actions on a spawned Dispatcher (requires async).

AsyncDispatcher requires all actions to be of the same type A. An effective way to fulfill this requirement is to define actions as enum variants.

This type is a just lightweight handle that may be cloned and sent to other threads.

Example

use futures::executor::*;
use futures::prelude::*;
use futures::task::*;
use reducer::*;
use std::error::Error;
use std::io::{self, Write};
use std::pin::Pin;

// The state of your app.
#[derive(Clone)]
struct Calculator(i32);

// Actions the user can trigger.
enum Action {
    Add(i32),
    Sub(i32),
    Mul(i32),
    Div(i32),
}

impl Reducer<Action> for Calculator {
    fn reduce(&mut self, action: Action) {
        match action {
            Action::Add(x) => self.0 += x,
            Action::Sub(x) => self.0 -= x,
            Action::Mul(x) => self.0 *= x,
            Action::Div(x) => self.0 /= x,
        }
    }
}

// The user interface.
struct Console;

impl Reactor<Calculator> for Console {
    type Error = io::Error;
    fn react(&mut self, state: &Calculator) -> io::Result<()> {
        io::stdout().write_fmt(format_args!("{}\n", state.0))
    }
}

// Implementing Sink for Console, means it can asynchronously react to state changes.
impl Sink<Calculator> for Console {
    type Error = io::Error;

    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }

    fn start_send(mut self: Pin<&mut Self>, state: Calculator) -> io::Result<()> {
        self.react(&state)
    }

    fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }

    fn poll_close(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let store = Store::new(Calculator(0), Console);

    // Spin up a thread-pool.
    let mut executor = ThreadPool::new()?;

    // Process incoming actions on a background task.
    let (mut dispatcher, handle) = executor.spawn_dispatcher(store)?;

    dispatcher.dispatch(Action::Add(5))?; // eventually displays "5"
    dispatcher.dispatch(Action::Mul(3))?; // eventually displays "15"
    dispatcher.dispatch(Action::Sub(1))?; // eventually displays "14"
    dispatcher.dispatch(Action::Div(7))?; // eventually displays "2"

    // Dropping the AsyncDispatcher signals to the background task that
    // it can terminate once all pending actions have been processed.
    drop(dispatcher);

    // Wait for the background task to terminate.
    block_on(handle)?;

    Ok(())
}

Trait Implementations

impl<A: Clone, E: Clone> Clone for AsyncDispatcher<A, E>

fn clone(&self) -> AsyncDispatcher<A, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, E: Debug> Debug for AsyncDispatcher<A, E>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<A, E> Dispatcher<A> for AsyncDispatcher<A, E>

type Output = Result<(), AsyncDispatcherError>

Either confirmation that action has been dispatched or the reason why not.

fn dispatch(&mut self, action: A) -> Self::Output

Sends an action to the associated spawned Dispatcher.

Once this call returns, the action may or may not have taken effect, but it's guaranteed to eventually do, unless the spawned Dispatcher terminates in between.

impl<A, E> Sink<A> for AsyncDispatcher<A, E>

type Error = AsyncDispatcherError

The type of value produced by the sink when an error occurs.

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, action: A) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<'pin, A, E> Unpin for AsyncDispatcher<A, E> where
    __AsyncDispatcher<'pin, A, E>: Unpin,