robt 0.2.0

Read only, immutable Btree for indexing key,value
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
128
129
130
131
132

use mkit::{
    self,
    cbor::{FromCbor, IntoCbor},
    db, Cborize,
};

use std::{convert::TryFrom, io};

use crate::{util, Error, Result};

const VALUE_VER1: u32 = 0x0001;
const DELTA_VER1: u32 = 0x0001;

#[derive(Clone, Debug, Eq, PartialEq, Cborize)]
pub enum Value<V> {
    N { value: db::Value<V> },
    R { fpos: u64, length: u64 },
}

impl<V> Value<V> {
    const ID: u32 = VALUE_VER1;
}

impl<V> From<db::Value<V>> for Value<V> {
    fn from(value: db::Value<V>) -> Value<V> {
        Value::N { value }
    }
}

impl<V> From<Value<V>> for db::Value<V> {
    fn from(value: Value<V>) -> db::Value<V> {
        match value {
            Value::N { value } => value,
            Value::R { .. } => unreachable!(),
        }
    }
}

impl<V> Value<V> {
    pub fn into_reference(self, fpos: u64) -> Result<(Self, Vec<u8>)>
    where
        V: IntoCbor,
    {
        match self {
            Value::N { value } => {
                let data = util::into_cbor_bytes(value)?;
                let length = err_at!(FailConvert, u64::try_from(data.len()))?;
                Ok((Value::R { fpos, length }, data))
            }
            val @ Value::R { .. } => Ok((val, vec![])),
        }
    }

    #[allow(unused_imports)]
    pub fn into_native<F>(self, f: &mut F) -> Result<Self>
    where
        F: io::Seek + io::Read,
        V: FromCbor,
    {
        match self {
            Value::N { .. } => Ok(self),
            Value::R { fpos, length } => {
                let seek = io::SeekFrom::Start(fpos);
                let block = read_file!(f, seek, length, "reading value from vlog")?;
                let value = util::from_cbor_bytes(&block)?.0;
                Ok(Value::N { value })
            }
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq, Cborize)]
pub enum Delta<D> {
    N { delta: db::Delta<D> },
    R { fpos: u64, length: u64 },
}

impl<D> Delta<D> {
    const ID: u32 = DELTA_VER1;
}

impl<D> From<db::Delta<D>> for Delta<D> {
    fn from(delta: db::Delta<D>) -> Delta<D> {
        Delta::N { delta }
    }
}

impl<D> From<Delta<D>> for db::Delta<D> {
    fn from(delta: Delta<D>) -> db::Delta<D> {
        match delta {
            Delta::N { delta } => delta,
            Delta::R { .. } => unreachable!(),
        }
    }
}

impl<D> Delta<D> {
    pub fn into_reference(self, fpos: u64) -> Result<(Self, Vec<u8>)>
    where
        D: IntoCbor,
    {
        match self {
            Delta::N { delta } => {
                let data = util::into_cbor_bytes(delta)?;
                let length = err_at!(FailConvert, u64::try_from(data.len()))?;
                Ok((Delta::R { fpos, length }, data))
            }
            val @ Delta::R { .. } => Ok((val, vec![])),
        }
    }

    #[allow(unused_imports)]
    pub fn into_native<F>(self, f: &mut F) -> Result<Self>
    where
        F: io::Seek + io::Read,
        D: FromCbor,
    {
        match self {
            Delta::N { .. } => Ok(self),
            Delta::R { fpos, length } => {
                let seek = io::SeekFrom::Start(fpos);
                let block = read_file!(f, seek, length, "reading delta from vlog")?;
                let delta = util::from_cbor_bytes(&block)?.0;
                Ok(Delta::N { delta })
            }
        }
    }
}

#[cfg(test)]
#[path = "vlog_test.rs"]
mod vlog_test;