improve the internal apis for node history

Author: ljeub-pometry

raphtory/src/core/entities/properties/tcell.rs

@@ -232,6 +232,48 @@ impl<A: Send + Sync> TimeIndexOps for TCell<A> {
     }
 }
 
+impl<'b, A: Send + Sync> TimeIndexOps for &'b TCell<A> {
+    type IndexType = TimeIndexEntry;
+    type RangeType<'a>
+        = TimeIndexWindow<'a, TimeIndexEntry, TCell<A>>
+    where
+        Self: 'a;
+
+    fn active(&self, w: Range<Self::IndexType>) -> bool {
+        TimeIndexOps::active(*self, w)
+    }
+
+    fn range(&self, w: Range<Self::IndexType>) -> Self::RangeType<'_> {
+        TimeIndexOps::range(*self, w)
+    }
+
+    fn first(&self) -> Option<Self::IndexType> {
+        TimeIndexOps::first(*self)
+    }
+
+    fn last(&self) -> Option<Self::IndexType> {
+        TimeIndexOps::last(*self)
+    }
+
+    fn iter(&self) -> BoxedLIter<Self::IndexType> {
+        TimeIndexOps::iter(*self)
+    }
+
+    fn len(&self) -> usize {
+        TimeIndexOps::len(*self)
+    }
+}
+
+impl<'a, A: Send + Sync> TimeIndexLike for &'a TCell<A> {
+    fn range_iter(&self, w: Range<Self::IndexType>) -> BoxedLIter<Self::IndexType> {
+        Box::new(self.iter_window(w).map(|(ti, _)| *ti))
+    }
+
+    fn last_range(&self, w: Range<Self::IndexType>) -> Option<Self::IndexType> {
+        self.iter_window(w).next_back().map(|(ti, _)| *ti)
+    }
+}
+
 #[cfg(test)]
 mod tcell_tests {
     use super::TCell;

raphtory/src/db/api/storage/graph/storage_ops/time_semantics.rs

@@ -129,8 +129,14 @@ impl TimeSemantics for GraphStorage {
             Some(w) => node
                 .additions()
                 .into_range(TimeIndexEntry::range(w))
-                .into_prop_events(),
-            None => node.additions().into_prop_events(),
+                .into_prop_events()
+                .into_iter()
+                .into_dyn_boxed(),
+            None => node
+                .additions()
+                .into_prop_events()
+                .into_iter()
+                .into_dyn_boxed(),
         })
         .into_dyn_boxed()
     }

raphtory/src/db/api/storage/graph/variants/storage_variants.rs

@@ -1,5 +1,8 @@
 use crate::{core::Prop, db::api::storage::graph::tprop_storage_ops::TPropOps};
-use raphtory_api::core::storage::timeindex::TimeIndexEntry;
+use raphtory_api::{
+    core::storage::timeindex::{TimeIndexEntry, TimeIndexIntoOps, TimeIndexOps},
+    iter::BoxedLIter,
+};
 use rayon::iter::{
     plumbing::{Consumer, ProducerCallback, UnindexedConsumer},
     IndexedParallelIterator, ParallelIterator,
@@ -278,3 +281,68 @@ impl<'a, Mem: TPropOps<'a> + 'a, #[cfg(feature = "storage")] Disk: TPropOps<'a>
         for_all!(self, props => props.at(ti))
     }
 }
+
+impl<
+        Mem: TimeIndexOps,
+        #[cfg(feature = "storage")] Disk: TimeIndexOps<IndexType = Mem::IndexType>,
+    > TimeIndexOps for SelfType!(Mem, Disk)
+{
+    type IndexType = Mem::IndexType;
+
+    #[cfg(feature = "storage")]
+    type RangeType<'a>
+        = StorageVariants<Mem::RangeType<'a>, Disk::RangeType<'a>>
+    where
+        Self: 'a;
+
+    #[cfg(not(feature = "storage"))]
+    type RangeType<'a>
+        = Mem::RangeType<'a>
+    where
+        Self: 'a;
+
+    fn active(&self, w: Range<Self::IndexType>) -> bool {
+        for_all!(self, props => props.active(w))
+    }
+
+    fn range(&self, w: Range<Self::IndexType>) -> Self::RangeType<'_> {
+        for_all_iter!(self, props => props.range(w))
+    }
+
+    fn first(&self) -> Option<Self::IndexType> {
+        for_all!(self, props => props.first())
+    }
+
+    fn last(&self) -> Option<Self::IndexType> {
+        for_all!(self, props => props.last())
+    }
+
+    fn iter(&self) -> BoxedLIter<Self::IndexType> {
+        for_all!(self, props => props.iter())
+    }
+
+    fn len(&self) -> usize {
+        for_all!(self, props => props.len())
+    }
+}
+
+impl<
+        Mem: TimeIndexIntoOps,
+        #[cfg(feature = "storage")] Disk: TimeIndexIntoOps<IndexType = Mem::IndexType>,
+    > TimeIndexIntoOps for SelfType!(Mem, Disk)
+{
+    type IndexType = Mem::IndexType;
+    #[cfg(feature = "storage")]
+    type RangeType = StorageVariants<Mem::RangeType, Disk::RangeType>;
+
+    #[cfg(not(feature = "storage"))]
+    type RangeType = Mem::RangeType;
+
+    fn into_range(self, w: Range<Self::IndexType>) -> Self::RangeType {
+        for_all_iter!(self, props => props.into_range(w))
+    }
+
+    fn into_iter(self) -> impl Iterator<Item = Self::IndexType> + Send + Sync {
+        for_all_iter!(self, props => props.into_iter())
+    }
+}

raphtory/src/db/api/view/internal/core_ops.rs

@@ -33,6 +33,7 @@ use raphtory_api::core::{
 };
 use std::{iter, ops::Range};
 
+use crate::db::api::storage::graph::variants::storage_variants::StorageVariants;
 #[cfg(feature = "storage")]
 use pometry_storage::timestamps::LayerAdditions;
 
@@ -375,20 +376,27 @@ pub enum NodeAdditions<'a> {
 }
 
 impl<'a> NodeAdditions<'a> {
-    pub fn into_prop_events(self) -> BoxedLIter<'a, TimeIndexEntry> {
+    pub fn into_prop_events(
+        self,
+    ) -> impl TimeIndexOps<IndexType = TimeIndexEntry>
+           + TimeIndexIntoOps<IndexType = TimeIndexEntry>
+           + use<'a> {
         match self {
-            NodeAdditions::Mem(index) => Box::new(index.props_ts.iter().map(|(time, _)| *time)),
-            NodeAdditions::Range(index) => match index {
-                TimeIndexWindow::Empty => Box::new(iter::empty()),
+            NodeAdditions::Mem(index) => {
+                StorageVariants::Mem(TimeIndexWindow::All(&index.props_ts))
+            }
+            NodeAdditions::Range(index) => StorageVariants::Mem(match index {
+                TimeIndexWindow::Empty => TimeIndexWindow::Empty,
                 TimeIndexWindow::TimeIndexRange { timeindex, range } => {
-                    Box::new(timeindex.props_ts.range_iter(range))
+                    TimeIndexWindow::TimeIndexRange {
+                        timeindex: &timeindex.props_ts,
+                        range,
+                    }
                 }
-                TimeIndexWindow::All(idx) => Box::new(idx.props_ts.iter().map(|(time, _)| *time)),
-            },
+                TimeIndexWindow::All(idx) => TimeIndexWindow::All(&idx.props_ts),
+            }),
             #[cfg(feature = "storage")]
-            NodeAdditions::Col(index) => {
-                Box::new(index.prop_events().map(|ts| ts.into_iter()).kmerge())
-            }
+            NodeAdditions::Col(index) => StorageVariants::Disk(index.prop_events()),
         }
     }
 

raphtory/src/db/graph/views/deletion_graph.rs

@@ -336,7 +336,29 @@ impl TimeSemantics for PersistentGraph {
     }
 
     fn node_property_history(&self, v: VID, w: Option<Range<i64>>) -> BoxedLIter<TimeIndexEntry> {
-        self.0.node_property_history(v, w)
+        match w {
+            None => self.0.node_property_history(v, w),
+            Some(w) => {
+                let node = self.core_node_entry(v);
+                GenLockedIter::from(node, |node| {
+                    has_persisted_event(
+                        &node.additions().into_prop_events(),
+                        &TimeIndex::Empty,
+                        w.start,
+                    )
+                    .then_some(TimeIndexEntry::start(w.start))
+                    .into_iter()
+                    .chain(
+                        node.additions()
+                            .into_range_t(w)
+                            .into_prop_events()
+                            .into_iter(),
+                    )
+                    .into_dyn_boxed()
+                })
+                .into_dyn_boxed()
+            }
+        }
     }
 
     fn edge_history<'a>(