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

use crate::{
    core_ops::CoreGraphOps,
    graph::{graph::GraphStorage, locked::LockedGraph},
};
use raphtory_api::{
    core::entities::{Layer, LayerIds},
    inherit::Base,
};
use raphtory_core::entities::graph::tgraph::InvalidLayer;
use std::sync::Arc;

pub trait InternalLayerOps: CoreGraphOps {
    /// get the layer ids for the graph view
    fn layer_ids(&self) -> &LayerIds;

    /// Get the layer id for the given layer name
    fn layer_ids_from_names(&self, key: Layer) -> Result<LayerIds, InvalidLayer> {
        let layer_ids = match self.core_graph() {
            GraphStorage::Mem(LockedGraph { graph, .. }) | GraphStorage::Unlocked(graph) => {
                graph.layer_ids(key)
            }
            #[cfg(feature = "storage")]
            GraphStorage::Disk(graph) => graph.layer_ids_from_names(key),
        }?;
        Ok(layer_ids.intersect(self.layer_ids()))
    }

    /// Get the valid layer ids for given layer names
    fn valid_layer_ids_from_names(&self, key: Layer) -> LayerIds {
        let layer_ids = match self.core_graph() {
            GraphStorage::Unlocked(graph) | GraphStorage::Mem(LockedGraph { graph, .. }) => {
                graph.valid_layer_ids(key)
            }
            #[cfg(feature = "storage")]
            GraphStorage::Disk(graph) => graph.valid_layer_ids_from_names(key),
        };
        layer_ids.intersect(self.layer_ids())
    }
}

impl InternalLayerOps for GraphStorage {
    fn layer_ids(&self) -> &LayerIds {
        &LayerIds::All
    }
}

pub trait InheritLayerOps: Base {}

impl<G: InheritLayerOps + CoreGraphOps> InternalLayerOps for G
where
    G::Base: InternalLayerOps,
{
    #[inline]
    fn layer_ids(&self) -> &LayerIds {
        self.base().layer_ids()
    }
}

impl<T: ?Sized> InheritLayerOps for Arc<T> {}
impl<T: ?Sized> InheritLayerOps for &T {}