raphtory 0.17.0

raphtory, a temporal graph library
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::{
    db::{
        api::view::internal::{InternalFilter, InternalLayerOps},
        graph::views::layer_graph::LayeredGraph,
    },
    errors::GraphError,
    prelude::GraphViewOps,
};
use raphtory_api::core::entities::{Layer, LayerIds, SingleLayer};
use raphtory_storage::core_ops::CoreGraphOps;

/// Trait defining layer operations
pub trait LayerOps<'graph> {
    type LayeredViewType;

    /// Return a graph containing only the default edge layer
    fn default_layer(&self) -> Self::LayeredViewType {
        self.valid_layers(Layer::Default)
    }

    /// Return a graph containing the layers in `names`. Errors if one or more of the layers do not exists.
    fn layers<L: Into<Layer>>(&self, names: L) -> Result<Self::LayeredViewType, GraphError>;

    /// Return a graph containing the excluded layers in `names`. Errors if one or more of the layers do not exists.
    fn exclude_layers<L: Into<Layer>>(
        &self,
        layers: L,
    ) -> Result<Self::LayeredViewType, GraphError>;

    fn exclude_valid_layers<L: Into<Layer>>(&self, layers: L) -> Self::LayeredViewType;

    /// Check if `name` is a valid layer name
    fn has_layer<L: SingleLayer>(&self, name: L) -> bool;

    /// Return a graph containing the layers in `names`. Any layers that do not exist are ignored.
    fn valid_layers<L: Into<Layer>>(&self, names: L) -> Self::LayeredViewType;

    /// Returns the number of layers
    fn num_layers(&self) -> usize;
}

impl<'graph, V: InternalFilter<'graph> + 'graph> LayerOps<'graph> for V {
    type LayeredViewType = V::Filtered<LayeredGraph<V::Graph>>;

    fn default_layer(&self) -> Self::LayeredViewType {
        let layers = match self.base_graph().get_default_layer_id() {
            None => LayerIds::None,
            Some(layer) => {
                if self.base_graph().layer_ids().contains(&layer) {
                    LayerIds::One(layer)
                } else {
                    LayerIds::None
                }
            }
        };
        self.apply_filter(LayeredGraph::new(self.base_graph().clone(), layers))
    }

    fn layers<L: Into<Layer>>(&self, layers: L) -> Result<Self::LayeredViewType, GraphError> {
        let layers = layers.into();
        let ids = self.base_graph().layer_ids_from_names(layers)?;
        Ok(self.apply_filter(LayeredGraph::new(self.base_graph().clone(), ids)))
    }

    fn exclude_layers<L: Into<Layer>>(
        &self,
        layers: L,
    ) -> Result<Self::LayeredViewType, GraphError> {
        let all_layer_ids = self.base_graph().layer_ids();
        let excluded_ids = self.base_graph().layer_ids_from_names(layers.into())?;
        let included_ids = diff(all_layer_ids, self.base_graph().clone(), &excluded_ids);

        Ok(self.apply_filter(LayeredGraph::new(self.base_graph().clone(), included_ids)))
    }

    fn exclude_valid_layers<L: Into<Layer>>(&self, layers: L) -> Self::LayeredViewType {
        let all_layer_ids = self.base_graph().layer_ids();
        let excluded_ids = self.base_graph().valid_layer_ids_from_names(layers.into());
        let included_ids = diff(all_layer_ids, self.base_graph().clone(), &excluded_ids);

        self.apply_filter(LayeredGraph::new(self.base_graph().clone(), included_ids))
    }

    fn has_layer<L: SingleLayer>(&self, name: L) -> bool {
        !self
            .base_graph()
            .valid_layer_ids_from_names(name.into())
            .is_none()
    }

    fn valid_layers<L: Into<Layer>>(&self, names: L) -> Self::LayeredViewType {
        let layers = names.into();
        let ids = self.base_graph().valid_layer_ids_from_names(layers);
        self.apply_filter(LayeredGraph::new(self.base_graph().clone(), ids))
    }

    fn num_layers(&self) -> usize {
        self.base_graph().unique_layers().count()
    }
}

pub fn diff<'a>(left: &LayerIds, graph: impl GraphViewOps<'a>, other: &LayerIds) -> LayerIds {
    match (left, other) {
        (LayerIds::None, _) => LayerIds::None,
        (this, LayerIds::None) => this.clone(),
        (_, LayerIds::All) => LayerIds::None,
        (LayerIds::One(id), other) => {
            if other.contains(id) {
                LayerIds::None
            } else {
                LayerIds::One(*id)
            }
        }
        (LayerIds::Multiple(ids), other) => {
            let ids: Vec<usize> = ids.iter().filter(|id| !other.contains(id)).collect();
            match ids.len() {
                0 => LayerIds::None,
                1 => LayerIds::One(ids[0]),
                _ => LayerIds::Multiple(ids.into()),
            }
        }
        (LayerIds::All, other) => {
            let all_layer_ids: Vec<usize> = graph
                .unique_layers()
                .map(|name| graph.get_layer_id(name.as_ref()).unwrap())
                .filter(|id| !other.contains(id))
                .collect();
            match all_layer_ids.len() {
                0 => LayerIds::None,
                1 => LayerIds::One(all_layer_ids[0]),
                _ => LayerIds::Multiple(all_layer_ids.into()),
            }
        }
    }
}