Struct relm4::factory::collections::FactoryVec

source · [−]

pub struct FactoryVec<Data> where
    Data: FactoryPrototype,  { /* private fields */ }

Expand description

A container similar to Vec that implements Factory.

Implementations

source

impl<Data> FactoryVec<Data> where
Data: FactoryPrototype,

source

pub fn new() -> Self

Create a new FactoryVec.

Examples found in repository

relm4-examples/examples/to_do.rs (line 131)

fn main() {
    let model = AppModel {
        tasks: FactoryVec::new(),
    };
    let relm = RelmApp::new(model);
    relm.run();
}

More examples

relm4-examples/examples/grid_factory.rs (line 161)

fn main() {
    let model = AppModel {
        data: FactoryVec::new(),
        counter: 0,
    };
    let relm = RelmApp::new(model);
    relm.run();
}

relm4-examples/examples/factory_manual.rs (line 118)

fn main() {
    let model = AppModel {
        counters: FactoryVec::new(),
        created_counters: 0,
    };

    let relm = RelmApp::new(model);
    relm.run();
}

relm4-examples/examples/stack_factory.rs (line 123)

fn main() {
    let model = AppModel {
        counters: FactoryVec::new(),
        created_counters: 0,
    };

    let relm = RelmApp::new(model);
    relm.run();
}

relm4-examples/examples/factory.rs (line 104)

fn main() {
    let model = AppModel {
        counters: FactoryVec::new(),
        created_counters: 0,
    };

    let relm = RelmApp::new(model);
    relm.run();
}

relm4-examples/examples/entry_tracker.rs (line 137)

fn main() {
    let model = AppModel {
        counters: FactoryVec::new(),
        created_counters: 0,
        entry: String::new(),
        tracker: 0,
    };

    let relm = RelmApp::new(model);
    relm.run();
}

Additional examples can be found in:

source

pub fn from_vec(data: Vec<Data>) -> Self

Initialize a new FactoryVec with a normal Vec.

Examples found in repository

relm4-examples/libadwaita/examples/sudoku_solver.rs (line 29)

    fn new() -> Self {
        Self {
            values: FactoryVec::from_vec(vec![Number { value: 0 }; 81]),
        }
    }

source

pub fn as_slice(&self) -> &[Data]ⓘNotable traits for &'_ [u8 ]`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

Get a slice of the internal data of a FactoryVec.

source

pub fn into_vec(self) -> Vec<Data>

Get the internal data of the FactoryVec.

source

pub fn clear(&mut self)

Remove all data from the FactoryVec.

source

pub fn len(&self) -> usize

Returns the length as amount of elements stored in this type.

Examples found in repository

relm4-examples/libadwaita/examples/advent_calendar.rs (line 140)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Update => {
                // Check all entries
                for i in 0..self.calendar_entries.len() {
                    // If counter > 1, count down
                    let needs_update = self.calendar_entries.get(i).unwrap().time_left != 0;

                    if needs_update {
                        let entry = self.calendar_entries.get_mut(i).unwrap();
                        entry.time_left = entry.time_left.saturating_sub(1);
                    }
                }
            }
        }
        true
    }

More examples

relm4-examples/libadwaita/examples/sudoku_solver.rs (line 76)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Solve => {
                let content = self.to_line_string();
                let sudoku = Sudoku::from_str_line(content.as_str()).unwrap();

                if let Some(solution) = sudoku.solve_one() {
                    self.from_string(solution.to_string());
                }
            }
            AppMsg::Clear => {
                for index in 0..self.values.len() {
                    if let Some(v) = self.values.get_mut(index) {
                        v.value = 0;
                    }
                }
            }
            AppMsg::Update(index, value) => {
                if let Some(v) = self.values.get_mut(index) {
                    v.value = value;
                }
            }
        }
        true
    }

source

pub fn is_empty(&self) -> bool

Returns true if the length of this type is 0.

source

pub fn push(&mut self, data: Data)

Insert an element at the end of a FactoryVec.

Examples found in repository

relm4-examples/examples/to_do.rs (lines 85-88)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::SetCompleted((index, completed)) => {
                if let Some(task) = self.tasks.get_mut(index) {
                    task.completed = completed;
                }
            }
            AppMsg::AddEntry(name) => {
                self.tasks.push(Task {
                    name,
                    completed: false,
                });
            }
        }
        true
    }

More examples

relm4-examples/examples/grid_factory.rs (lines 94-96)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.data.push(Data {
                    counter: self.counter,
                });
                self.counter += 1;
            }
            AppMsg::Remove => {
                self.data.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(data) = self.data.get_mut(index) {
                    data.counter = data.counter.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/factory_manual.rs (lines 32-34)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/stack_factory.rs (lines 32-34)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/factory.rs (lines 32-34)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/entry.rs (lines 40-42)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::AddCounters => {
                let text = self.entry.text();
                if let Ok(v) = text.parse::<i32>() {
                    if v.is_positive() {
                        // add as many counters as user entered
                        for _ in 0..v {
                            self.counters.push(Counter {
                                value: self.created_counters,
                            });
                            self.created_counters += 1;
                        }
                    } else if v.is_negative() {
                        // remove counters
                        for _ in v..0 {
                            self.counters.pop();
                        }
                    }

                    // clearing the entry value clears the entry widget
                    self.entry.set_text("");
                }
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

Additional examples can be found in:

source

pub fn pop(&mut self) -> Option<Data>

Remove an element at the end of a FactoryVec.

Examples found in repository

relm4-examples/examples/grid_factory.rs (line 100)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.data.push(Data {
                    counter: self.counter,
                });
                self.counter += 1;
            }
            AppMsg::Remove => {
                self.data.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(data) = self.data.get_mut(index) {
                    data.counter = data.counter.wrapping_sub(1);
                }
            }
        }
        true
    }

More examples

relm4-examples/examples/factory_manual.rs (line 38)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/stack_factory.rs (line 38)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/factory.rs (line 38)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/entry.rs (line 48)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::AddCounters => {
                let text = self.entry.text();
                if let Ok(v) = text.parse::<i32>() {
                    if v.is_positive() {
                        // add as many counters as user entered
                        for _ in 0..v {
                            self.counters.push(Counter {
                                value: self.created_counters,
                            });
                            self.created_counters += 1;
                        }
                    } else if v.is_negative() {
                        // remove counters
                        for _ in v..0 {
                            self.counters.pop();
                        }
                    }

                    // clearing the entry value clears the entry widget
                    self.entry.set_text("");
                }
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/entry_tracker.rs (line 54)

↕

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

        match msg {
            AppMsg::Modify(value) => {
                self.entry = value;
                if let Ok(v) = self.entry.parse::<i32>() {
                    if v.is_positive() {
                        // add as many counters as user entered
                        for _ in 0..v {
                            self.counters.push(Counter {
                                value: self.created_counters,
                            });
                            self.created_counters += 1;
                        }
                    } else if v.is_negative() {
                        // remove counters
                        for _ in v..0 {
                            self.counters.pop();
                        }
                    }

                    // clearing the entry value clears the entry widget,
                    // as it is tracked in view! if empty
                    self.entry.clear();
                }
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

source

pub fn get(&self, index: usize) -> Option<&Data>

Get a reference to data stored at index.

Examples found in repository

relm4-examples/libadwaita/examples/advent_calendar.rs (line 142)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Update => {
                // Check all entries
                for i in 0..self.calendar_entries.len() {
                    // If counter > 1, count down
                    let needs_update = self.calendar_entries.get(i).unwrap().time_left != 0;

                    if needs_update {
                        let entry = self.calendar_entries.get_mut(i).unwrap();
                        entry.time_left = entry.time_left.saturating_sub(1);
                    }
                }
            }
        }
        true
    }

source

pub fn get_mut(&mut self, index: usize) -> Option<&mut Data>

Get a mutable reference to data stored at index.

Assumes that the data will be modified and the corresponding widget needs to be updated.

Examples found in repository

relm4-examples/libadwaita/examples/sudoku_solver.rs (line 50)

≺ ≻↕

    fn from_string(&mut self, input: String) {
        for (i, v) in input.chars().enumerate() {
            if v != '.' {
                let value = v.to_string().parse().unwrap();
                if let Some(v) = self.values.get_mut(i) {
                    v.value = value;
                }
            }
        }
    }
}

impl Model for AppModel {
    type Msg = AppMsg;
    type Widgets = AppWidgets;
    type Components = ();
}

impl AppUpdate for AppModel {
    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Solve => {
                let content = self.to_line_string();
                let sudoku = Sudoku::from_str_line(content.as_str()).unwrap();

                if let Some(solution) = sudoku.solve_one() {
                    self.from_string(solution.to_string());
                }
            }
            AppMsg::Clear => {
                for index in 0..self.values.len() {
                    if let Some(v) = self.values.get_mut(index) {
                        v.value = 0;
                    }
                }
            }
            AppMsg::Update(index, value) => {
                if let Some(v) = self.values.get_mut(index) {
                    v.value = value;
                }
            }
        }
        true
    }

More examples

relm4-examples/examples/to_do.rs (line 80)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::SetCompleted((index, completed)) => {
                if let Some(task) = self.tasks.get_mut(index) {
                    task.completed = completed;
                }
            }
            AppMsg::AddEntry(name) => {
                self.tasks.push(Task {
                    name,
                    completed: false,
                });
            }
        }
        true
    }

relm4-examples/examples/grid_factory.rs (line 103)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.data.push(Data {
                    counter: self.counter,
                });
                self.counter += 1;
            }
            AppMsg::Remove => {
                self.data.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(data) = self.data.get_mut(index) {
                    data.counter = data.counter.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/factory_manual.rs (line 41)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/stack_factory.rs (line 41)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

relm4-examples/examples/factory.rs (line 41)

↕

    fn update(&mut self, msg: AppMsg, _components: &(), _sender: Sender<AppMsg>) -> bool {
        match msg {
            AppMsg::Add => {
                self.counters.push(Counter {
                    value: self.created_counters,
                });
                self.created_counters += 1;
            }
            AppMsg::Remove => {
                self.counters.pop();
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.get_mut(index) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
        true
    }

Additional examples can be found in:

impl<Data: Default> Default for FactoryVec<Data> where
 Data: FactoryPrototype,
 Data::Widgets: Default,
 Data::View: Default,
 Data::Root: Default,

source

fn default() -> FactoryVec<Data>

Returns the “default value” for a type. Read more

source

impl<Data, View> Factory<Data, View> for FactoryVec<Data> where
Data: FactoryPrototype<Factory = Self, View = View>,
View: FactoryView<Data::Root>,

type Key = usize

Key that provides additional information for the FactoryPrototype functions.

source

fn generate(&self, view: &View, sender: Sender<Data::Msg>)

Efficiently update the view according to data changes.

Auto Trait Implementations

impl<Data> !RefUnwindSafe for FactoryVec<Data>

impl<Data> Send for FactoryVec<Data> where
 Data: Send,
 <<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: Send,
 <Data as FactoryPrototype>::Widgets: Send,

impl<Data> !Sync for FactoryVec<Data>

impl<Data> Unpin for FactoryVec<Data> where
 Data: Unpin,
 <<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: Unpin,
 <Data as FactoryPrototype>::Widgets: Unpin,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct relm4::factory::collections::FactoryVec

Implementations

impl<Data> FactoryVec<Data> where Data: FactoryPrototype,

pub fn new() -> Self

pub fn from_vec(data: Vec<Data>) -> Self

pub fn as_slice(&self) -> &[Data]ⓘNotable traits for &'_ [u8]impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

pub fn into_vec(self) -> Vec<Data>

pub fn clear(&mut self)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn push(&mut self, data: Data)

pub fn pop(&mut self) -> Option<Data>

pub fn get(&self, index: usize) -> Option<&Data>

pub fn get_mut(&mut self, index: usize) -> Option<&mut Data>

impl<Data, View> FactoryVec<Data> where Data: FactoryPrototype<Factory = Self, View = View>, View: FactoryView<Data::Root>,

pub fn iter(&self) -> Iter<'_, Data>

Trait Implementations

impl<Data: Debug> Debug for FactoryVec<Data> where Data: FactoryPrototype, Data::Widgets: Debug, Data::View: Debug, Data::Root: Debug,

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

impl<Data: Default> Default for FactoryVec<Data> where Data: FactoryPrototype, Data::Widgets: Default, Data::View: Default, Data::Root: Default,

fn default() -> FactoryVec<Data>

impl<Data, View> Factory<Data, View> for FactoryVec<Data> where Data: FactoryPrototype<Factory = Self, View = View>, View: FactoryView<Data::Root>,

type Key = usize

fn generate(&self, view: &View, sender: Sender<Data::Msg>)

Auto Trait Implementations

impl<Data> !RefUnwindSafe for FactoryVec<Data>

impl<Data> Send for FactoryVec<Data> where Data: Send, <<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: Send, <Data as FactoryPrototype>::Widgets: Send,

impl<Data> !Sync for FactoryVec<Data>

impl<Data> Unpin for FactoryVec<Data> where Data: Unpin, <<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: Unpin, <Data as FactoryPrototype>::Widgets: Unpin,

impl<Data> UnwindSafe for FactoryVec<Data> where Data: UnwindSafe, <<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: UnwindSafe, <Data as FactoryPrototype>::Widgets: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

fn into(self) -> U

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<Data> FactoryVec<Data> where
Data: FactoryPrototype,

pub fn as_slice(&self) -> &[Data]ⓘNotable traits for &'_ [u8 ]`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

impl<Data, View> FactoryVec<Data> where
Data: FactoryPrototype<Factory = Self, View = View>,
View: FactoryView<Data::Root>,

impl<Data: Debug> Debug for FactoryVec<Data> where
Data: FactoryPrototype,
Data::Widgets: Debug,
Data::View: Debug,
Data::Root: Debug,

impl<Data: Default> Default for FactoryVec<Data> where
Data: FactoryPrototype,
Data::Widgets: Default,
Data::View: Default,
Data::Root: Default,

impl<Data, View> Factory<Data, View> for FactoryVec<Data> where
Data: FactoryPrototype<Factory = Self, View = View>,
View: FactoryView<Data::Root>,

impl<Data> Send for FactoryVec<Data> where
Data: Send,
<<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: Send,
<Data as FactoryPrototype>::Widgets: Send,

impl<Data> Unpin for FactoryVec<Data> where
Data: Unpin,
<<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: Unpin,
<Data as FactoryPrototype>::Widgets: Unpin,

impl<Data> UnwindSafe for FactoryVec<Data> where
Data: UnwindSafe,
<<Data as FactoryPrototype>::View as FactoryView<<Data as FactoryPrototype>::Root>>::Root: UnwindSafe,
<Data as FactoryPrototype>::Widgets: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,