nodeops suggestions from lucas

Author: shivamka1

raphtory/src/db/api/state/lazy_node_state.rs

@@ -173,7 +173,7 @@ impl<'graph, Op: NodeOp + 'graph, G: GraphViewOps<'graph>, GH: GraphViewOps<'gra
         let storage = self.graph().core_graph().lock();
         self.nodes
             .iter_refs()
-            .map(move |vid| self.op.apply(&storage, vid))
+            .map(move |vid| self.op.apply(&self.graph(), &storage, vid))
     }
 
     fn par_iter_values<'a>(&'a self) -> impl ParallelIterator<Item = Self::Value<'a>> + 'a

raphtory/src/db/api/state/ops/history.rs

@@ -1,140 +1,79 @@
+use std::sync::Arc;
 use crate::{
-    db::api::{
-        state::{ops::NodeOpFilter, NodeOp},
-        view::internal::NodeTimeSemanticsOps,
-    },
-    prelude::GraphViewOps,
+    db::api::{state::NodeOp, view::internal::NodeTimeSemanticsOps},
 };
 use itertools::Itertools;
 use raphtory_api::core::entities::VID;
 use raphtory_storage::graph::graph::GraphStorage;
+use crate::db::api::view::internal::GraphView;
 
 #[derive(Debug, Clone)]
-pub struct EarliestTime<G> {
-    pub(crate) graph: G,
-}
+pub struct EarliestTime;
 
-impl<'graph, G: GraphViewOps<'graph>> NodeOp for EarliestTime<G> {
+impl NodeOp for EarliestTime {
     type Output = Option<i64>;
 
-    fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
-        let semantics = self.graph.node_time_semantics();
+    fn apply<G: GraphView>(&self, view: &G, storage: &GraphStorage, node: VID) -> Self::Output {
+        let semantics = view.node_time_semantics();
         let node = storage.core_node(node);
-        semantics.node_earliest_time(node.as_ref(), &self.graph)
-    }
-}
-
-impl<'graph, G: GraphViewOps<'graph>> NodeOpFilter<'graph> for EarliestTime<G> {
-    type Graph = G;
-    type Filtered<GH: GraphViewOps<'graph> + 'graph> = EarliestTime<GH>;
-
-    fn graph(&self) -> &Self::Graph {
-        &self.graph
+        semantics.node_earliest_time(node.as_ref(), view)
     }
 
-    fn filtered<GH: GraphViewOps<'graph> + 'graph>(
-        &self,
-        filtered_graph: GH,
-    ) -> Self::Filtered<GH> {
-        EarliestTime {
-            graph: filtered_graph,
-        }
+    fn into_dynamic(self) -> Arc<dyn NodeOp<Output = Self::Output>> where Self: Sized {
+        Arc::new(self)
     }
 }
 
 #[derive(Debug, Clone)]
-pub struct LatestTime<G> {
-    pub(crate) graph: G,
-}
+pub struct LatestTime;
 
-impl<'graph, G: GraphViewOps<'graph>> NodeOp for LatestTime<G> {
+impl NodeOp for LatestTime {
     type Output = Option<i64>;
 
-    fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
-        let semantics = self.graph.node_time_semantics();
+    fn apply<G: GraphView>(&self, view: &G, storage: &GraphStorage, node: VID) -> Self::Output {
+        let semantics = view.node_time_semantics();
         let node = storage.core_node(node);
-        semantics.node_latest_time(node.as_ref(), &self.graph)
-    }
-}
-
-impl<'graph, G: GraphViewOps<'graph>> NodeOpFilter<'graph> for LatestTime<G> {
-    type Graph = G;
-    type Filtered<GH: GraphViewOps<'graph> + 'graph> = LatestTime<GH>;
-
-    fn graph(&self) -> &Self::Graph {
-        &self.graph
+        semantics.node_latest_time(node.as_ref(), view)
     }
 
-    fn filtered<GH: GraphViewOps<'graph> + 'graph>(
-        &self,
-        filtered_graph: GH,
-    ) -> Self::Filtered<GH> {
-        LatestTime {
-            graph: filtered_graph,
-        }
+    fn into_dynamic(self) -> Arc<dyn NodeOp<Output = Self::Output>> where Self: Sized {
+        Arc::new(self)
     }
 }
 
 #[derive(Debug, Clone)]
-pub struct History<G> {
-    pub(crate) graph: G,
-}
+pub struct History;
 
-impl<'graph, G: GraphViewOps<'graph>> NodeOp for History<G> {
+impl NodeOp for History {
     type Output = Vec<i64>;
 
-    fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
-        let semantics = self.graph.node_time_semantics();
+    fn apply<G: GraphView>(&self, view: &G, storage: &GraphStorage, node: VID) -> Self::Output {
+        let semantics = view.node_time_semantics();
         let node = storage.core_node(node);
         semantics
-            .node_history(node.as_ref(), &self.graph)
+            .node_history(node.as_ref(), view)
             .dedup()
             .collect()
     }
-}
-
-impl<'graph, G: GraphViewOps<'graph>> NodeOpFilter<'graph> for History<G> {
-    type Graph = G;
-    type Filtered<GH: GraphViewOps<'graph> + 'graph> = History<GH>;
-
-    fn graph(&self) -> &Self::Graph {
-        &self.graph
-    }
 
-    fn filtered<GH: GraphViewOps<'graph> + 'graph>(
-        &self,
-        filtered_graph: GH,
-    ) -> Self::Filtered<GH> {
-        History {
-            graph: filtered_graph,
-        }
+    fn into_dynamic(self) -> Arc<dyn NodeOp<Output = Self::Output>> where Self: Sized {
+        Arc::new(self)
     }
 }
 
 #[derive(Debug, Copy, Clone)]
-pub struct EdgeHistoryCount<G> {
-    pub(crate) graph: G,
-}
+pub struct EdgeHistoryCount;
 
-impl<'graph, G: GraphViewOps<'graph>> NodeOp for EdgeHistoryCount<G> {
+impl NodeOp for EdgeHistoryCount {
     type Output = usize;
 
-    fn apply(&self, storage: &GraphStorage, node: VID) -> Self::Output {
+    fn apply<G: GraphView>(&self, view: &G, storage: &GraphStorage, node: VID) -> Self::Output {
         let node = storage.core_node(node);
-        let ts = self.graph.node_time_semantics();
-        ts.node_edge_history_count(node.as_ref(), &self.graph)
-    }
-}
-
-impl<'graph, G: GraphViewOps<'graph>> NodeOpFilter<'graph> for EdgeHistoryCount<G> {
-    type Graph = G;
-    type Filtered<GH: GraphViewOps<'graph>> = EdgeHistoryCount<GH>;
-
-    fn graph(&self) -> &Self::Graph {
-        &self.graph
+        let ts = view.node_time_semantics();
+        ts.node_edge_history_count(node.as_ref(), view)
     }
 
-    fn filtered<GH: GraphViewOps<'graph>>(&self, graph: GH) -> Self::Filtered<GH> {
-        EdgeHistoryCount { graph }
+    fn into_dynamic(self) -> Arc<dyn NodeOp<Output = Self::Output>> where Self: Sized {
+        Arc::new(self)
     }
 }

raphtory/src/db/api/state/ops/mod.rs

@@ -1,5 +1,5 @@
-pub(crate) mod history;
-pub(crate) mod node;
+pub mod history;
+pub mod node;
 mod properties;
 
 pub use history::*;