Struct relm4::AsyncRelmWorker

pub struct AsyncRelmWorker<Model, ParentModel> where
    Model: AsyncComponentUpdate<ParentModel, Widgets = ()> + Send + 'static,
    Model::Components: Send,
    ParentModel: ModelTrait,
    ParentModel::Msg: Send,
    Model::Msg: Send,  { /* private fields */ }

This is supported on crate feature tokio-rt only.

A AsyncRelmWorker is like a RelmWorker but runs the AsyncComponentUpdate::update function in a tokio Runtime.

Implementations

impl<Model, ParentModel> AsyncRelmWorker<Model, ParentModel> where
    Model: AsyncComponentUpdate<ParentModel, Widgets = ()> + Send,
    Model::Components: Send,
    ParentModel: ModelTrait,
    ParentModel::Msg: Send,
    Model::Msg: Send, 

pub fn with_new_tokio_rt(
    parent_model: &ParentModel,
    parent_sender: Sender<ParentModel::Msg>
) -> Self

Create a new AsyncRelmWorker that runs the AsyncComponentUpdate::update function in a tokio Runtime.

pub fn send(&self, msg: Model::Msg) -> Result<(), SendError<Model::Msg>>

Send a message to this component. This can be used by the parent to send messages to this worker.

Examples found in repository

relm4-examples/examples/tokio.rs (line 101)

↕

    fn update(&mut self, msg: AppMsg, components: &AppComponents, _sender: Sender<AppMsg>) -> bool {
        self.reset();

        match msg {
            AppMsg::Request(url) => {
                components.http.send(HttpMsg::Request(url)).unwrap();
                self.set_text_waiting(true);
                self.set_image_waiting(true);
            }
            AppMsg::SetText(text_opt) => {
                self.set_text_waiting(false);
                if let Some(text) = text_opt {
                    self.set_text(text);
                } else {
                    self.set_text("No response".to_string());
                }
            }
            AppMsg::SetImage(bytes_opt) => {
                self.set_image_waiting(false);
                if let Some(bytes) = bytes_opt {
                    let buf = Pixbuf::from_read(bytes.reader()).ok();
                    self.set_image_data(buf);
                } else {
                    self.set_image_data(None);
                }
            }
        }
        true
    }

Trait Implementations

impl<Model: Clone, ParentModel: Clone> Clone for AsyncRelmWorker<Model, ParentModel> where
    Model: AsyncComponentUpdate<ParentModel, Widgets = ()> + Send + 'static,
    Model::Components: Send,
    ParentModel: ModelTrait,
    ParentModel::Msg: Send,
    Model::Msg: Send,
    Model::Msg: Clone, 

fn clone(&self) -> AsyncRelmWorker<Model, ParentModel>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Model: Debug, ParentModel: Debug> Debug for AsyncRelmWorker<Model, ParentModel> where
    Model: AsyncComponentUpdate<ParentModel, Widgets = ()> + Send + 'static,
    Model::Components: Send,
    ParentModel: ModelTrait,
    ParentModel::Msg: Send,
    Model::Msg: Send,
    Model::Msg: Debug, 

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

Formats the value using the given formatter.