lognplot 0.1.0

Log and plot data
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

//! Query datatypes.
//!
//! The database can be queried, and will give a `QueryResult` back.

use super::sample::{Sample, SampleMetrics};
// use super::{Aggregation, Observation};
use super::RangeQueryResult;
use crate::time::{Resolution, TimeSpan, TimeStamp};

#[derive(Debug)]
pub struct Query {
    pub interval: TimeSpan,
    pub resolution: Resolution,
    pub amount: usize,
}

impl Query {
    pub fn create() -> QueryBuilder {
        QueryBuilder::new()
    }

    pub fn new(interval: TimeSpan, resolution: Resolution, amount: usize) -> Self {
        Query {
            interval,
            resolution,
            amount,
        }
    }
}

pub struct QueryBuilder {
    start: Option<TimeStamp>,
    end: Option<TimeStamp>,
    amount: usize,
}

impl QueryBuilder {
    fn new() -> Self {
        QueryBuilder {
            start: None,
            end: None,
            amount: 10,
        }
    }

    /// Select the start point for this query!
    pub fn start(mut self, start: TimeStamp) -> Self {
        self.start = Some(start);
        self
    }

    /// Select the end timestamp for this query!
    pub fn end(mut self, end: TimeStamp) -> Self {
        self.end = Some(end);
        self
    }

    /// Select this time period for query.
    pub fn span(mut self, timespan: &TimeSpan) -> Self {
        self.start = Some(timespan.start.clone());
        self.end = Some(timespan.end.clone());
        self
    }

    /// Select the minimum amount of results we want.
    pub fn amount(mut self, amount: usize) -> Self {
        self.amount = amount;
        self
    }

    /// Finish building the query, and construct it!
    pub fn build(self) -> Query {
        let start = self.start.expect("No 'start' value given for the query!");
        let end = self.end.expect("No 'end' value given for the query!");
        let interval = TimeSpan::new(start, end);
        Query::new(interval, Resolution::NanoSeconds, self.amount)
    }
}

/// This holds the result of a query to the database.
/// The result can be several things, depending upon query type.
/// It can be min/max/mean slices, or single values, if the data is present at the
/// proper resolution.
#[derive(Debug)]
pub struct QueryResult {
    pub query: Query,
    pub inner: RangeQueryResult<Sample, SampleMetrics>,
}

impl QueryResult {
    pub fn len(&self) -> usize {
        self.inner.len()
    }
}