quotick 0.1.3

Embedded tick market data (trade, quote, ..) database storage optimized for billions of data points.
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
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

use radix_trie::{Trie, TrieCommon};
use serde::de::DeserializeOwned;
use serde::Serialize;

use super::BackingFile;
use super::frame::Frame;
use super::path_builder::QuotickPathBuilder;
use super::Tick;

#[derive(Debug)]
pub enum EpochError {
    BackingFileFailure(&'static str),
    IndexFileFailure,
    WriteFailure,
    FrameConflict,
    FrameTooBig,
    FrameEmpty,
}

type FrameIndex<T> = Trie<u64, T>;

pub struct Epoch<T: Tick + Serialize + DeserializeOwned> {
    frame_index_backing: BackingFile<FrameIndex<T>>,

    pub frame_index: FrameIndex<T>,

    epoch: u64,

    tainted: bool,

    path_builder: QuotickPathBuilder,
}

impl<T: Tick + Serialize + DeserializeOwned> Epoch<T> {
    #[inline(always)]
    pub fn new(
        epoch: u64,
        path_builder: QuotickPathBuilder,
    ) -> Result<Epoch<T>, EpochError> {
        let mut frame_index_backing =
            BackingFile::<FrameIndex<T>>::new(
                path_builder.index_backing_file(epoch),
            )
                .or_else(|_|
                    Err(
                        EpochError::BackingFileFailure(
                            "Failed to open frame index backing file.",
                        ),
                    )
                )?;

        let frame_index =
            frame_index_backing.try_read()
                .unwrap_or_else(|_| Trie::new());

        Ok(
            Epoch {
                frame_index_backing,
                frame_index,

                epoch,
                tainted: false,

                path_builder,
            },
        )
    }

    pub fn frames(&mut self) -> impl Iterator<Item=Frame<T>> + '_ {
        self.frame_index
            .iter()
            .map(|(time, item)|
                Frame::new(
                    *time,
                    item.clone(),
                ),
            )
    }

    #[inline(always)]
    pub fn epoch(&self) -> u64 {
        self.epoch
    }

    #[inline(always)]
    pub fn insert(
        &mut self,
        frame: &Frame<T>,
    ) -> Result<(), EpochError> {
        let time = frame.time();

        if self.frame_index.get(&time).is_some() {
            return Err(EpochError::FrameConflict);
        }

        self.frame_index
            .insert(
                time,
                frame.tick().clone(),
            );

        self.tainted = true;

        Ok(())
    }

    #[inline(always)]
    pub fn persist(&mut self) {
        if !self.tainted {
            return;
        }

        self.frame_index_backing
            .write_all(
                &self.frame_index,
            );

        self.tainted = false;
    }
}

impl<T: Tick + Serialize + DeserializeOwned> Drop for Epoch<T> {
    #[inline(always)]
    fn drop(&mut self) {
        self.persist();
    }
}