Struct relm4::component::ComponentStream

pub struct ComponentStream<C: Component> { /* private fields */ }

Yields Component::Output values as a stream and contains the input sender and the root widget.

Use this as alternative to Controller when you prefer a stream of futures or want to unlock the potential of StreamExt. Also, this type implements Send so using it in commands is possible.

Implementations

impl<C: Component> ComponentStream<C>

pub async fn recv_one(self) -> Option<C::Output>

Receive one message and drop the component afterwards. This can be used for dialogs.

Examples found in repository

relm4/examples/message_stream.rs (line 148)

    fn update(&mut self, msg: Self::Input, sender: ComponentSender<Self>, root: &Self::Root) {
        match msg {
            AppMsg::StartSearch => {
                self.searching = true;

                let stream = Dialog::builder()
                    .transient_for(root)
                    .launch(())
                    .into_stream();
                sender.oneshot_command(async move {
                    // Use the component as stream
                    let result = stream.recv_one().await;

                    if let Some(search) = result {
                        let response =
                            reqwest::get(format!("https://duckduckgo.com/lite/?q={search}"))
                                .await
                                .unwrap();
                        let response_text = response.text().await.unwrap();

                        // Extract the url of the first search result.
                        if let Some(url) = response_text.split("<a rel=\"nofollow\" href=\"").nth(1)
                        {
                            let url = url.split('\"').next().unwrap().replace("amp;", "");
                            Some(format!("https:{url}"))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                });
            }
        }
    }

impl<C: Component> ComponentStream<C>

pub fn detach_runtime(&mut self)

Dropping this type will usually stop the runtime of the worker. With this method you can give the runtime a static lifetime. In other words, dropping the controller or connector will not stop the runtime anymore, instead it will run until the app is closed.

Trait Implementations

impl<C: Component> Debug for ComponentStream<C>

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

Formats the value using the given formatter.

impl<C: Component> Stream for ComponentStream<C>

type Item = <C as Component>::Output

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.