raphtory_storage/graph/nodes/
node_entry.rs

1use crate::graph::{
2    nodes::{node_ref::NodeStorageRef, node_storage_ops::NodeStorageOps},
3    variants::storage_variants3::StorageVariants3,
4};
5use raphtory_api::{
6    core::{
7        entities::{
8            edges::edge_ref::EdgeRef,
9            properties::{prop::Prop, tprop::TPropOps},
10            GidRef, LayerIds, VID,
11        },
12        Direction,
13    },
14    iter::BoxedLIter,
15};
16use raphtory_core::{
17    storage::{node_entry::NodePtr, NodeEntry},
18    utils::iter::GenLockedIter,
19};
20use std::borrow::Cow;
21
22#[cfg(feature = "storage")]
23use crate::disk::storage_interface::node::DiskNode;
24use crate::graph::nodes::node_additions::NodeAdditions;
25
26pub enum NodeStorageEntry<'a> {
27    Mem(NodePtr<'a>),
28    Unlocked(NodeEntry<'a>),
29    #[cfg(feature = "storage")]
30    Disk(DiskNode<'a>),
31}
32
33impl<'a> From<NodePtr<'a>> for NodeStorageEntry<'a> {
34    fn from(value: NodePtr<'a>) -> Self {
35        NodeStorageEntry::Mem(value)
36    }
37}
38
39impl<'a> From<NodeEntry<'a>> for NodeStorageEntry<'a> {
40    fn from(value: NodeEntry<'a>) -> Self {
41        NodeStorageEntry::Unlocked(value)
42    }
43}
44
45#[cfg(feature = "storage")]
46impl<'a> From<DiskNode<'a>> for NodeStorageEntry<'a> {
47    fn from(value: DiskNode<'a>) -> Self {
48        NodeStorageEntry::Disk(value)
49    }
50}
51
52impl<'a> NodeStorageEntry<'a> {
53    #[inline]
54    pub fn as_ref(&self) -> NodeStorageRef<'_> {
55        match self {
56            NodeStorageEntry::Mem(entry) => NodeStorageRef::Mem(*entry),
57            NodeStorageEntry::Unlocked(entry) => NodeStorageRef::Mem(entry.as_ref()),
58            #[cfg(feature = "storage")]
59            NodeStorageEntry::Disk(node) => NodeStorageRef::Disk(*node),
60        }
61    }
62}
63
64impl<'a, 'b: 'a> From<&'a NodeStorageEntry<'b>> for NodeStorageRef<'a> {
65    fn from(value: &'a NodeStorageEntry<'b>) -> Self {
66        value.as_ref()
67    }
68}
69
70impl<'b> NodeStorageEntry<'b> {
71    pub fn into_edges_iter(
72        self,
73        layers: &LayerIds,
74        dir: Direction,
75    ) -> impl Iterator<Item = EdgeRef> + use<'b, '_> {
76        match self {
77            NodeStorageEntry::Mem(entry) => StorageVariants3::Mem(entry.edges_iter(layers, dir)),
78            NodeStorageEntry::Unlocked(entry) => {
79                StorageVariants3::Unlocked(entry.into_edges(layers, dir))
80            }
81            #[cfg(feature = "storage")]
82            NodeStorageEntry::Disk(node) => StorageVariants3::Disk(node.edges_iter(layers, dir)),
83        }
84    }
85
86    pub fn metadata_ids(self) -> BoxedLIter<'b, usize> {
87        match self {
88            NodeStorageEntry::Mem(entry) => Box::new(entry.node().metadata_ids()),
89            NodeStorageEntry::Unlocked(entry) => Box::new(GenLockedIter::from(entry, |e| {
90                Box::new(e.as_ref().node().metadata_ids())
91            })),
92            #[cfg(feature = "storage")]
93            NodeStorageEntry::Disk(node) => Box::new(node.node_metadata_ids()),
94        }
95    }
96
97    pub fn temporal_prop_ids(self) -> Box<dyn Iterator<Item = usize> + 'b> {
98        match self {
99            NodeStorageEntry::Mem(entry) => Box::new(entry.temporal_prop_ids()),
100            NodeStorageEntry::Unlocked(entry) => Box::new(GenLockedIter::from(entry, |e| {
101                Box::new(e.as_ref().temporal_prop_ids())
102            })),
103            #[cfg(feature = "storage")]
104            NodeStorageEntry::Disk(node) => Box::new(node.temporal_node_prop_ids()),
105        }
106    }
107}
108
109impl<'a, 'b: 'a> NodeStorageOps<'a> for &'a NodeStorageEntry<'b> {
110    fn degree(self, layers: &LayerIds, dir: Direction) -> usize {
111        self.as_ref().degree(layers, dir)
112    }
113
114    fn additions(self) -> NodeAdditions<'a> {
115        self.as_ref().additions()
116    }
117
118    fn tprop(self, prop_id: usize) -> impl TPropOps<'a> {
119        self.as_ref().tprop(prop_id)
120    }
121
122    fn edges_iter(self, layers: &LayerIds, dir: Direction) -> impl Iterator<Item = EdgeRef> + 'a {
123        self.as_ref().edges_iter(layers, dir)
124    }
125
126    fn node_type_id(self) -> usize {
127        self.as_ref().node_type_id()
128    }
129
130    fn vid(self) -> VID {
131        self.as_ref().vid()
132    }
133
134    fn id(self) -> GidRef<'a> {
135        self.as_ref().id()
136    }
137
138    fn name(self) -> Option<Cow<'a, str>> {
139        self.as_ref().name()
140    }
141
142    fn find_edge(self, dst: VID, layer_ids: &LayerIds) -> Option<EdgeRef> {
143        self.as_ref().find_edge(dst, layer_ids)
144    }
145
146    fn prop(self, prop_id: usize) -> Option<Prop> {
147        self.as_ref().prop(prop_id)
148    }
149
150    fn tprops(self) -> impl Iterator<Item = (usize, impl TPropOps<'a>)> {
151        self.as_ref().tprops()
152    }
153}
raphtory_storage/graph/nodes/node_entry.rs

raphtory_storage/graph/nodes/
node_entry.rs
