use crate::{EventStream, Sink};
use std::cell::RefCell;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ListChange<T> {
Insert {
index: usize,
items: Vec<T>,
},
Remove {
index: usize,
len: usize,
},
Update {
index: usize,
items: Vec<T>,
},
Reset {
items: Vec<T>,
},
}
pub struct ListModel<T> {
items: RefCell<Vec<T>>,
changes: Sink<ListChange<T>>,
}
impl<T> ListModel<T>
where
T: Clone + 'static,
{
pub fn new() -> Self {
Self {
items: RefCell::new(Vec::new()),
changes: Sink::new(),
}
}
pub fn from(items: Vec<T>) -> Self {
let model = Self::new();
model.replace_all(items);
model
}
pub fn len(&self) -> usize {
self.items.borrow().len()
}
pub fn is_empty(&self) -> bool {
self.items.borrow().is_empty()
}
pub fn changes(&self) -> EventStream<ListChange<T>> {
self.changes.stream()
}
pub fn get(&self, index: usize) -> Option<T> {
self.items.borrow().get(index).cloned()
}
pub fn snapshot(&self) -> Vec<T> {
self.items.borrow().clone()
}
pub fn push(&self, item: T) {
self.insert(self.len(), item);
}
pub fn extend(&self, items: Vec<T>) {
if items.is_empty() {
return;
}
let index = self.len();
self.items.borrow_mut().extend(items.iter().cloned());
self.changes.send(ListChange::Insert { index, items });
}
pub fn insert(&self, index: usize, item: T) {
let mut items = self.items.borrow_mut();
if index > items.len() {
return;
}
items.insert(index, item.clone());
self.changes.send(ListChange::Insert {
index,
items: vec![item],
});
}
pub fn remove(&self, index: usize) -> bool {
self.remove_range(index, 1)
}
pub fn remove_range(&self, index: usize, len: usize) -> bool {
let mut items = self.items.borrow_mut();
if index >= items.len() || len == 0 {
return false;
}
let end = (index + len).min(items.len());
items.drain(index..end);
self.changes.send(ListChange::Remove {
index,
len: end - index,
});
true
}
pub fn set(&self, index: usize, item: T) -> bool {
let mut items = self.items.borrow_mut();
let Some(slot) = items.get_mut(index) else {
return false;
};
*slot = item.clone();
self.changes.send(ListChange::Update {
index,
items: vec![item],
});
true
}
pub fn clear(&self) {
let len = self.items.borrow().len();
if len == 0 {
return;
}
self.items.borrow_mut().clear();
self.changes.send(ListChange::Remove { index: 0, len });
}
pub fn replace_all(&self, items: Vec<T>) {
*self.items.borrow_mut() = items.clone();
self.changes.send(ListChange::Reset { items });
}
pub fn sort_by<F>(&self, compare: F)
where
F: FnMut(&T, &T) -> std::cmp::Ordering,
{
let mut items = self.items.borrow_mut();
items.sort_by(compare);
let snapshot = items.clone();
drop(items);
self.changes.send(ListChange::Reset { items: snapshot });
}
pub fn retain<F>(&self, mut keep: F)
where
F: FnMut(&T) -> bool,
{
let mut items = self.items.borrow_mut();
let mut runs: Vec<(usize, usize)> = Vec::new();
let mut run_start: Option<usize> = None;
for (index, item) in items.iter().enumerate() {
if keep(item) {
if let Some(start) = run_start.take() {
runs.push((start, index - start));
}
} else if run_start.is_none() {
run_start = Some(index);
}
}
if let Some(start) = run_start {
runs.push((start, items.len() - start));
}
for (index, len) in runs.iter().rev() {
items.drain(*index..*index + *len);
}
drop(items);
runs.reverse();
for (index, len) in runs {
self.changes.send(ListChange::Remove { index, len });
}
}
}
impl<T> Default for ListModel<T>
where
T: Clone + 'static,
{
fn default() -> Self {
Self::new()
}
}