1use crate::{
2 core::{
3 entities::{edges::edge_ref::EdgeRef, VID},
4 state::compute_state::ComputeState,
5 },
6 db::{
7 api::{
8 properties::{Metadata, Properties},
9 view::{internal::InternalFilter, BaseEdgeViewOps, BoxedLIter},
10 },
11 graph::edges::Edges,
12 task::{
13 edge::eval_edge::EvalEdgeView,
14 eval_graph::EvalGraph,
15 node::{eval_node::EvalPathFromNode, eval_node_state::EVState},
16 task_state::PrevLocalState,
17 },
18 },
19 prelude::GraphViewOps,
20};
21use raphtory_storage::graph::graph::GraphStorage;
22use std::{cell::RefCell, rc::Rc};
23
24pub struct EvalEdges<'graph, 'a, G, CS: Clone, S> {
25 pub(crate) ss: usize,
26 pub(crate) edges: Edges<'graph, G>,
27 pub(crate) storage: &'graph GraphStorage,
28 pub(crate) node_state: Rc<RefCell<EVState<'a, CS>>>,
29 pub(crate) local_state_prev: &'graph PrevLocalState<'a, S>,
30}
31
32impl<'graph, 'a: 'graph, G: GraphViewOps<'graph>, CS: Clone, S> Clone
33 for EvalEdges<'graph, 'a, G, CS, S>
34{
35 fn clone(&self) -> Self {
36 Self {
37 ss: self.ss,
38 edges: self.edges.clone(),
39 storage: self.storage,
40 node_state: self.node_state.clone(),
41 local_state_prev: self.local_state_prev,
42 }
43 }
44}
45
46impl<'graph, 'a, Current, CS, S> InternalFilter<'graph> for EvalEdges<'graph, 'a, Current, CS, S>
47where
48 'a: 'graph,
49 Current: GraphViewOps<'graph>,
50 CS: Clone,
51{
52 type Graph = Current;
53 type Filtered<Next: GraphViewOps<'graph> + 'graph> = EvalEdges<'graph, 'a, Next, CS, S>;
54
55 fn base_graph(&self) -> &Self::Graph {
56 &self.edges.base_graph
57 }
58
59 fn apply_filter<Next: GraphViewOps<'graph> + 'graph>(
60 &self,
61 filtered_graph: Next,
62 ) -> Self::Filtered<Next> {
63 let edges = self.edges.apply_filter(filtered_graph);
64 let ss = self.ss;
65 let node_state = self.node_state.clone();
66 let local_state_prev = self.local_state_prev;
67 let storage = self.storage;
68 EvalEdges {
69 ss,
70 edges,
71 storage,
72 node_state,
73 local_state_prev,
74 }
75 }
76}
77
78impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S>
79 EvalEdges<'graph, 'a, G, CS, S>
80{
81 pub fn iter(&self) -> impl Iterator<Item = EvalEdgeView<'graph, 'a, G, CS, S>> + 'graph {
82 let node_state = self.node_state.clone();
83 let ss = self.ss;
84 let local_state_prev = self.local_state_prev;
85 let storage = self.storage;
86 self.edges
87 .clone()
88 .into_iter()
89 .map(move |edge| EvalEdgeView {
90 ss,
91 edge,
92 storage,
93 node_state: node_state.clone(),
94 local_state_prev,
95 })
96 }
97}
98
99impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S> IntoIterator
100 for EvalEdges<'graph, 'a, G, CS, S>
101{
102 type Item = EvalEdgeView<'graph, 'a, G, CS, S>;
103 type IntoIter = Box<dyn Iterator<Item = Self::Item> + 'graph>;
104
105 fn into_iter(self) -> Self::IntoIter {
106 let node_state = self.node_state;
107 let ss = self.ss;
108 let local_state_prev = self.local_state_prev;
109 let storage = self.storage;
110 Box::new(self.edges.into_iter().map(move |edge| EvalEdgeView {
111 ss,
112 edge,
113 storage,
114 node_state: node_state.clone(),
115 local_state_prev,
116 }))
117 }
118}
119
120impl<'graph, 'a, G: GraphViewOps<'graph>, CS: Clone + ComputeState, S: 'static>
121 BaseEdgeViewOps<'graph> for EvalEdges<'graph, 'a, G, CS, S>
122{
123 type Graph = G;
124 type ValueType<T>
125 = BoxedLIter<'graph, T>
126 where
127 T: 'graph;
128 type PropType = <Edges<'graph, G> as BaseEdgeViewOps<'graph>>::PropType;
129 type Nodes = EvalPathFromNode<'graph, 'a, G, CS, S>;
130 type Exploded = EvalEdges<'graph, 'a, G, CS, S>;
131
132 fn map<O: 'graph, F: Fn(&Self::Graph, EdgeRef) -> O + Send + Sync + Clone + 'graph>(
133 &self,
134 op: F,
135 ) -> Self::ValueType<O> {
136 self.edges.map(op)
137 }
138
139 fn as_props(&self) -> Self::ValueType<Properties<Self::PropType>> {
140 self.edges.as_props()
141 }
142
143 fn as_metadata(&self) -> Self::ValueType<Metadata<'graph, Self::PropType>> {
144 self.edges.as_metadata()
145 }
146
147 fn map_nodes<F: for<'b> Fn(&'b Self::Graph, EdgeRef) -> VID + Send + Sync + Clone + 'graph>(
148 &self,
149 op: F,
150 ) -> Self::Nodes {
151 let ss = self.ss;
152 let node_state = self.node_state.clone();
153 let local_state_prev = self.local_state_prev;
154 let path = self.edges.map_nodes(op);
155 let base_graph = self.edges.base_graph.clone();
156 let storage = self.storage;
157 let eval_graph = EvalGraph {
158 ss,
159 base_graph,
160 storage,
161 local_state_prev,
162 node_state,
163 };
164 EvalPathFromNode {
165 eval_graph,
166 op: path.op,
167 }
168 }
169
170 fn map_exploded<
171 I: Iterator<Item = EdgeRef> + Send + Sync + 'graph,
172 F: for<'b> Fn(&'b Self::Graph, EdgeRef) -> I + Send + Sync + Clone + 'graph,
173 >(
174 &self,
175 op: F,
176 ) -> Self::Exploded {
177 let ss = self.ss;
178 let node_state = self.node_state.clone();
179 let local_state_prev = self.local_state_prev;
180 let edges = self.edges.map_exploded(op);
181 let storage = self.storage;
182 Self {
183 ss,
184 storage,
185 node_state,
186 local_state_prev,
187 edges,
188 }
189 }
190}