Struct FactoryHashMap 

pub struct FactoryHashMap<K, C: FactoryComponent, S = RandomState> { /* private fields */ }

A container similar to HashMap that can be used to store values of type FactoryComponent.

Implementations

impl<K, C> FactoryHashMap<K, C, RandomState>

where C: FactoryComponent,

pub fn builder() -> FactoryHashMapBuilder<K, C>

Creates a new FactoryHashMap.

Examples found in repository

relm4/examples/factory_hash_map.rs (line 149)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters = FactoryHashMap::builder().launch_default().detach();

        let model = App {
            created_widgets: counter,
            counters,
            entry_buffer: gtk::EntryBuffer::default(),
        };

        let counter_stack = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

impl<K, C, S> FactoryHashMap<K, C, S>

where C: FactoryComponent,

pub fn len(&self) -> usize

Returns the number of elements in the FactoryHashMap.

pub fn is_empty(&self) -> bool

Returns true if the FactoryHashMap is empty.

pub fn broadcast(&self, msg: C::Input)

where C::Input: Clone,

Send clone of a message to all of the elements.

pub const fn widget(&self) -> &C::ParentWidget

Returns the widget all components are attached to.

Examples found in repository

relm4/examples/factory_hash_map.rs (line 157)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters = FactoryHashMap::builder().launch_default().detach();

        let model = App {
            created_widgets: counter,
            counters,
            entry_buffer: gtk::EntryBuffer::default(),
        };

        let counter_stack = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

pub fn iter(&self) -> impl ExactSizeIterator<Item = (&K, &C)> + FusedIterator

An iterator visiting all key-value pairs in arbitrary order.

pub fn values(&self) -> impl ExactSizeIterator<Item = &C> + FusedIterator

Returns an iterator over the factory components.

pub fn keys(&self) -> impl ExactSizeIterator<Item = &K> + FusedIterator

Returns an iterator over the keys of the hash map.

pub fn clear(&mut self)

Clears the map, removing all factory components.

impl<K, C> FactoryHashMap<K, C, RandomState>

where C: FactoryComponent<Index = K>, K: Hash + Eq,

pub fn from_vec( component_vec: Vec<(K, C::Init)>, widget: C::ParentWidget, ) -> Self

Creates a FactoryHashMap from a Vec.

impl<K, C, S> FactoryHashMap<K, C, S>

where C: FactoryComponent<Index = K>, K: Hash + Eq, S: BuildHasher,

pub fn send(&self, key: &K, msg: C::Input)

Send a mage to one of the elements.

pub fn get(&self, key: &K) -> Option<&C>

Tries to get an immutable reference to the model of one element.

Returns None if key is invalid.

pub fn get_mut(&mut self, key: &K) -> Option<FactoryElementGuard<'_, C>>

Tries to get a mutable reference to the model of one element.

Returns None if key is invalid.

Examples found in repository

relm4/examples/factory_hash_map.rs (line 175)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            AppMsg::AddCounter => {
                let index = self.entry_buffer.text().to_string();
                if !index.is_empty() {
                    self.counters.insert(index.clone(), self.created_widgets);
                    // Change focus to the currently created element
                    self.counters.set_visible(&index);
                    self.created_widgets = self.created_widgets.wrapping_add(1);
                }
            }
            AppMsg::Increment(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_add(1);
            }
            AppMsg::Decrement(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_sub(1);
            }
            AppMsg::RemoveCounter(key) => {
                self.counters.remove(&key);
            }
            AppMsg::UpdateView => (),
        }
    }

pub fn insert(&mut self, key: K, init: C::Init) -> Option<C>

Inserts a new factory component into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical. See the module-level documentation for more.

Examples found in repository

relm4/examples/factory_hash_map.rs (line 168)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            AppMsg::AddCounter => {
                let index = self.entry_buffer.text().to_string();
                if !index.is_empty() {
                    self.counters.insert(index.clone(), self.created_widgets);
                    // Change focus to the currently created element
                    self.counters.set_visible(&index);
                    self.created_widgets = self.created_widgets.wrapping_add(1);
                }
            }
            AppMsg::Increment(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_add(1);
            }
            AppMsg::Decrement(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_sub(1);
            }
            AppMsg::RemoveCounter(key) => {
                self.counters.remove(&key);
            }
            AppMsg::UpdateView => (),
        }
    }

pub fn remove(&mut self, key: &K) -> Option<C>

Removes a key from the map, returning the factory component at the key if the key was previously in the map.

Examples found in repository

relm4/examples/factory_hash_map.rs (line 183)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            AppMsg::AddCounter => {
                let index = self.entry_buffer.text().to_string();
                if !index.is_empty() {
                    self.counters.insert(index.clone(), self.created_widgets);
                    // Change focus to the currently created element
                    self.counters.set_visible(&index);
                    self.created_widgets = self.created_widgets.wrapping_add(1);
                }
            }
            AppMsg::Increment(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_add(1);
            }
            AppMsg::Decrement(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_sub(1);
            }
            AppMsg::RemoveCounter(key) => {
                self.counters.remove(&key);
            }
            AppMsg::UpdateView => (),
        }
    }

impl<K, C> FactoryHashMap<K, C, RandomState>

where C: FactoryComponent, K: Clone + Hash + Eq, C::ParentWidget: IsA<Stack>, C::Root: IsA<Widget>,

pub fn set_visible(&self, key: &K) -> bool

Makes the element at a given key visible in a gtk::Stack. Returns true on success, otherwise false.

Examples found in repository

relm4/examples/factory_hash_map.rs (line 170)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            AppMsg::AddCounter => {
                let index = self.entry_buffer.text().to_string();
                if !index.is_empty() {
                    self.counters.insert(index.clone(), self.created_widgets);
                    // Change focus to the currently created element
                    self.counters.set_visible(&index);
                    self.created_widgets = self.created_widgets.wrapping_add(1);
                }
            }
            AppMsg::Increment(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_add(1);
            }
            AppMsg::Decrement(key) => {
                let mut elem = self.counters.get_mut(&key).unwrap();
                elem.value = elem.value.saturating_sub(1);
            }
            AppMsg::RemoveCounter(key) => {
                self.counters.remove(&key);
            }
            AppMsg::UpdateView => (),
        }
    }

Trait Implementations

impl<K, C> Clone for FactoryHashMap<K, C, RandomState>

where C: CloneableFactoryComponent + FactoryComponent<Index = K>, K: Clone + Hash + Eq,

Implements the Clone Trait for FactoryHashMap if the component implements CloneableFactoryComponent.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, C: Debug + FactoryComponent, S: Debug> Debug for FactoryHashMap<K, C, S>

where C::ParentWidget: Debug, C::Output: Debug,

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

Formats the value using the given formatter.

impl<K, C, S> Drop for FactoryHashMap<K, C, S>

where C: FactoryComponent,

fn drop(&mut self)

Executes the destructor for this type.

impl<K, C, S> Index<&K> for FactoryHashMap<K, C, S>

where C: FactoryComponent<Index = K>, K: Hash + Eq, S: BuildHasher,

type Output = C

The returned type after indexing.

fn index(&self, key: &K) -> &Self::Output

Performs the indexing (container[index]) operation.