raphtory-storage 0.17.0

Raphtory storage interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use super::node_ref::NodeStorageRef;
use crate::graph::variants::storage_variants3::StorageVariants3;
use raphtory_api::core::entities::VID;
use raphtory_core::storage::ReadLockedStorage;
use rayon::iter::ParallelIterator;

#[cfg(feature = "storage")]
use crate::disk::storage_interface::nodes_ref::DiskNodesRef;

#[derive(Debug)]
pub enum NodesStorageEntry<'a> {
    Mem(&'a ReadLockedStorage),
    Unlocked(ReadLockedStorage),
    #[cfg(feature = "storage")]
    Disk(DiskNodesRef<'a>),
}

macro_rules! for_all_variants {
    ($value:expr, $pattern:pat => $result:expr) => {
        match $value {
            NodesStorageEntry::Mem($pattern) => StorageVariants3::Mem($result),
            NodesStorageEntry::Unlocked($pattern) => StorageVariants3::Unlocked($result),
            #[cfg(feature = "storage")]
            NodesStorageEntry::Disk($pattern) => StorageVariants3::Disk($result),
        }
    };
}

impl<'a> NodesStorageEntry<'a> {
    pub fn node(&self, vid: VID) -> NodeStorageRef<'_> {
        match self {
            NodesStorageEntry::Mem(store) => NodeStorageRef::Mem(store.get_entry(vid)),
            NodesStorageEntry::Unlocked(store) => NodeStorageRef::Mem(store.get_entry(vid)),
            #[cfg(feature = "storage")]
            NodesStorageEntry::Disk(store) => NodeStorageRef::Disk(store.node(vid)),
        }
    }

    pub fn len(&self) -> usize {
        match self {
            NodesStorageEntry::Mem(store) => store.len(),
            NodesStorageEntry::Unlocked(store) => store.len(),
            #[cfg(feature = "storage")]
            NodesStorageEntry::Disk(store) => store.len(),
        }
    }

    pub fn par_iter(&self) -> impl ParallelIterator<Item = NodeStorageRef<'_>> {
        for_all_variants!(self, nodes => nodes.par_iter().map(|n| n.into()))
    }

    pub fn iter(&self) -> impl Iterator<Item = NodeStorageRef<'_>> {
        for_all_variants!(self, nodes => nodes.iter().map(|n| n.into()))
    }
}