Struct Runtime 

pub struct Runtime<S, A: Action, E = NoEffect, Routing = Direct, St = Store<S, A, E>>
where
    St: RuntimeStore<S, A, E>,
{ /* private fields */ }

Runtime helper for store-driven applications.

Implementations

impl<S, A, E, Routing, St> Runtime<S, A, E, Routing, St>

where S: 'static, A: Action, St: RuntimeStore<S, A, E>,

pub fn with_event_bus<Id, Ctx>( self, bus: EventBus<S, A, Id, Ctx>, keybindings: Keybindings<Ctx>, ) -> Runtime<S, A, E, EventBusRouting<S, A, Id, Ctx>, St>

where Id: ComponentId + 'static, Ctx: BindingContext + 'static, S: EventRoutingState<Id, Ctx>,

Pair this runtime with an EventBus + Keybindings so raw events are routed through the bus before actions are dispatched.

impl<S, A, E, Id, Ctx, St> Runtime<S, A, E, EventBusRouting<S, A, Id, Ctx>, St>

where S: 'static + EventRoutingState<Id, Ctx>, A: Action, Id: ComponentId + 'static, Ctx: BindingContext + 'static, St: RuntimeStore<S, A, E>,

pub fn bus(&self) -> &EventBus<S, A, Id, Ctx>

Access the event bus.

pub fn bus_mut(&mut self) -> &mut EventBus<S, A, Id, Ctx>

Access the event bus mutably.

pub fn keybindings(&self) -> &Keybindings<Ctx>

Access the keybindings.

pub fn keybindings_mut(&mut self) -> &mut Keybindings<Ctx>

Access the keybindings mutably.

impl<S, A, Id, Ctx, St> Runtime<S, A, NoEffect, EventBusRouting<S, A, Id, Ctx>, St>

where S: 'static + EventRoutingState<Id, Ctx>, A: Action, Id: ComponentId + 'static, Ctx: BindingContext + 'static, St: RuntimeStore<S, A, NoEffect>,

pub async fn run<B, FRender, FQuit>( &mut self, terminal: &mut Terminal<B>, render: FRender, should_quit: FQuit, ) -> Result<()>

where B: Backend, FRender: FnMut(&mut Frame<'_>, Rect, &S, RenderContext, &mut EventContext<Id>), FQuit: FnMut(&A) -> bool,

Run the event/action loop until quit, routing raw events through the bus + keybindings.

pub async fn run_with_hooks<B, FRender, FQuit, FAfter>( &mut self, terminal: &mut Terminal<B>, render: FRender, should_quit: FQuit, after_render: FAfter, ) -> Result<()>

where B: Backend, FRender: FnMut(&mut Frame<'_>, Rect, &S, RenderContext, &mut EventContext<Id>), FQuit: FnMut(&A) -> bool, FAfter: FnMut(&mut EventBus<S, A, Id, Ctx>, &S),

Run the event/action loop with a post-render hook invoked after each frame is drawn.

impl<S, A, E, Id, Ctx, St> Runtime<S, A, E, EventBusRouting<S, A, Id, Ctx>, St>

where S: 'static + EventRoutingState<Id, Ctx>, A: Action, Id: ComponentId + 'static, Ctx: BindingContext + 'static, St: RuntimeStore<S, A, E>,

pub async fn run_with_effects<B, FRender, FQuit, FEffect>( &mut self, terminal: &mut Terminal<B>, render: FRender, should_quit: FQuit, handle_effect: FEffect, ) -> Result<()>

where B: Backend, FRender: FnMut(&mut Frame<'_>, Rect, &S, RenderContext, &mut EventContext<Id>), FQuit: FnMut(&A) -> bool, FEffect: FnMut(E, &mut EffectContext<'_, A>),

Run the event/action loop until quit, routing raw events through the bus + keybindings and handling emitted effects at the run boundary.

pub async fn run_with_effect_hooks<B, FRender, FQuit, FEffect, FAfter>( &mut self, terminal: &mut Terminal<B>, render: FRender, should_quit: FQuit, handle_effect: FEffect, after_render: FAfter, ) -> Result<()>

where B: Backend, FRender: FnMut(&mut Frame<'_>, Rect, &S, RenderContext, &mut EventContext<Id>), FQuit: FnMut(&A) -> bool, FEffect: FnMut(E, &mut EffectContext<'_, A>), FAfter: FnMut(&mut EventBus<S, A, Id, Ctx>, &S),

Run the event/action loop with effects and a post-render hook invoked after each frame is drawn.

impl<S: 'static, A: Action, E> Runtime<S, A, E, Direct, Store<S, A, E>>

pub fn new(state: S, reducer: Reducer<S, A, E>) -> Self

Create a runtime from state + reducer.

impl<S: 'static, A: Action, E, St: RuntimeStore<S, A, E>> Runtime<S, A, E, Direct, St>

pub fn from_store(store: St) -> Self

Create a runtime from an existing store.

impl<S: 'static, A: Action, E, Routing, St> Runtime<S, A, E, Routing, St>

where St: RuntimeStore<S, A, E>,

pub fn with_event_poller(self, config: PollerConfig) -> Self

Configure event polling behavior.

pub fn with_dispatch_error_handler<F>(self, handler: F) -> Self

where F: FnMut(&DispatchError) -> DispatchErrorPolicy + 'static,

Configure handling for recoverable dispatch errors.

The handler receives each DispatchError and selects a DispatchErrorPolicy. Runtimes do not log or store errors by default; do that inside this closure when needed.

pub fn subscribe_actions(&self) -> Receiver<String>

Subscribe to action name broadcasts.

pub fn enqueue(&self, action: A)

Send an action into the runtime queue.

pub fn action_tx(&self) -> UnboundedSender<A>

Clone the action sender.

pub fn state(&self) -> &S

Access the current state.

impl<S: 'static, A: Action, St> Runtime<S, A, NoEffect, Direct, St>

where St: RuntimeStore<S, A, NoEffect>,

pub async fn run<B, FRender, FEvent, FQuit, R>( &mut self, terminal: &mut Terminal<B>, render: FRender, map_event: FEvent, should_quit: FQuit, ) -> Result<()>

where B: Backend, FRender: FnMut(&mut Frame<'_>, Rect, &S, RenderContext), FEvent: FnMut(&EventKind, &S) -> R, R: Into<EventOutcome<A>>, FQuit: FnMut(&A) -> bool,

Run the event/action loop until quit.

impl<S: 'static, A: Action, E, St> Runtime<S, A, E, Direct, St>

where St: RuntimeStore<S, A, E>,

pub async fn run_with_effects<B, FRender, FEvent, FQuit, FEffect, R>( &mut self, terminal: &mut Terminal<B>, render: FRender, map_event: FEvent, should_quit: FQuit, handle_effect: FEffect, ) -> Result<()>

where B: Backend, FRender: FnMut(&mut Frame<'_>, Rect, &S, RenderContext), FEvent: FnMut(&EventKind, &S) -> R, R: Into<EventOutcome<A>>, FQuit: FnMut(&A) -> bool, FEffect: FnMut(E, &mut EffectContext<'_, A>),

Run the event/action loop until quit, handling emitted effects at the run boundary.