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
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::collections::BTreeMap;
use crate::dtf::update::Update;

type Time = u64;

enum EventType {
    CancelEvent,
    TradeEvent,
    CreateEvent,
}

#[derive(Debug)]
struct Events {
    cancelled: BTreeMap<Time, Vec<Update>>,
    trades: BTreeMap<Time, Vec<Update>>,
    created: BTreeMap<Time, Vec<Update>>,
}

impl<'a> From<&'a [Update]> for Events {
    fn from(ups: &[Update]) -> Events {

        let mut cancelled = BTreeMap::new();
        let mut trades = BTreeMap::new();
        let mut created = BTreeMap::new();

        let mut current_level = BTreeMap::new();

        for row in ups {

            let ts = row.ts;
            let price = row.price.to_bits();

            if row.is_trade {
                let v = trades.entry(ts).or_insert(Vec::new());
                (*v).push(row.clone());
            } else {
                let prev = if current_level.contains_key(&price) {
                    *current_level.get(&price).unwrap()
                } else {
                    0.
                };
                if row.size == 0. || row.size <= prev {
                    let v = cancelled.entry(ts).or_insert(Vec::new());
                    (*v).push(row.clone());
                } else if row.size > prev {
                    let v = created.entry(ts).or_insert(Vec::new());
                    (*v).push(row.clone());
                } else {
                    // size == prev
                    unreachable!();
                }
            }

            current_level.insert(price, row.size);
        }

        Events {
            cancelled,
            trades,
            created,
        }
    }
}

impl Events {
    pub fn filter_volume(&self, event_type: EventType, from_vol: f32, to_vol: f32) -> Vec<Update> {
        let obj = match event_type {
            EventType::CancelEvent => &self.cancelled,
            EventType::CreateEvent => &self.created,
            EventType::TradeEvent => &self.trades,
        };

        let mut ret = Vec::new();
        for v in obj.values() {
            for up in v.iter() {
                if up.size >= from_vol && up.size <= to_vol {
                    ret.push(up.clone());
                }
            }
        }
        ret
    }
}

#[cfg(test)]
mod test {

    use super::*;
    use crate::dtf;
    static FNAME: &str = "test/test-data/bt_btcnav.dtf";
    static POLO: &str = "test/test-data/pl_btc_nav.dtf";

    #[test]
    fn test_into_events() {
        // let records = dtf::decode(FNAME, Some(10000));
        // let ups = records.as_slice();
        // TODO: Finish this test...
    }

    #[test]
    fn test_volume_filter() {
        let records = dtf::file_format::decode(FNAME, Some(10000)).unwrap();
        let ups = records.as_slice();

        let evts = Events::from(ups);

        let cancels = evts.filter_volume(EventType::CancelEvent, 100., 200.);
        assert!(cancels.len() > 0);
        for up in cancels.iter() {
            assert!(up.size >= 100. && up.size <= 200.);
        }

        let creates = evts.filter_volume(EventType::CreateEvent, 100., 200.);
        assert!(creates.len() > 0);
        for up in creates.iter() {
            assert!(up.size >= 100. && up.size <= 200.);
        }

        let trades = evts.filter_volume(EventType::TradeEvent, 100., 200.);
        assert!(trades.len() > 0);
        for up in trades.iter() {
            assert!(up.size >= 100. && up.size <= 200.);
        }
    }

    #[test]
    fn should_work_with_poloniex_too() {
        // TODO: more poloniex tests
        // The raw data doesn't look correct.
        let records = dtf::file_format::decode(POLO, Some(10000)).unwrap();

        let ups = records.as_slice();
        let evts = Events::from(ups);

        let trades = evts.filter_volume(EventType::TradeEvent, 100., 200.);
        assert!(trades.len() > 0);
        for up in trades.iter() {
            assert!(up.size >= 100. && up.size <= 200.);
        }
    }
}