bincode_thin/de/
read.rs

1use error::Result;
2use serde;
3use std::io;
4
5/// An optional Read trait for advanced Bincode usage.
6///
7/// It is highly recommended to use bincode with `io::Read` or `&[u8]` before
8/// implementing a custom `BincodeRead`.
9pub trait BincodeRead<'storage>: io::Read {
10    /// Forwards reading `length` bytes of a string on to the serde reader.
11    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
12    where
13        V: serde::de::Visitor<'storage>;
14
15    /// Return the first `length` bytes of the internal byte buffer.
16    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>>;
17
18    /// Forwards reading `length` bytes on to the serde reader.
19    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
20    where
21        V: serde::de::Visitor<'storage>;
22}
23
24/// A BincodeRead implementation for byte slices
25/// NOT A PART OF THE STABLE PUBLIC API
26#[doc(hidden)]
27pub struct SliceReader<'storage> {
28    slice: &'storage [u8],
29}
30
31/// A BincodeRead implementation for io::Readers
32/// NOT A PART OF THE STABLE PUBLIC API
33#[doc(hidden)]
34pub struct IoReader<R> {
35    reader: R,
36    temp_buffer: Vec<u8>,
37}
38
39impl<'storage> SliceReader<'storage> {
40    /// Constructs a slice reader
41    pub fn new(bytes: &'storage [u8]) -> SliceReader<'storage> {
42        SliceReader { slice: bytes }
43    }
44}
45
46impl<R> IoReader<R> {
47    /// Constructs an IoReadReader
48    pub fn new(r: R) -> IoReader<R> {
49        IoReader {
50            reader: r,
51            temp_buffer: vec![],
52        }
53    }
54}
55
56impl<'storage> io::Read for SliceReader<'storage> {
57    #[inline(always)]
58    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
59        (&mut self.slice).read(out)
60    }
61    #[inline(always)]
62    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
63        (&mut self.slice).read_exact(out)
64    }
65}
66
67impl<R: io::Read> io::Read for IoReader<R> {
68    #[inline(always)]
69    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
70        self.reader.read(out)
71    }
72    #[inline(always)]
73    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
74        self.reader.read_exact(out)
75    }
76}
77
78impl<'storage> SliceReader<'storage> {
79    #[inline(always)]
80    fn unexpected_eof() -> Box<::ErrorKind> {
81        return Box::new(::ErrorKind::Io(io::Error::new(
82            io::ErrorKind::UnexpectedEof,
83            "",
84        )));
85    }
86}
87
88impl<'storage> BincodeRead<'storage> for SliceReader<'storage> {
89    #[inline(always)]
90    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
91    where
92        V: serde::de::Visitor<'storage>,
93    {
94        use ErrorKind;
95        if length > self.slice.len() {
96            return Err(SliceReader::unexpected_eof());
97        }
98
99        let string = match ::std::str::from_utf8(&self.slice[..length]) {
100            Ok(s) => s,
101            Err(e) => return Err(ErrorKind::InvalidUtf8Encoding(e).into()),
102        };
103        let r = visitor.visit_borrowed_str(string);
104        self.slice = &self.slice[length..];
105        r
106    }
107
108    #[inline(always)]
109    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>> {
110        if length > self.slice.len() {
111            return Err(SliceReader::unexpected_eof());
112        }
113
114        let r = &self.slice[..length];
115        self.slice = &self.slice[length..];
116        Ok(r.to_vec())
117    }
118
119    #[inline(always)]
120    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
121    where
122        V: serde::de::Visitor<'storage>,
123    {
124        if length > self.slice.len() {
125            return Err(SliceReader::unexpected_eof());
126        }
127
128        let r = visitor.visit_borrowed_bytes(&self.slice[..length]);
129        self.slice = &self.slice[length..];
130        r
131    }
132}
133
134impl<R> IoReader<R>
135where
136    R: io::Read,
137{
138    fn fill_buffer(&mut self, length: usize) -> Result<()> {
139        let current_length = self.temp_buffer.len();
140        if length > current_length {
141            self.temp_buffer.reserve_exact(length - current_length);
142        }
143
144        unsafe {
145            self.temp_buffer.set_len(length);
146        }
147
148        self.reader.read_exact(&mut self.temp_buffer)?;
149        Ok(())
150    }
151}
152
153impl<R> BincodeRead<'static> for IoReader<R>
154where
155    R: io::Read,
156{
157    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
158    where
159        V: serde::de::Visitor<'static>,
160    {
161        self.fill_buffer(length)?;
162
163        let string = match ::std::str::from_utf8(&self.temp_buffer[..]) {
164            Ok(s) => s,
165            Err(e) => return Err(::ErrorKind::InvalidUtf8Encoding(e).into()),
166        };
167
168        let r = visitor.visit_str(string);
169        r
170    }
171
172    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>> {
173        self.fill_buffer(length)?;
174        Ok(::std::mem::replace(&mut self.temp_buffer, Vec::new()))
175    }
176
177    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
178    where
179        V: serde::de::Visitor<'static>,
180    {
181        self.fill_buffer(length)?;
182        let r = visitor.visit_bytes(&self.temp_buffer[..]);
183        r
184    }
185}
bincode_thin/de/read.rs

bincode_thin/de/
read.rs
