lib0/
decoding.rs

1use crate::error::Error;
2use crate::number::{Signed, SignedVarInt, VarInt};
3
4#[derive(Default)]
5pub struct Cursor<'a> {
6    pub buf: &'a [u8],
7    pub next: usize,
8}
9
10impl<'a> Cursor<'a> {
11    pub fn new(buf: &'a [u8]) -> Cursor<'a> {
12        Cursor { buf, next: 0 }
13    }
14
15    pub fn has_content(&self) -> bool {
16        self.next != self.buf.len()
17    }
18}
19
20impl<'a, R> From<&'a R> for Cursor<'a>
21where
22    R: AsRef<[u8]>,
23{
24    fn from(buf: &'a R) -> Self {
25        Self::new(buf.as_ref())
26    }
27}
28
29impl<'a> Read for Cursor<'a> {
30    /// Take a slice of the next `len` bytes and advance the position by `len`.
31    fn read_exact(&mut self, len: usize) -> Result<&[u8], Error> {
32        if self.next + len > self.buf.len() {
33            Err(Error::EndOfBuffer(len))
34        } else {
35            let slice = &self.buf[self.next..(self.next + len)];
36            self.next += len as usize;
37            Ok(slice)
38        }
39    }
40
41    /// Read a single byte.
42    fn read_u8(&mut self) -> Result<u8, Error> {
43        if let Some(&b) = self.buf.get(self.next) {
44            self.next += 1;
45            Ok(b)
46        } else {
47            Err(Error::EndOfBuffer(1))
48        }
49    }
50}
51
52pub trait Read: Sized {
53    fn read_exact(&mut self, len: usize) -> Result<&[u8], Error>;
54
55    /// Read a single byte.
56    fn read_u8(&mut self) -> Result<u8, Error> {
57        let buf = self.read_exact(1)?;
58        Ok(buf[0])
59    }
60
61    /// Read a variable length buffer.
62    fn read_buf(&mut self) -> Result<&[u8], Error> {
63        let len: u32 = self.read_var()?;
64        self.read_exact(len as usize)
65    }
66
67    /// Read 2 bytes as unsigned integer
68    fn read_u16(&mut self) -> Result<u16, Error> {
69        let buf = self.read_exact(2)?;
70        Ok(buf[0] as u16 | ((buf[1] as u16) << 8))
71    }
72
73    /// Read 4 bytes as unsigned integer
74    fn read_u32(&mut self) -> Result<u32, Error> {
75        let buf = self.read_exact(4)?;
76        Ok(buf[0] as u32 | (buf[1] as u32) << 8 | (buf[2] as u32) << 16 | (buf[3] as u32) << 24)
77    }
78
79    /// Read 4 bytes as unsigned integer in big endian order.
80    /// (most significant byte first)
81    fn read_u32_be(&mut self) -> Result<u32, Error> {
82        let buf = self.read_exact(4)?;
83        Ok((buf[0] as u32) << 24 | (buf[1] as u32) << 16 | (buf[2] as u32) << 8 | buf[3] as u32)
84    }
85
86    /// Read unsigned integer with variable length.
87    /// * numbers < 2^7 are stored in one byte
88    /// * numbers < 2^14 are stored in two bytes
89    #[inline]
90    fn read_var<T: VarInt>(&mut self) -> Result<T, Error> {
91        T::read(self)
92    }
93
94    /// Read unsigned integer with variable length.
95    /// * numbers < 2^7 are stored in one byte
96    /// * numbers < 2^14 are stored in two bytes
97    #[inline]
98    fn read_var_signed<T: SignedVarInt>(&mut self) -> Result<Signed<T>, Error> {
99        T::read_signed(self)
100    }
101
102    /// Read string of variable length.
103    fn read_string(&mut self) -> Result<&str, Error> {
104        let buf = self.read_buf()?;
105        Ok(unsafe { std::str::from_utf8_unchecked(buf) })
106    }
107
108    /// Read float32 in big endian order
109    fn read_f32(&mut self) -> Result<f32, Error> {
110        let mut buf = [0; 4];
111        let slice = self.read_exact(4)?;
112        buf.copy_from_slice(slice);
113        Ok(f32::from_be_bytes(buf))
114    }
115
116    /// Read float64 in big endian order
117    // @todo there must be a more elegant way to convert a slice to a fixed-length buffer.
118    fn read_f64(&mut self) -> Result<f64, Error> {
119        let mut buf = [0; 8];
120        let slice = self.read_exact(8)?;
121        buf.copy_from_slice(slice);
122        Ok(f64::from_be_bytes(buf))
123    }
124
125    /// Read BigInt64 in big endian order
126    fn read_i64(&mut self) -> Result<i64, Error> {
127        let mut buf = [0; 8];
128        let slice = self.read_exact(8)?;
129        buf.copy_from_slice(slice);
130        Ok(i64::from_be_bytes(buf))
131    }
132
133    /// read BigUInt64 in big endian order
134    fn read_u64(&mut self) -> Result<u64, Error> {
135        let mut buf = [0; 8];
136        let slice = self.read_exact(8)?;
137        buf.copy_from_slice(slice);
138        Ok(u64::from_be_bytes(buf))
139    }
140}
lib0/decoding.rs

lib0/
decoding.rs
