Skip to main content

raphtory_storage/graph/nodes/
nodes_ref.rs

1use super::node_ref::NodeStorageRef;
2use crate::graph::variants::storage_variants3::StorageVariants3;
3use raphtory_api::core::entities::VID;
4use raphtory_core::storage::ReadLockedStorage;
5use rayon::iter::ParallelIterator;
6
7#[cfg(feature = "storage")]
8use crate::disk::storage_interface::nodes_ref::DiskNodesRef;
9
10#[derive(Debug)]
11pub enum NodesStorageEntry<'a> {
12    Mem(&'a ReadLockedStorage),
13    Unlocked(ReadLockedStorage),
14    #[cfg(feature = "storage")]
15    Disk(DiskNodesRef<'a>),
16}
17
18macro_rules! for_all_variants {
19    ($value:expr, $pattern:pat => $result:expr) => {
20        match $value {
21            NodesStorageEntry::Mem($pattern) => StorageVariants3::Mem($result),
22            NodesStorageEntry::Unlocked($pattern) => StorageVariants3::Unlocked($result),
23            #[cfg(feature = "storage")]
24            NodesStorageEntry::Disk($pattern) => StorageVariants3::Disk($result),
25        }
26    };
27}
28
29impl<'a> NodesStorageEntry<'a> {
30    pub fn node(&self, vid: VID) -> NodeStorageRef<'_> {
31        match self {
32            NodesStorageEntry::Mem(store) => NodeStorageRef::Mem(store.get_entry(vid)),
33            NodesStorageEntry::Unlocked(store) => NodeStorageRef::Mem(store.get_entry(vid)),
34            #[cfg(feature = "storage")]
35            NodesStorageEntry::Disk(store) => NodeStorageRef::Disk(store.node(vid)),
36        }
37    }
38
39    pub fn len(&self) -> usize {
40        match self {
41            NodesStorageEntry::Mem(store) => store.len(),
42            NodesStorageEntry::Unlocked(store) => store.len(),
43            #[cfg(feature = "storage")]
44            NodesStorageEntry::Disk(store) => store.len(),
45        }
46    }
47
48    pub fn par_iter(&self) -> impl ParallelIterator<Item = NodeStorageRef<'_>> {
49        for_all_variants!(self, nodes => nodes.par_iter().map(|n| n.into()))
50    }
51
52    pub fn iter(&self) -> impl Iterator<Item = NodeStorageRef<'_>> {
53        for_all_variants!(self, nodes => nodes.iter().map(|n| n.into()))
54    }
55}