mla/layers/
raw.rs

1use std::io;
2use std::io::{Read, Seek, SeekFrom, Write};
3
4use crate::layers::traits::{
5    InnerWriterTrait, InnerWriterType, LayerFailSafeReader, LayerReader, LayerWriter,
6};
7use crate::Error;
8
9// ---------- Writer ----------
10
11/// Dummy layer, standing for the last layer (wrapping I/O)
12pub struct RawLayerWriter<W: InnerWriterTrait> {
13    inner: W,
14}
15
16impl<W: InnerWriterTrait> RawLayerWriter<W> {
17    pub fn new(inner: W) -> Self {
18        Self { inner }
19    }
20}
21
22impl<'a, W: InnerWriterTrait> LayerWriter<'a, W> for RawLayerWriter<W> {
23    fn into_inner(self) -> Option<InnerWriterType<'a, W>> {
24        None
25    }
26
27    fn into_raw(self: Box<Self>) -> W {
28        self.inner
29    }
30
31    fn finalize(&mut self) -> Result<(), Error> {
32        // No recursive call, this is the last layer
33        Ok(())
34    }
35}
36
37impl<W: InnerWriterTrait> Write for RawLayerWriter<W> {
38    /// Wrapper on inner
39    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
40        self.inner.write(buf)
41    }
42
43    /// Wrapper on inner
44    fn flush(&mut self) -> io::Result<()> {
45        self.inner.flush()
46    }
47}
48
49// ---------- Reader ----------
50
51/// Dummy layer, standing for the last layer (wrapping I/O)
52pub struct RawLayerReader<R: Read + Seek> {
53    inner: R,
54    // Offset to use in position
55    offset_pos: u64,
56}
57
58impl<R: Read + Seek> RawLayerReader<R> {
59    pub fn new(inner: R) -> Self {
60        Self {
61            inner,
62            offset_pos: 0,
63        }
64    }
65
66    /// Mark the current position as the position 0
67    pub fn reset_position(&mut self) -> io::Result<()> {
68        self.offset_pos = self.inner.stream_position()?;
69        Ok(())
70    }
71}
72
73impl<'a, R: Read + Seek> LayerReader<'a, R> for RawLayerReader<R> {
74    fn into_inner(self) -> Option<Box<dyn 'a + LayerReader<'a, R>>> {
75        None
76    }
77
78    fn into_raw(self: Box<Self>) -> R {
79        self.inner
80    }
81
82    fn initialize(&mut self) -> Result<(), Error> {
83        // No recursive call, this is the last layer
84        Ok(())
85    }
86}
87
88impl<R: Read + Seek> Seek for RawLayerReader<R> {
89    /// Offer a position relatively to `self.offset_pos`
90    fn seek(&mut self, ask_pos: SeekFrom) -> io::Result<u64> {
91        match ask_pos {
92            SeekFrom::Start(pos) => {
93                self.inner.seek(SeekFrom::Start(self.offset_pos + pos))?;
94                Ok(pos)
95            }
96            SeekFrom::Current(_pos) => {
97                let inner_pos = self.inner.seek(ask_pos)?;
98                if inner_pos < self.offset_pos {
99                    self.inner.seek(SeekFrom::Start(self.offset_pos))?;
100                    Ok(0)
101                } else {
102                    Ok(inner_pos - self.offset_pos)
103                }
104            }
105            SeekFrom::End(_pos) => {
106                let inner_pos = self.inner.seek(ask_pos)?;
107                if inner_pos < self.offset_pos {
108                    self.inner.seek(SeekFrom::Start(self.offset_pos))?;
109                    Ok(0)
110                } else {
111                    Ok(inner_pos - self.offset_pos)
112                }
113            }
114        }
115    }
116}
117
118impl<R: Read + Seek> Read for RawLayerReader<R> {
119    /// Wrapper on inner
120    fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
121        self.inner.read(into)
122    }
123}
124
125// ---------- FailSafeReader ----------
126
127/// Dummy layer, standing for the last layer (wrapping I/O)
128pub struct RawLayerFailSafeReader<R: Read> {
129    inner: R,
130}
131
132impl<R: Read> RawLayerFailSafeReader<R> {
133    pub fn new(inner: R) -> Self {
134        Self { inner }
135    }
136}
137
138impl<R: Read> Read for RawLayerFailSafeReader<R> {
139    /// Wrapper on inner
140    fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
141        self.inner.read(into)
142    }
143}
144
145impl<'a, R: Read> LayerFailSafeReader<'a, R> for RawLayerFailSafeReader<R> {
146    fn into_inner(self) -> Option<Box<dyn 'a + LayerFailSafeReader<'a, R>>> {
147        None
148    }
149
150    fn into_raw(self: Box<Self>) -> R {
151        self.inner
152    }
153}
154
155#[cfg(test)]
156mod tests {
157    use super::*;
158    use crate::layers::traits::{LayerReader, LayerWriter};
159
160    use std::io::{Cursor, Read, Seek, SeekFrom, Write};
161
162    static DATA: [u8; 4] = [1, 2, 3, 4];
163
164    #[test]
165    fn basic_ops() {
166        let buf = Vec::new();
167
168        // Write
169        let mut raw_w = Box::new(RawLayerWriter::new(buf));
170        raw_w.write_all(&DATA).unwrap();
171        raw_w.finalize().unwrap();
172
173        // Read
174        let buf = Cursor::new(raw_w.into_raw());
175        let mut raw_r = Box::new(RawLayerReader::new(buf));
176        raw_r.initialize().unwrap();
177        let mut output = Vec::new();
178        raw_r.read_to_end(&mut output).unwrap();
179        assert_eq!(output.as_slice(), &DATA);
180
181        // Seek
182        raw_r.seek(SeekFrom::Start(2)).unwrap();
183        let mut output = Vec::new();
184        raw_r.read_to_end(&mut output).unwrap();
185        assert_eq!(output.as_slice(), &DATA[2..]);
186    }
187
188    #[test]
189    fn relative_seek() {
190        let buf = Vec::new();
191
192        // Write
193        let mut raw_w = Box::new(RawLayerWriter::new(buf));
194        raw_w.write_all(&DATA).unwrap();
195        let data2 = b"abcdef";
196        raw_w.write_all(data2).unwrap();
197        raw_w.finalize().unwrap();
198
199        // Read
200        let buf = Cursor::new(raw_w.into_raw());
201        let mut raw_r = Box::new(RawLayerReader::new(buf));
202        raw_r.initialize().unwrap();
203        let mut output = [0u8; 4];
204        raw_r.read_exact(&mut output).unwrap();
205        assert_eq!(&output, &DATA);
206
207        // Start playing with relative seek
208        raw_r.reset_position().unwrap();
209        assert_eq!(raw_r.stream_position().unwrap(), 0);
210        assert_eq!(raw_r.seek(SeekFrom::Current(-1)).unwrap(), 0);
211        assert_eq!(raw_r.seek(SeekFrom::Current(1)).unwrap(), 1);
212        let mut buf = Vec::new();
213        raw_r.read_to_end(&mut buf).unwrap();
214        assert_eq!(buf.as_slice(), b"bcdef");
215        assert_eq!(raw_r.stream_position().unwrap(), data2.len() as u64);
216
217        raw_r.rewind().unwrap();
218        assert_eq!(raw_r.seek(SeekFrom::Start(3)).unwrap(), 3);
219        let mut buf = Vec::new();
220        raw_r.read_to_end(&mut buf).unwrap();
221        assert_eq!(buf.as_slice(), b"def");
222        assert_eq!(raw_r.stream_position().unwrap(), data2.len() as u64);
223
224        assert_eq!(raw_r.seek(SeekFrom::End(0)).unwrap(), data2.len() as u64);
225        assert_eq!(raw_r.seek(SeekFrom::End(-6)).unwrap(), 0);
226        assert_eq!(raw_r.seek(SeekFrom::End(-10)).unwrap(), 0);
227        assert_eq!(raw_r.seek(SeekFrom::End(-4)).unwrap(), 2);
228        let mut buf = Vec::new();
229        raw_r.read_to_end(&mut buf).unwrap();
230        assert_eq!(buf.as_slice(), b"cdef");
231        assert_eq!(raw_r.stream_position().unwrap(), data2.len() as u64);
232    }
233
234    #[test]
235    fn basic_failsafe_ops() {
236        let buf = Vec::new();
237
238        // Write
239        let mut raw_w = Box::new(RawLayerWriter::new(buf));
240        raw_w.write_all(&DATA).unwrap();
241        raw_w.finalize().unwrap();
242
243        // Read
244        let buf = raw_w.into_raw();
245        let mut raw_r = Box::new(RawLayerFailSafeReader::new(buf.as_slice()));
246        let mut output = Vec::new();
247        raw_r.read_to_end(&mut output).unwrap();
248        assert_eq!(output.as_slice(), &DATA);
249    }
250
251    #[test]
252    fn basic_failsafe_truncated() {
253        let buf = Vec::new();
254
255        // Write
256        let mut raw_w = Box::new(RawLayerWriter::new(buf));
257        raw_w.write_all(&DATA).unwrap();
258        raw_w.finalize().unwrap();
259
260        // Read
261        let buf = raw_w.into_raw();
262        // Truncate at the middle
263        let stop = buf.len() / 2;
264        let mut raw_r = Box::new(RawLayerFailSafeReader::new(&buf[..stop]));
265        let mut output = Vec::new();
266        raw_r.read_to_end(&mut output).unwrap();
267        // Thanks to the raw layer construction, we can recover `stop` bytes
268        assert_eq!(output.as_slice(), &DATA[..stop]);
269    }
270}
mla/layers/raw.rs

mla/layers/
raw.rs
