Struct slint::SortModel

pub struct SortModel<M, F>(_)
where
    M: Model + 'static,
    F: SortHelper<<M as Model>::Data>;

Provides a sorted view of rows by another Model.

When the other Model is updated, the Sorted is updated accordingly.

Generic parameters:

• M the type of the wrapped Model.
• F a type that provides an order to model rows. It is constrained by the internal trait SortHelper, which is used to sort the model in ascending order if the model data supports it, or by a given sort function.

Example

Here we have a VecModel holding crate::SharedStrings. It is then sorted into a SortModel.

let model = VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]);

let sorted_model = SortModel::new(model, |lhs, rhs| lhs.to_lowercase().cmp(&rhs.to_lowercase()));

assert_eq!(sorted_model.row_data(0).unwrap(), SharedString::from("dolor"));
assert_eq!(sorted_model.row_data(1).unwrap(), SharedString::from("ipsum"));
assert_eq!(sorted_model.row_data(2).unwrap(), SharedString::from("Lorem"));

Alternatively you can use the shortcut ModelExt::sort_by.

let sorted_model = VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]).sort_by(|lhs, rhs| lhs.to_lowercase().cmp(&rhs.to_lowercase()));

It is also possible to get a ascending sorted SortModel order for core::cmp::Ord type items.

let model = VecModel::from(vec![
    5,
    1,
    3,
]);

let sorted_model = SortModel::new_ascending(model);

assert_eq!(sorted_model.row_data(0).unwrap(), 1);
assert_eq!(sorted_model.row_data(1).unwrap(), 3);
assert_eq!(sorted_model.row_data(2).unwrap(), 5);

Alternatively you can use the shortcut ModelExt::sort.

let sorted_model = VecModel::from(vec![
    5,
    1,
    3,
]).sort();

If you want to modify the underlying VecModel you can give it a Rc of the SortModel:

let model = Rc::new(VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]));

let sorted_model = SortModel::new(model.clone(), |lhs, rhs| lhs.to_lowercase().cmp(&rhs.to_lowercase()));

assert_eq!(sorted_model.row_data(0).unwrap(), SharedString::from("dolor"));
assert_eq!(sorted_model.row_data(1).unwrap(), SharedString::from("ipsum"));
assert_eq!(sorted_model.row_data(2).unwrap(), SharedString::from("Lorem"));

model.set_row_data(1, SharedString::from("opsom"));

assert_eq!(sorted_model.row_data(0).unwrap(), SharedString::from("dolor"));
assert_eq!(sorted_model.row_data(1).unwrap(), SharedString::from("Lorem"));
assert_eq!(sorted_model.row_data(2).unwrap(), SharedString::from("opsom"));

Implementations

impl<M, F> SortModel<M, F>where M: Model + 'static, F: FnMut(&<M as Model>::Data, &<M as Model>::Data) -> Ordering + 'static,

pub fn new(wrapped_model: M, sort_function: F) -> SortModel<M, F>where F: FnMut(&<M as Model>::Data, &<M as Model>::Data) -> Ordering + 'static,

Creates a new SortModel based on the given wrapped_model and sorted by sort_function. Alternativly you can use ModelExt::sort_by on your Model.

impl<M> SortModel<M, AscendingSortHelper>where M: Model + 'static, <M as Model>::Data: Ord,

pub fn new_ascending(wrapped_model: M) -> SortModel<M, AscendingSortHelper>where <M as Model>::Data: Ord,

Creates a new SortModel based on the given wrapped_model and sorted in ascending order. Alternativly you can use ModelExt::sort on your Model.

pub fn reset(&self)

Manually reapply the sorting. You need to run this e.g. if the sort function depends on mutable state and it has changed.

pub fn unsorted_row(&self, sorted_row: usize) -> usize

Gets the row index of the underlying unsorted model for a given sorted row index.

Trait Implementations

impl<M, S> Model for SortModel<M, S>where M: Model + 'static, S: SortHelper<<M as Model>::Data>,

type Data = <M as Model>::Data

The model data: A model is a set of row and each row has this data

fn row_count(&self) -> usize

The amount of row in the model

fn row_data(&self, row: usize) -> Option<<SortModel<M, S> as Model>::Data>

Returns the data for a particular row. This function should be called with row < row_count().

fn set_row_data(&self, row: usize, data: <SortModel<M, S> as Model>::Data)

Sets the data for a particular row.

fn model_tracker(&self) -> &dyn ModelTracker

The implementation should return a reference to its ModelNotify field.

fn iter(&self) -> ModelIterator<'_, Self::Data> where Self: Sized,

Returns an iterator visiting all elements of the model.

fn as_any(&self) -> &(dyn Any + 'static)

Return something that can be downcast’ed (typically self)