raphtory-api 0.18.5

Raphtory common interface and APIs
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

use crate::core::{
    entities::properties::prop::Prop,
    storage::timeindex::{AsTime, EventTime},
};
use std::ops::Range;

pub trait TPropOps<'a>: Clone + Send + Sync + Sized + 'a {
    fn active(&self, w: Range<EventTime>) -> bool {
        self.clone().iter_window(w).next().is_some()
    }

    /// Is there any event in this window
    fn active_t(&self, w: Range<i64>) -> bool {
        self.clone().iter_window_t(w).next().is_some()
    }

    fn last_before(&self, t: EventTime) -> Option<(EventTime, Prop)> {
        self.clone().iter_inner_rev(Some(EventTime::MIN..t)).next()
    }

    fn last_window(&self, w: Range<EventTime>) -> Option<(EventTime, Prop)>;

    fn last(&self) -> Option<(EventTime, Prop)>;

    fn iter_inner(
        self,
        range: Option<Range<EventTime>>,
    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a;

    fn iter_inner_rev(
        self,
        range: Option<Range<EventTime>>,
    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a;

    fn iter(self) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
        self.iter_inner(None)
    }

    fn iter_rev(self) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
        self.iter_inner_rev(None)
    }

    fn iter_window(
        self,
        r: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
        self.iter_inner(Some(r))
    }

    fn iter_window_rev(
        self,
        r: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, Prop)> + Send + Sync + 'a {
        self.iter_inner_rev(Some(r))
    }

    fn iter_t(self) -> impl Iterator<Item = (i64, Prop)> + Send + Sync + 'a {
        self.iter().map(|(t, v)| (t.t(), v))
    }

    fn iter_window_t(self, r: Range<i64>) -> impl Iterator<Item = (i64, Prop)> + Send + Sync + 'a {
        self.iter_window(EventTime::range(r))
            .map(|(t, v)| (t.t(), v))
    }

    fn iter_window_te(
        self,
        r: Range<EventTime>,
    ) -> impl Iterator<Item = (i64, Prop)> + Send + Sync + 'a {
        self.iter_window(r).map(|(t, v)| (t.t(), v))
    }

    fn at(&self, ti: &EventTime) -> Option<Prop>;
}