Struct relm4::component::worker::WorkerHandle

pub struct WorkerHandle<W: Component> { /* private fields */ }

Handle to a worker task in the background

Implementations

impl<W: Component> WorkerHandle<W>where W::Input: 'static, W::Output: 'static,

pub fn connect_receiver<F: FnMut(&mut Sender<W::Input>, W::Output) + 'static>( self, func: F ) -> WorkerController<W>

Given a mutable closure, captures the receiver for handling.

pub fn forward<X: 'static, F: Fn(W::Output) -> X + 'static>( self, sender: &Sender<X>, transform: F ) -> WorkerController<W>

Forwards output events to the designated sender.

Examples found in repository

relm4/examples/worker.rs (line 97)

    fn init(
        _: Self::Init,
        root: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let model = App {
            counter: 0,
            worker: AsyncHandler::builder()
                .detach_worker(())
                .forward(sender.input_sender(), identity),
        };

        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

pub fn detach(self) -> WorkerController<W>

Ignore outputs from the component and take the handle.

Trait Implementations

impl<W: Debug + Component> Debug for WorkerHandle<W>where W::Input: Debug, W::Output: Debug,

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

Formats the value using the given formatter.