gremlin_client/structure/
metrics.rs

1#[derive(Debug, PartialEq, Clone)]
2pub struct TraversalExplanation {
3    final_t: Vec<String>,
4    original: Vec<String>,
5    intermediate: Vec<IntermediateRepr>,
6}
7
8impl TraversalExplanation {
9    pub fn final_t(&self) -> &Vec<String> {
10        &self.final_t
11    }
12    pub fn original(&self) -> &Vec<String> {
13        &self.original
14    }
15
16    pub fn intermediate(&self) -> &Vec<IntermediateRepr> {
17        &self.intermediate
18    }
19}
20#[derive(Debug, PartialEq, Clone)]
21pub struct IntermediateRepr {
22    traversal: Vec<String>,
23    strategy: String,
24    category: String,
25}
26
27impl IntermediateRepr {
28    pub fn new(traversal: Vec<String>, strategy: String, category: String) -> IntermediateRepr {
29        IntermediateRepr {
30            traversal,
31            strategy,
32            category,
33        }
34    }
35}
36impl TraversalExplanation {
37    pub fn new(
38        original: Vec<String>,
39        final_t: Vec<String>,
40        intermediate: Vec<IntermediateRepr>,
41    ) -> TraversalExplanation {
42        TraversalExplanation {
43            final_t,
44            original,
45            intermediate,
46        }
47    }
48}
49
50#[derive(Debug, PartialEq, Clone)]
51pub struct TraversalMetrics {
52    duration: f64,
53    metrics: Vec<Metric>,
54}
55
56impl TraversalMetrics {
57    pub fn duration(&self) -> &f64 {
58        &self.duration
59    }
60
61    pub fn metrics(&self) -> &Vec<Metric> {
62        &self.metrics
63    }
64}
65
66impl TraversalMetrics {
67    pub fn new(duration: f64, metrics: Vec<Metric>) -> Self {
68        TraversalMetrics { duration, metrics }
69    }
70}
71
72#[derive(Debug, PartialEq, Clone)]
73pub struct Metric {
74    id: String,
75    duration: f64,
76    name: String,
77    count: i64,
78    traversers: i64,
79    perc_duration: f64,
80    nested: Vec<Metric>,
81}
82
83impl Metric {
84    pub fn id(&self) -> &String {
85        &self.id
86    }
87    pub fn name(&self) -> &String {
88        &self.name
89    }
90    pub fn duration(&self) -> &f64 {
91        &self.duration
92    }
93
94    pub fn perc_duration(&self) -> &f64 {
95        &self.perc_duration
96    }
97    pub fn count(&self) -> &i64 {
98        &self.count
99    }
100    pub fn traversers(&self) -> &i64 {
101        &self.traversers
102    }
103}
104
105impl Metric {
106    pub fn new<T, V>(
107        id: T,
108        name: V,
109        duration: f64,
110        count: i64,
111        traversers: i64,
112        perc_duration: f64,
113        nested: Vec<Metric>,
114    ) -> Self
115    where
116        T: Into<String>,
117        V: Into<String>,
118    {
119        Metric {
120            id: id.into(),
121            name: name.into(),
122            duration,
123            count,
124            traversers,
125            perc_duration,
126            nested,
127        }
128    }
129}