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

//! The core idea of the time series database:
//! split the sample sequence into batches.
//! This will result in a tree of chunks, each chunk having either sub chunks
//! or leave chunks, with real data.
//! Also: keep track of certain metrics, such as min, max and sum.

// use std::cell::RefCell;
use super::query::{Query, QueryResult};
use super::sample::{Sample, SampleMetrics};
use super::{Aggregation, Btree, Observation};

/// A trace is a single signal with a history in time.
#[derive(Debug)]
pub struct Trace {
    tree: Btree<Sample, SampleMetrics>,
}

impl Trace {
    /// Add a vector of values to this trace.
    pub fn add_values(&mut self, samples: Vec<Observation<Sample>>) {
        for sample in samples {
            self.add_sample(sample);
        }

        // self.tree.append_samples(samples);
    }

    /// Add a single sample.
    pub fn add_sample(&mut self, observation: Observation<Sample>) {
        self.tree.append_sample(observation);
    }

    /// Query this trace for some data.
    pub fn query(&self, query: Query) -> QueryResult {
        let samples = self.tree.query_range(&query.interval, query.amount);

        QueryResult {
            query,
            inner: samples,
        }
    }

    pub fn summary(&self) -> Option<Aggregation<Sample, SampleMetrics>> {
        self.tree.summary()
    }

    pub fn to_vec(&self) -> Vec<Observation<Sample>> {
        self.tree.to_vec()
    }

    pub fn len(&self) -> usize {
        self.tree.len()
    }
}

impl Default for Trace {
    fn default() -> Self {
        let tree = Default::default();

        Self { tree }
    }
}