Struct seed::app::orders::container::OrdersContainer

pub struct OrdersContainer<Ms: 'static, Mdl: 'static, ElC: View<Ms>, GMs = UndefinedGMsg> { /* fields omitted */ }

Methods

impl<Ms, Mdl, ElC: View<Ms>, GMs> OrdersContainer<Ms, Mdl, ElC, GMs>

pub fn new(app: App<Ms, Mdl, ElC, GMs>) -> Self

Trait Implementations

impl<Ms: 'static, Mdl, ElC: View<Ms> + 'static, GMs> Orders<Ms, GMs> for OrdersContainer<Ms, Mdl, ElC, GMs>

type AppMs = Ms

type Mdl = Mdl

type ElC = ElC

fn proxy<ChildMs: 'static>(
    &mut self,
    f: impl FnOnce(ChildMs) -> Ms + 'static + Clone
) -> OrdersProxy<ChildMs, Ms, Mdl, ElC, GMs>

Automatically map message type. It allows you to pass Orders into child module.

fn render(&mut self) -> &mut Self

Schedule web page rerender after model update. It's the default behaviour.

fn force_render_now(&mut self) -> &mut Self

Force web page to rerender immediately after model update.

fn skip(&mut self) -> &mut Self

Don't rerender web page after model update.

fn send_msg(&mut self, msg: Ms) -> &mut Self

Call function update with the given msg after model update. - You can call this function multiple times - messages will be sent in the same order.

fn perform_cmd<C>(&mut self, cmd: C) -> &mut Self where
    C: Future<Output = Result<Ms, Ms>> + 'static, 

Schedule given future cmd to be executed after model update. - Result is send to function update. - You can call this function multiple times - futures will be scheduled in the same order.

fn send_g_msg(&mut self, g_msg: GMs) -> &mut Self

Similar to send_msg, but calls function sink with the given global message.

fn perform_g_cmd<C>(&mut self, g_cmd: C) -> &mut Self where
    C: Future<Output = Result<GMs, GMs>> + 'static, 

Similar to perform_cmd, but result is send to function sink.

fn clone_app(&self) -> App<Self::AppMs, Self::Mdl, Self::ElC, GMs>

Get app instance. Cloning is cheap because App contains only Rc fields.

fn msg_mapper(&self) -> Box<dyn Fn(Ms) -> Self::AppMs>

Get function which maps module's Msg to app's (root's) one.

fn after_next_render(
    &mut self,
    callback: impl FnOnce(Option<RenderTimestampDelta>) -> Ms + 'static
) -> &mut Self

Register the callback that will be executed after the next render.