Struct HostedRuntime 

pub struct HostedRuntime<S, A, E, Id, Ctx, St = Store<S, A, E>>
where
    A: ActionTrait,
    Id: ComponentId + 'static,
    Ctx: BindingContext + 'static,
    S: EventRoutingState<Id, Ctx>,
    St: RuntimeStore<S, A, E>,
{ /* private fields */ }

Runtime wrapper that keeps ComponentHost area synchronization out of app loops.

Implementations

impl<S, A, E, Id, Ctx, St> HostedRuntime<S, A, E, Id, Ctx, St>

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

pub fn host(&self) -> &ComponentHost<S, A, Id, Ctx>

Access the hosted component host.

pub fn host_mut(&mut self) -> &mut ComponentHost<S, A, Id, Ctx>

Access the hosted component host mutably.

pub fn runtime(&self) -> &ComponentHostRuntime<S, A, E, Id, Ctx, St>

Access the wrapped runtime.

pub fn runtime_mut(&mut self) -> &mut ComponentHostRuntime<S, A, E, Id, Ctx, St>

Access the wrapped runtime mutably.

pub fn into_parts(self) -> HostedRuntimeParts<S, A, E, Id, Ctx, St>

Split the wrapper back into its runtime and host.

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 keybindings.

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

Access keybindings mutably.

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, A, Id, Ctx, St> HostedRuntime<S, A, NoEffect, Id, Ctx, St>

where S: 'static + EventRoutingState<Id, Ctx>, A: ActionTrait, 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 and synchronize host-rendered areas after each frame.

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 loop with a post-render hook after host area synchronization.

impl<S, A, E, Id, Ctx, St> HostedRuntime<S, A, E, Id, Ctx, St>

where S: 'static + EventRoutingState<Id, Ctx>, A: ActionTrait, 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 with effects and host area synchronization.

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 loop with effects and a post-render hook after host area synchronization.