Struct relm::Relm

pub struct Relm<MSG: Clone + DisplayVariant> { /* fields omitted */ }

Methods

impl<MSG: Clone + DisplayVariant + Send + 'static> Relm<MSG>

fn connect<CALLBACK, FAILCALLBACK, STREAM, TOSTREAM>(&self,
                                                     to_stream: TOSTREAM,
                                                     success_callback: CALLBACK,
                                                     failure_callback: FAILCALLBACK)
                                                     -> impl Future<Item=(), Error=()> where CALLBACK: Fn(STREAM::Item) -> MSG + 'static,
        FAILCALLBACK: Fn(STREAM::Error) -> MSG + 'static,
        STREAM: Stream + 'static,
        TOSTREAM: ToStream<STREAM, Item=STREAM::Item, Error=STREAM::Error> + 'static

fn connect_ignore_err<CALLBACK, STREAM, TOSTREAM>(&self,
                                                  to_stream: TOSTREAM,
                                                  success_callback: CALLBACK)
                                                  -> impl Future<Item=(), Error=()> where CALLBACK: Fn(STREAM::Item) -> MSG + 'static,
        STREAM: Stream + 'static,
        TOSTREAM: ToStream<STREAM, Item=STREAM::Item, Error=STREAM::Error> + 'static

fn connect_exec<CALLBACK, FAILCALLBACK, STREAM, TOSTREAM>(&self,
                                                          to_stream: TOSTREAM,
                                                          callback: CALLBACK,
                                                          failure_callback: FAILCALLBACK) where CALLBACK: Fn(STREAM::Item) -> MSG + 'static,
        FAILCALLBACK: Fn(STREAM::Error) -> MSG + 'static,
        STREAM: Stream + 'static,
        TOSTREAM: ToStream<STREAM, Item=STREAM::Item, Error=STREAM::Error> + 'static

fn connect_exec_ignore_err<CALLBACK, STREAM, TOSTREAM>(&self,
                                                       to_stream: TOSTREAM,
                                                       callback: CALLBACK) where CALLBACK: Fn(STREAM::Item) -> MSG + 'static,
        STREAM: Stream + 'static,
        TOSTREAM: ToStream<STREAM, Item=STREAM::Item, Error=STREAM::Error> + 'static

fn exec<FUTURE: Future<Item=(), Error=()> + 'static>(&self, future: FUTURE)

fn handle(&self) -> &Handle

fn run<WIDGET>() -> Result<(), Error> where WIDGET: Widget<MSG> + 'static, WIDGET::Model: Send

fn stream(&self) -> &EventStream<MSG>