Simplify windowing in graph wrapper structs

docbrown/src/db/edge.rs

@@ -8,6 +8,7 @@
 use crate::core::tgraph::{EdgeRef, VertexRef};
 use crate::core::Direction;
 use crate::core::Prop;
+use crate::db::graph_window::WindowedGraph;
 use crate::db::vertex::VertexView;
 use crate::db::view_api::{BoxedIter, EdgeListOps, GraphViewOps, TimeOps};
 use std::collections::HashMap;
@@ -21,8 +22,7 @@ pub struct EdgeView<G: GraphViewOps> {
     /// A view of an edge in the graph.
     pub graph: G,
     /// A reference to the edge.
-    edge: EdgeRef,
-    window: Option<Range<i64>>,
+    pub edge: EdgeRef,
 }
 
 impl<G: GraphViewOps> Debug for EdgeView<G> {
@@ -47,19 +47,7 @@ impl<G: GraphViewOps> EdgeView<G> {
     ///
     /// A new `EdgeView`.
     pub(crate) fn new(graph: G, edge: EdgeRef) -> Self {
-        EdgeView {
-            graph,
-            edge,
-            window: None,
-        }
-    }
-
-    pub(crate) fn new_windowed(graph: G, edge: EdgeRef, window: Option<Range<i64>>) -> EdgeView<G> {
-        EdgeView {
-            graph,
-            edge,
-            window,
-        }
+        EdgeView { graph, edge }
     }
 
     /// Returns a reference to the underlying edge reference.
@@ -102,15 +90,7 @@ impl<G: GraphViewOps> EdgeView<G> {
     }
 
     pub fn history(&self) -> Vec<i64> {
-        match self.window.clone() {
-            Some(_) => self.graph.edge_timestamps(self.edge, self.window.clone()),
-            None => self.graph.edge_timestamps(
-                self.edge,
-                Some(
-                    self.graph.earliest_time().unwrap_or(0)..self.graph.latest_time().unwrap_or(0),
-                ),
-            ),
-        }
+        self.graph.edge_timestamps(self.edge, None)
     }
 
     pub fn properties(&self, include_static: bool) -> HashMap<String, Prop> {
@@ -213,14 +193,7 @@ impl<G: GraphViewOps> EdgeView<G> {
             g_id: self.edge.src_g_id,
             pid: None,
         };
-
-        match &self.window {
-            None => self.graph.vertex_edges_t(vertex, Direction::OUT, None),
-            Some(w) => {
-                self.graph
-                    .vertex_edges_window_t(vertex, w.start, w.end, Direction::OUT, None)
-            }
-        }
+        self.graph.vertex_edges_t(vertex, Direction::OUT, None)
     }
 
     /// Gets the first time an edge was seen
@@ -245,27 +218,20 @@ impl<G: GraphViewOps> EdgeView<G> {
 }
 
 impl<G: GraphViewOps> TimeOps for EdgeView<G> {
-    type WindowedViewType = EdgeView<G>;
+    type WindowedViewType = EdgeView<WindowedGraph<G>>;
 
     fn start(&self) -> Option<i64> {
-        match &self.window {
-            None => self.graph.start(),
-            Some(w) => Some(w.start),
-        }
+        self.graph.start()
     }
 
     fn end(&self) -> Option<i64> {
-        match &self.window {
-            None => self.graph.end(),
-            Some(w) => Some(w.end),
-        }
+        self.graph.end()
     }
 
     fn window(&self, t_start: i64, t_end: i64) -> Self::WindowedViewType {
-        Self {
-            graph: self.graph.clone(),
+        EdgeView {
+            graph: self.graph.window(t_start, t_end),
             edge: self.edge,
-            window: Some(self.actual_start(t_start)..self.actual_end(t_end)),
         }
     }
 }

docbrown/src/db/graph_window.rs

@@ -44,6 +44,7 @@ use crate::core::{
 use crate::db::view_api::internal::GraphViewInternalOps;
 use crate::db::view_api::time::TimeOps;
 use crate::db::view_api::GraphViewOps;
+use std::cmp::{max, min};
 use std::{collections::HashMap, ops::Range};
 
 /// A struct that represents a windowed view of a `Graph`.
@@ -813,7 +814,11 @@ impl<G: GraphViewOps> GraphViewInternalOps for WindowedGraph<G> {
     /// - `GraphError` - Raised if edge does not exist
 
     fn edge_timestamps(&self, e: EdgeRef, window: Option<Range<i64>>) -> Vec<i64> {
-        self.graph.edge_timestamps(e, window)
+        let window = match window {
+            Some(Range { start, end, .. }) => self.actual_start(start)..self.actual_end(end),
+            None => self.t_start..self.t_end,
+        };
+        self.graph.edge_timestamps(e, Some(window))
     }
 
     /// Get all temporal properties of a vertex
@@ -1052,6 +1057,16 @@ impl<G: GraphViewInternalOps> WindowedGraph<G> {
             t_end,
         }
     }
+
+    /// the larger of `t_start` and `self.start()` (useful for creating nested windows)
+    fn actual_start(&self, t_start: i64) -> i64 {
+        max(t_start, self.t_start)
+    }
+
+    /// the smaller of `t_end` and `self.end()` (useful for creating nested windows)
+    fn actual_end(&self, t_end: i64) -> i64 {
+        min(t_end, self.t_end)
+    }
 }
 
 #[cfg(test)]