Struct relm4::shutdown::AttachedShutdown

pub struct AttachedShutdown<F> { /* private fields */ }

A future attached to a shutdown receiver.

Implementations

impl<F, Out> AttachedShutdown<F>where F: Future<Output = Out>,

pub async fn on_shutdown<S>(self, shutdown: S) -> Outwhere S: Future<Output = Out>,

Creates a future which will resolve to this on shutdown.

pub async fn wait(self) -> Either<(), Out>

Waits until a shutdown signal is received.

• Either::Left(()) on cancellation.
• Either::Right(Out) on registered future completion.

pub async fn drop_on_shutdown(self)

Waits until a shutdown signal is received.

Ignores any output when we don’t care about it.

Examples found in repository

relm4/examples/drawing.rs (line 137)

    fn init(
        _: Self::Init,
        root: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let model = App {
            width: 100.0,
            height: 100.0,
            points: Vec::new(),
            handler: DrawHandler::new(),
        };

        let area = model.handler.drawing_area();
        let widgets = view_output!();

        sender.command(|out, shutdown| {
            shutdown
                .register(async move {
                    loop {
                        tokio::time::sleep(Duration::from_millis(20)).await;
                        out.send(UpdatePointsMsg).unwrap();
                    }
                })
                .drop_on_shutdown()
        });

        ComponentParts { model, widgets }
    }

relm4/examples/progress.rs (line 139)

    fn update(&mut self, message: Self::Input, sender: ComponentSender<Self>, _root: &Self::Root) {
        match message {
            Input::Compute => {
                self.computing = true;
                sender.command(|out, shutdown| {
                    shutdown
                        // Performs this operation until a shutdown is triggered
                        .register(async move {
                            let mut progress = 0.0;

                            while progress < 1.0 {
                                out.send(CmdOut::Progress(progress)).unwrap();
                                progress += 0.1;
                                tokio::time::sleep(std::time::Duration::from_millis(333)).await;
                            }

                            out.send(CmdOut::Finished(Ok("42".into()))).unwrap();
                        })
                        // Perform task until a shutdown interrupts it
                        .drop_on_shutdown()
                        // Wrap into a `Pin<Box<Future>>` for return
                        .boxed()
                });
            }
        }
    }

Trait Implementations

impl<F: Debug> Debug for AttachedShutdown<F>

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

Formats the value using the given formatter.