OXYGENHUB
# ebb9210bad0c oxygen / crates / oxy-core / src / flat.rs
4.2 KiB · Rust · last changed A state index for the working copy's base 1 month ago source blame history raw
f9575918 Andy McCall ↶ 1 
//! A flat binary layout for local indexes (oxygen#41): fixed-width
2 
//! little-endian numbers and length-prefixed bytes, read in one pass
3 
//! without building a generic value tree. Only for caches this repository
4 
//! derives and can derive again: never exchanged, never trusted beyond the
5 
//! key they are stored under, and a reader that finds anything amiss fails
6 
//! so the caller rebuilds.
7
8 
use crate::hash::ObjectRef;
9 
use crate::objects::ObjectError;
10
11 
#[derive(Default)]
12 
pub struct Writer(pub Vec<u8>);
13
14 
impl Writer {
15 
    pub fn u8(&mut self, v: u8) {
16 
        self.0.push(v);
17 
    }
18 
    pub fn u32(&mut self, v: u32) {
19 
        self.0.extend_from_slice(&v.to_le_bytes());
20 
    }
21 
    pub fn u64(&mut self, v: u64) {
22 
        self.0.extend_from_slice(&v.to_le_bytes());
23 
    }
24 
    /// A count, which must fit in 32 bits.
25 
    pub fn count(&mut self, n: usize) {
26 
        self.u32(u32::try_from(n).expect("an index count fits in 32 bits"));
27 
    }
28 
    pub fn fixed(&mut self, b: &[u8]) {
29 
        self.0.extend_from_slice(b);
30 
    }
31 
    pub fn bytes(&mut self, b: &[u8]) {
32 
        self.count(b.len());
33 
        self.0.extend_from_slice(b);
34 
    }
35 
    pub fn object(&mut self, r: &ObjectRef) {
36 
        self.fixed(&r.0);
37 
    }
38 
    pub fn opt_object(&mut self, r: &Option<ObjectRef>) {
39 
        match r {
40 
            None => self.u8(0),
41 
            Some(r) => {
42 
                self.u8(1);
43 
                self.object(r);
44 
            }
45 
        }
46 
    }
47 
}
48
49 
pub struct Reader<'a> {
50 
    buf: &'a [u8],
51 
    pos: usize,
52 
}
53
54 
fn short() -> ObjectError {
55 
    ObjectError::Schema("index: truncated".into())
56 
}
57
58 
impl<'a> Reader<'a> {
59 
    pub fn new(buf: &'a [u8]) -> Reader<'a> {
60 
        Reader { buf, pos: 0 }
61 
    }
62 
    pub fn at_end(&self) -> bool {
63 
        self.pos == self.buf.len()
64 
    }
65 
    fn take(&mut self, n: usize) -> Result<&'a [u8], ObjectError> {
66 
        let end = self.pos.checked_add(n).ok_or_else(short)?;
67 
        let s = self.buf.get(self.pos..end).ok_or_else(short)?;
68 
        self.pos = end;
69 
        Ok(s)
70 
    }
71 
    pub fn u8(&mut self) -> Result<u8, ObjectError> {
72 
        Ok(self.take(1)?[0])
73 
    }
74 
    pub fn u32(&mut self) -> Result<u32, ObjectError> {
75 
        Ok(u32::from_le_bytes(self.fixed::<4>()?))
76 
    }
77 
    pub fn u64(&mut self) -> Result<u64, ObjectError> {
78 
        Ok(u64::from_le_bytes(self.fixed::<8>()?))
79 
    }
80 
    /// A count; checked against what is left, so a corrupt one cannot ask
81 
    /// for more room than the index could hold.
82 
    pub fn count(&mut self) -> Result<usize, ObjectError> {
83 
        let n = self.u32()? as usize;
84 
        if n > self.buf.len() - self.pos {
85 
            return Err(short());
86 
        }
87 
        Ok(n)
88 
    }
89 
    pub fn fixed<const N: usize>(&mut self) -> Result<[u8; N], ObjectError> {
90 
        Ok(self.take(N)?.try_into().expect("N bytes"))
91 
    }
92 
    pub fn bytes(&mut self) -> Result<&'a [u8], ObjectError> {
93 
        let n = self.u32()? as usize;
94 
        self.take(n)
95 
    }
96 
    pub fn text(&mut self) -> Result<String, ObjectError> {
97 
        String::from_utf8(self.bytes()?.to_vec())
98 
            .map_err(|_| ObjectError::Schema("index: text is not UTF-8".into()))
99 
    }
100 
    pub fn object(&mut self) -> Result<ObjectRef, ObjectError> {
101 
        Ok(ObjectRef(self.fixed::<32>()?))
102 
    }
103 
    pub fn opt_object(&mut self) -> Result<Option<ObjectRef>, ObjectError> {
104 
        Ok(match self.u8()? {
105 
            0 => None,
106 
            _ => Some(self.object()?),
107 
        })
108 
    }
109 
}
110
111 
#[cfg(test)]
112 
mod tests {
113 
    use super::*;
114
115 
    #[test]
116 
    fn numbers_and_bytes_round_trip_and_truncation_fails() {
117 
        let mut w = Writer::default();
118 
        w.u8(7);
119 
        w.u32(70_000);
120 
        w.u64(1 << 40);
121 
        w.bytes(b"path/name");
122 
        w.opt_object(&Some(ObjectRef([3; 32])));
123 
        w.opt_object(&None);
124 
        let mut r = Reader::new(&w.0);
125 
        assert_eq!(r.u8().unwrap(), 7);
126 
        assert_eq!(r.u32().unwrap(), 70_000);
127 
        assert_eq!(r.u64().unwrap(), 1 << 40);
128 
        assert_eq!(r.text().unwrap(), "path/name");
129 
        assert_eq!(r.opt_object().unwrap(), Some(ObjectRef([3; 32])));
130 
        assert_eq!(r.opt_object().unwrap(), None);
131 
        assert!(r.at_end());
132 
        let mut r = Reader::new(&w.0[..w.0.len() - 3]);
133 
        r.fixed::<13>().unwrap();
134 
        assert!(r.text().is_ok());
135 
        assert!(r.opt_object().is_err());
136 
    }
137 
}