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
56
57
58
59
60
61
62
63
64
65
66
67
68

use crate::{disk::graph_impl::DiskEdge, graph::edges::edge_storage_ops::EdgeStorageOps};
use pometry_storage::graph::TemporalGraph;
use raphtory_api::core::entities::{LayerIds, LayerVariants, EID};
use rayon::prelude::*;
use std::iter;

#[derive(Copy, Clone, Debug)]
pub struct DiskEdgesRef<'a> {
    pub(super) graph: &'a TemporalGraph,
}

impl<'a> DiskEdgesRef<'a> {
    pub(crate) fn new(storage: &'a TemporalGraph) -> Self {
        Self { graph: storage }
    }

    pub fn edge(self, eid: EID) -> DiskEdge<'a> {
        self.graph.edge(eid)
    }

    pub fn iter(self, layers: &LayerIds) -> impl Iterator<Item = DiskEdge<'a>> + use<'a, '_> {
        match layers {
            LayerIds::None => LayerVariants::None(iter::empty()),
            LayerIds::All => LayerVariants::All(self.graph.edges_iter()),
            LayerIds::One(layer_id) => LayerVariants::One(self.graph.edges_layer_iter(*layer_id)),
            layer_ids => LayerVariants::Multiple(
                self.graph
                    .edges_iter()
                    .filter(move |e| e.has_layer(layer_ids)),
            ),
        }
    }

    pub fn par_iter(
        self,
        layers: &LayerIds,
    ) -> impl ParallelIterator<Item = DiskEdge<'a>> + use<'a, '_> {
        match layers {
            LayerIds::None => LayerVariants::None(rayon::iter::empty()),
            LayerIds::All => LayerVariants::All(self.graph.edges_par_iter()),
            LayerIds::One(layer_id) => {
                LayerVariants::One(self.graph.edges_layer_par_iter(*layer_id))
            }
            layer_ids => LayerVariants::Multiple(
                self.graph
                    .edges_par_iter()
                    .filter(move |e| e.has_layer(layer_ids)),
            ),
        }
    }

    pub fn count(self, layers: &LayerIds) -> usize {
        match layers {
            LayerIds::None => 0,
            LayerIds::All => self.graph.num_edges(),
            LayerIds::One(id) => self.graph.layer(*id).num_edges(),
            layer_ids => self
                .graph
                .edges_par_iter()
                .filter(move |e| e.has_layer(layer_ids))
                .count(),
        }
    }

    pub fn len(&self) -> usize {
        self.count(&LayerIds::All)
    }
}