Struct FilterModel

pub struct FilterModel<M, F>(/* private fields */)
where
    M: Model + 'static,
    F: Fn(&<M as Model>::Data) -> bool + 'static;

Provides a filtered subset of rows by another Model.

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

Generic parameters:

• M the type of the wrapped Model.
• F the filter function.

Example

Here we have a VecModel holding crate::SharedStrings. It is then filtered into a FilterModel.

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

let filtered_model = FilterModel::new(model, |s| s.contains('o'));

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

Alternatively you can use the shortcut ModelExt::filter.

let filtered_model = VecModel::from(vec![
    SharedString::from("Lorem"),
    SharedString::from("ipsum"),
    SharedString::from("dolor"),
]).filter(|s| s.contains('o'));

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

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

let filtered_model = FilterModel::new(model.clone(), |s| s.contains('o'));

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

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

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

Implementations

impl<M, F> FilterModel<M, F>

where M: Model + 'static, F: Fn(&<M as Model>::Data) -> bool + 'static,

pub fn new(wrapped_model: M, filter_function: F) -> FilterModel<M, F>

Creates a new FilterModel based on the given wrapped_model and filtered by filter_function. Alternatively you can use ModelExt::filter on your Model.

pub fn reset(&self)

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

pub fn unfiltered_row(&self, filtered_row: usize) -> usize

Gets the row index of the underlying unfiltered model for a given filtered row index.

pub fn source_model(&self) -> &M

Returns a reference to the inner model

Trait Implementations

impl<M, F> Model for FilterModel<M, F>

where M: Model + 'static, F: Fn(&<M as Model>::Data) -> bool + 'static,

type Data = <M as Model>::Data

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

fn row_count(&self) -> usize

The number of rows in the model

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

Returns the data for a particular row.

fn set_row_data(&self, row: usize, data: <FilterModel<M, F> 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 as_any(&self) -> &(dyn Any + 'static)

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

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

where Self: Sized,

Returns an iterator visiting all elements of the model.