Struct relm4::Sender

source ·

pub struct Sender<T>(_);

Expand description

A Relm4 sender sends messages to a component or worker.

Implementations§

source §

impl<T> Sender<T>

source

pub fn emit(&self, message: T)

Sends a message through the channel.

This method ignores errors. Only a log message will appear when sending fails.

source

pub fn send(&self, message: T) -> Result<(), T>

Sends a message through the channel.

If all receivers where dropped, Err is returned with the content of the message.

Examples found in repository ?

src/component/async/controller.rs (line 15)

14
15
16

    fn emit(&self, event: C::Input) {
        self.sender().send(event).unwrap();
    }

More examples

Hide additional examples

src/component/sync/controller.rs (line 16)

15
16
17

    fn emit(&self, event: C::Input) {
        self.sender().send(event).unwrap();
    }

src/component/worker.rs (line 258)

257
258
259

    pub fn emit(&self, event: W::Input) {
        self.sender.send(event).unwrap();
    }

src/component/sync/message_broker.rs (line 56)

55
56
57

    pub fn send(&self, input: C::Input) {
        self.inner.sender.send(input).unwrap();
    }

src/component/sync/state_watcher.rs (line 27)

    pub fn get_mut(&self) -> RefMut<'_, ComponentParts<C>> {
        self.notifier.send(()).unwrap();
        self.state.borrow_mut()
    }

src/channel/mod.rs (line 37)

    pub fn emit(&self, message: T) {
        if self.send(message).is_err() {
            tracing::warn!("Receiver was dropped");
        }
    }

    /// Sends a message through the channel.
    ///
    /// If all receivers where dropped, [`Err`] is returned
    /// with the content of the message.
    pub fn send(&self, message: T) -> Result<(), T> {
        self.0.send(message).map_err(|e| e.into_inner())
    }
}

impl<T> Clone for Sender<T> {
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
}

impl<T> fmt::Debug for Sender<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple("Sender").field(&self.0).finish()
    }
}

/// A Relm4 receiver receives messages from a component or worker.
pub struct Receiver<T>(pub(crate) flume::Receiver<T>);

impl<T> Receiver<T> {
    /// Receives a message from a component or worker.
    ///
    /// Returns [`None`] if all senders have been disconnected.
    pub async fn recv(&self) -> Option<T> {
        self.0.recv_async().await.ok()
    }

    /// Receives a message synchronously from a component or worker.
    ///
    /// Returns [`None`] if all senders have been disconnected.
    #[must_use]
    pub fn recv_sync(&self) -> Option<T> {
        self.0.recv().ok()
    }

    #[must_use]
    pub(crate) fn into_stream(self) -> RecvStream<'static, T> {
        self.0.into_stream()
    }

    /// Forwards an event from one channel to another.
    pub async fn forward<Transformer, Output>(
        self,
        sender: impl Into<Sender<Output>>,
        transformer: Transformer,
    ) where
        Transformer: (Fn(T) -> Output) + 'static,
        Output: 'static,
    {
        let sender = sender.into();
        while let Some(event) = self.recv().await {
            if sender.send(transformer(event)).is_err() {
                return;
            }
        }
    }