Partial dictionary rewrite

src/data/repositories.rs

@@ -8,8 +8,9 @@ use rayon::iter::IntoParallelRefIterator;
 use rayon::iter::ParallelIterator;
 use rusqlite::Connection;
 use std::marker::PhantomData;
-use std::ops::Deref;
+use std::ops::{Deref, Index, IndexMut};
 use std::rc::Rc;
+use std::slice::Iter;
 use std::sync::Arc;
 use crate::data_provider::sqlite::SqliteConnection;
 
@@ -20,6 +21,9 @@ where
     fn get(&self, handle: &mut EntityHandle<T>) -> Option<T>;
     fn get_ref(&self, handle: &mut EntityHandle<T>) -> Option<&T>;
     fn get_mut(&mut self, handle: &mut EntityHandle<T>) -> Option<&mut T>;
+    fn get_static(&self, handle: EntityHandle<T>) -> Option<T>;
+    fn get_ref_static(&self, handle: EntityHandle<T>) -> Option<&T>;
+    fn get_mut_static(&mut self, handle: EntityHandle<T>) -> Option<&mut T>;
     fn handle_by_id(&self, id: Id) -> EntityHandle<T>;
     fn create(&mut self, new: T) -> EntityHandle<T>;
     fn create_now(&mut self, new: T) -> Result<EntityHandle<T>, NotificationData>;
@@ -30,6 +34,8 @@ where
     fn start(&mut self) -> MaybeError;
     fn reload(&mut self) -> MaybeError;
     fn shifts(&self) -> usize;
+    fn iter<'a>(&'a self) -> impl Iterator<Item = &'a T> where T: 'a;
+    fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut T> where T: 'a;
 }
 
 struct QueryManger<T, R, D>
@@ -122,10 +128,25 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
             .filter_map(move |e| data_repository_inner.get_ref(e))
     }
 
-    pub fn for_each_mut<F>(&mut self, repo: &mut R, mut f: F)
+    pub fn iter_with_handles<'a>(&mut self, data_repository_inner: &'a DataRepositoryInner<T, D>) -> impl Iterator<Item =  (&'a T, EntityHandle<T>)>
+    where
+        T: 'a,
+    {
+        if self.shift_stamp != data_repository_inner.shifts() {
+            self.load(data_repository_inner);
+        }
+        self.cache
+            .iter_mut()
+            .filter_map(move |e| Some((data_repository_inner.get_ref(e)?, e.clone())))
+    }
+    
+    pub fn for_each_mut<F>(&mut self, repo: &mut DataRepositoryInner<T, D>, mut f: F)
     where
         F: FnMut(&mut T),
     {
+        if self.shift_stamp != repo.shifts() {
+            self.load(repo);
+        }
         for handle in &mut self.cache {
             if let Some(entity) = repo.get_mut(handle) {
                 f(entity);
@@ -166,6 +187,28 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
                 .collect::<Vec<_>>(),
         );
     }
+
+    pub fn handles(&self, data_repository: &DataRepositoryInner<T, D>) -> impl Iterator<Item = EntityHandle<T>> {
+        self.cache.iter().cloned()
+    }
+    
+    pub fn len(&self) -> usize {
+        self.cache.len()
+    }
+}
+
+impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Index<usize> for  Query<T, R, D> {
+    type Output = EntityHandle<T>;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.cache[index]
+    }
+}
+
+impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> IndexMut<usize> for  Query<T, R, D> {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        &mut self.cache[index]
+    }
 }
 
 pub trait BatchedRepository<T, D>
@@ -300,6 +343,30 @@ impl<T: EntityData + Clone, D: DbLayer<T>> DataRepositoryInner<T, D> {
             shift_stamp: self.shifts,
         }
     }
+    
+    pub fn empty_query(&self) -> Query<T, DataRepositoryInner<T, D>, D> {
+        Query{
+            cache: vec![],
+            rule: Arc::new(|_| false),
+            parallel: false,
+            _marker: Default::default(),
+            shift_stamp: 0,
+        }
+    }
+
+    pub fn empty_query_par(&self) -> Query<T, DataRepositoryInner<T, D>, D> {
+        Query{
+            cache: vec![],
+            rule: Arc::new(|_| false),
+            parallel: true,
+            _marker: Default::default(),
+            shift_stamp: 0,
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.cache.len() + self.temporal.len()
+    }
 }
 
 impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryInner<T, D> {
@@ -333,6 +400,18 @@ impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryIn
         Some(&mut slice[index])
     }
 
+    fn get_static(&self, mut handle: EntityHandle<T>) -> Option<T> {
+        self.get(&mut handle)
+    }
+
+    fn get_ref_static(&self, mut handle: EntityHandle<T>) -> Option<&T> {
+        self.get_ref(&mut handle)
+    }
+
+    fn get_mut_static(&mut self, mut handle: EntityHandle<T>) -> Option<&mut T> {
+        self.get_mut(&mut handle)
+    }
+
     fn handle_by_id(&self, id: Id) -> EntityHandle<T> {
         EntityHandle::new(id, id.0 as usize, true)
     }
@@ -439,6 +518,20 @@ impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryIn
     fn shifts(&self) -> usize {
         self.shifts
     }
+
+    fn iter<'a>(&'a self) -> impl Iterator<Item=&'a T>
+    where
+        T: 'a
+    {
+        self.cache.iter().chain(self.temporal.iter())
+    }
+
+    fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item=&'a mut T>
+    where
+        T: 'a
+    {
+        self.cache.iter_mut().chain(self.temporal.iter_mut())
+    }
 }
 impl<T: EntityData + Clone, D: BatchedDbLayer<T> + DbLayer<T>> BatchedRepository<T, D>
     for DataRepositoryInner<T, D>