pub trait AsyncFactoryComponent: AsyncPosition<<Self::ParentWidget as FactoryView>::Position> + Sized + 'static {
    type ParentWidget: FactoryView + 'static;
    type ParentInput: Debug + 'static;
    type CommandOutput: Debug + Send + 'static;
    type Input: Debug + 'static;
    type Output: Debug + 'static;
    type Init;
    type Root: AsRef<<Self::ParentWidget as FactoryView>::Children> + Debug + Clone;
    type Widgets: 'static;

    fn init_model<'life0, 'async_trait>(
        init: Self::Init,
        index: &'life0 DynamicIndex,
        sender: AsyncFactorySender<Self>
    ) -> Pin<Box<dyn Future<Output = Self> + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait
; fn init_root() -> Self::Root; fn init_widgets(
        &mut self,
        index: &DynamicIndex,
        root: &Self::Root,
        returned_widget: &<Self::ParentWidget as FactoryView>::ReturnedWidget,
        sender: AsyncFactorySender<Self>
    ) -> Self::Widgets; fn init_loading_widgets(_root: &mut Self::Root) -> Option<LoadingWidgets> { ... } fn output_to_parent_input(
        _output: Self::Output
    ) -> Option<Self::ParentInput> { ... } fn update<'life0, 'async_trait>(
        &'life0 mut self,
        message: Self::Input,
        sender: AsyncFactorySender<Self>
    ) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait
, { ... } fn update_cmd<'life0, 'async_trait>(
        &'life0 mut self,
        message: Self::CommandOutput,
        sender: AsyncFactorySender<Self>
    ) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait
, { ... } fn update_cmd_with_view<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        widgets: &'life1 mut Self::Widgets,
        message: Self::CommandOutput,
        sender: AsyncFactorySender<Self>
    ) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait
, { ... } fn update_view(
        &self,
        widgets: &mut Self::Widgets,
        sender: AsyncFactorySender<Self>
    ) { ... } fn update_with_view<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        widgets: &'life1 mut Self::Widgets,
        message: Self::Input,
        sender: AsyncFactorySender<Self>
    ) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait
, { ... } fn shutdown(
        &mut self,
        widgets: &mut Self::Widgets,
        output: Sender<Self::Output>
    ) { ... } fn id(&self) -> String { ... } }
Expand description

A component that’s stored inside a factory. Similar to Component but adjusted to fit the life cycle of factories.

Required Associated Types§

Container widget to which all widgets of the factory will be added.

Input messages sent to the parent component.

Messages which are received from commands executing in the background.

The message type that the factory component accepts as inputs.

The message type that the factory component provides as outputs.

The parameter used to initialize the factory component.

The widget that was constructed by the factory component.

The type that’s used for storing widgets created for this factory component.

Required Methods§

Initializes the model.

Initializes the root widget

Initializes the widgets.

Provided Methods§

Allows you to initialize the root widget with a temporary value as a placeholder until the init_model() future completes.

This method does nothing by default.

Optionally convert an output message from this component to an input message for the parent component.

If None is returned, nothing is forwarded.

Processes inputs received by the component.

Defines how the component should respond to command updates.

Handles updates from a command.

Updates the view after the model has been updated.

Updates the model and view. Optionally returns a command to run.

Last method called before a component is shut down.

An identifier for the component used for debug logging.

The default implementation of this method uses the address of the component, but implementations are free to provide more meaningful identifiers.

Implementors§