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

use crate::{DataSource, Point, Result, Time, Value};

const GEN_POINTS: u32 = 200;
const GEN_T_INTERVAL: Time = 20;

/// A struct that implements `DataSource` by showing dummy test data.
#[derive(Debug)]
pub struct TestDataGenerator {
    curr_t: Time,
    interval: Time,
    interval_inc: bool,
}

impl TestDataGenerator {
    /// Construct a new instance.
    pub fn new() -> TestDataGenerator {
        TestDataGenerator {
            curr_t: 1,
            interval: GEN_T_INTERVAL,
            interval_inc: false,
        }
    }
}

impl DataSource for TestDataGenerator {
    fn get_data(&mut self) -> Result<Vec<Point>> {
        let mut rv: Vec<Point> = Vec::with_capacity(GEN_POINTS as usize);
        for _i in 0..GEN_POINTS {
            let t = self.curr_t;
            rv.push(Point {
                t,
                vs: vec![trig_sample(1.0, 1.0/10000.0, 0.0, t),
                         ((100000.0 / (t as f64)) * trig_sample(1.0, 1.0/10000.0, std::f32::consts::PI / 3.0, t) as f64) as Value,
                         trig_sample(0.5, 1.0/5000.0,  0.0, t)],
            });

            self.curr_t += self.interval;
        }

        let switch = if self.interval_inc {
            self.interval += 1;
            self.interval == GEN_T_INTERVAL
        } else {
            self.interval -= 1;
            self.interval == 1
        };
        if switch {
            self.interval_inc = !self.interval_inc;
        }
        Ok(rv)
    }

    fn get_num_values(&self) -> Result<usize> {
        Ok(3)
    }
}

fn trig_sample(scale: f32, scale_period: f32, offset: f32, t: Time) -> Value {
    let float_val = (offset + t as f32 * scale_period).sin() * scale;
    let int_val = (((float_val + 1.0) / 2.0) * std::u16::MAX as f32) as Value;
    int_val
}