]>
Commit | Line | Data |
---|---|---|
1b1a35ee XL |
1 | #[cfg(test)] |
2 | mod tests; | |
3 | ||
532ac7d7 | 4 | use crate::cmp; |
532ac7d7 | 5 | use crate::fmt; |
60c5eb7d XL |
6 | use crate::io::{ |
7 | self, BufRead, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write, | |
8 | }; | |
532ac7d7 | 9 | use crate::mem; |
85aaf69f SL |
10 | |
11 | // ============================================================================= | |
12 | // Forwarding implementations | |
13 | ||
c34b1796 | 14 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 15 | impl<R: Read + ?Sized> Read for &mut R { |
c34b1796 AL |
16 | #[inline] |
17 | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { | |
18 | (**self).read(buf) | |
19 | } | |
20 | ||
9fa01778 | 21 | #[inline] |
48663c56 | 22 | fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { |
9fa01778 XL |
23 | (**self).read_vectored(bufs) |
24 | } | |
25 | ||
f9f354fc XL |
26 | #[inline] |
27 | fn is_read_vectored(&self) -> bool { | |
28 | (**self).is_read_vectored() | |
29 | } | |
30 | ||
041b39d2 XL |
31 | #[inline] |
32 | unsafe fn initializer(&self) -> Initializer { | |
33 | (**self).initializer() | |
34 | } | |
35 | ||
c34b1796 AL |
36 | #[inline] |
37 | fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { | |
38 | (**self).read_to_end(buf) | |
39 | } | |
40 | ||
41 | #[inline] | |
42 | fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { | |
43 | (**self).read_to_string(buf) | |
44 | } | |
e9174d1e SL |
45 | |
46 | #[inline] | |
47 | fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { | |
48 | (**self).read_exact(buf) | |
49 | } | |
85aaf69f | 50 | } |
c34b1796 | 51 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 52 | impl<W: Write + ?Sized> Write for &mut W { |
c34b1796 | 53 | #[inline] |
60c5eb7d XL |
54 | fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
55 | (**self).write(buf) | |
56 | } | |
c34b1796 | 57 | |
9fa01778 | 58 | #[inline] |
48663c56 | 59 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
60 | (**self).write_vectored(bufs) |
61 | } | |
62 | ||
f9f354fc XL |
63 | #[inline] |
64 | fn is_write_vectored(&self) -> bool { | |
65 | (**self).is_write_vectored() | |
66 | } | |
67 | ||
c34b1796 | 68 | #[inline] |
60c5eb7d XL |
69 | fn flush(&mut self) -> io::Result<()> { |
70 | (**self).flush() | |
71 | } | |
c34b1796 AL |
72 | |
73 | #[inline] | |
74 | fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { | |
75 | (**self).write_all(buf) | |
76 | } | |
77 | ||
78 | #[inline] | |
532ac7d7 | 79 | fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> { |
c34b1796 AL |
80 | (**self).write_fmt(fmt) |
81 | } | |
85aaf69f | 82 | } |
c34b1796 | 83 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 84 | impl<S: Seek + ?Sized> Seek for &mut S { |
c34b1796 | 85 | #[inline] |
60c5eb7d XL |
86 | fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { |
87 | (**self).seek(pos) | |
88 | } | |
85aaf69f | 89 | } |
c34b1796 | 90 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 91 | impl<B: BufRead + ?Sized> BufRead for &mut B { |
c34b1796 | 92 | #[inline] |
60c5eb7d XL |
93 | fn fill_buf(&mut self) -> io::Result<&[u8]> { |
94 | (**self).fill_buf() | |
95 | } | |
c34b1796 AL |
96 | |
97 | #[inline] | |
60c5eb7d XL |
98 | fn consume(&mut self, amt: usize) { |
99 | (**self).consume(amt) | |
100 | } | |
c34b1796 AL |
101 | |
102 | #[inline] | |
103 | fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> { | |
104 | (**self).read_until(byte, buf) | |
105 | } | |
106 | ||
107 | #[inline] | |
108 | fn read_line(&mut self, buf: &mut String) -> io::Result<usize> { | |
109 | (**self).read_line(buf) | |
110 | } | |
85aaf69f SL |
111 | } |
112 | ||
c34b1796 | 113 | #[stable(feature = "rust1", since = "1.0.0")] |
85aaf69f | 114 | impl<R: Read + ?Sized> Read for Box<R> { |
c34b1796 AL |
115 | #[inline] |
116 | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { | |
117 | (**self).read(buf) | |
118 | } | |
119 | ||
9fa01778 | 120 | #[inline] |
48663c56 | 121 | fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { |
9fa01778 XL |
122 | (**self).read_vectored(bufs) |
123 | } | |
124 | ||
f9f354fc XL |
125 | #[inline] |
126 | fn is_read_vectored(&self) -> bool { | |
127 | (**self).is_read_vectored() | |
128 | } | |
129 | ||
041b39d2 XL |
130 | #[inline] |
131 | unsafe fn initializer(&self) -> Initializer { | |
132 | (**self).initializer() | |
133 | } | |
134 | ||
c34b1796 AL |
135 | #[inline] |
136 | fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { | |
137 | (**self).read_to_end(buf) | |
138 | } | |
139 | ||
140 | #[inline] | |
141 | fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { | |
142 | (**self).read_to_string(buf) | |
143 | } | |
e9174d1e SL |
144 | |
145 | #[inline] | |
146 | fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { | |
147 | (**self).read_exact(buf) | |
148 | } | |
85aaf69f | 149 | } |
c34b1796 | 150 | #[stable(feature = "rust1", since = "1.0.0")] |
85aaf69f | 151 | impl<W: Write + ?Sized> Write for Box<W> { |
c34b1796 | 152 | #[inline] |
60c5eb7d XL |
153 | fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
154 | (**self).write(buf) | |
155 | } | |
c34b1796 | 156 | |
9fa01778 | 157 | #[inline] |
48663c56 | 158 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
159 | (**self).write_vectored(bufs) |
160 | } | |
161 | ||
f9f354fc XL |
162 | #[inline] |
163 | fn is_write_vectored(&self) -> bool { | |
164 | (**self).is_write_vectored() | |
165 | } | |
166 | ||
c34b1796 | 167 | #[inline] |
60c5eb7d XL |
168 | fn flush(&mut self) -> io::Result<()> { |
169 | (**self).flush() | |
170 | } | |
c34b1796 AL |
171 | |
172 | #[inline] | |
173 | fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { | |
174 | (**self).write_all(buf) | |
175 | } | |
176 | ||
177 | #[inline] | |
532ac7d7 | 178 | fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> { |
c34b1796 AL |
179 | (**self).write_fmt(fmt) |
180 | } | |
85aaf69f | 181 | } |
c34b1796 | 182 | #[stable(feature = "rust1", since = "1.0.0")] |
85aaf69f | 183 | impl<S: Seek + ?Sized> Seek for Box<S> { |
c34b1796 | 184 | #[inline] |
60c5eb7d XL |
185 | fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { |
186 | (**self).seek(pos) | |
187 | } | |
85aaf69f | 188 | } |
c34b1796 | 189 | #[stable(feature = "rust1", since = "1.0.0")] |
85aaf69f | 190 | impl<B: BufRead + ?Sized> BufRead for Box<B> { |
c34b1796 | 191 | #[inline] |
60c5eb7d XL |
192 | fn fill_buf(&mut self) -> io::Result<&[u8]> { |
193 | (**self).fill_buf() | |
194 | } | |
c34b1796 AL |
195 | |
196 | #[inline] | |
60c5eb7d XL |
197 | fn consume(&mut self, amt: usize) { |
198 | (**self).consume(amt) | |
199 | } | |
c34b1796 AL |
200 | |
201 | #[inline] | |
202 | fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> { | |
203 | (**self).read_until(byte, buf) | |
204 | } | |
205 | ||
206 | #[inline] | |
207 | fn read_line(&mut self, buf: &mut String) -> io::Result<usize> { | |
208 | (**self).read_line(buf) | |
209 | } | |
85aaf69f SL |
210 | } |
211 | ||
212 | // ============================================================================= | |
213 | // In-memory buffer implementations | |
214 | ||
c30ab7b3 SL |
215 | /// Read is implemented for `&[u8]` by copying from the slice. |
216 | /// | |
217 | /// Note that reading updates the slice to point to the yet unread part. | |
218 | /// The slice will be empty when EOF is reached. | |
c34b1796 | 219 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 220 | impl Read for &[u8] { |
c34b1796 | 221 | #[inline] |
85aaf69f SL |
222 | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
223 | let amt = cmp::min(buf.len(), self.len()); | |
224 | let (a, b) = self.split_at(amt); | |
476ff2be SL |
225 | |
226 | // First check if the amount of bytes we want to read is small: | |
227 | // `copy_from_slice` will generally expand to a call to `memcpy`, and | |
228 | // for a single byte the overhead is significant. | |
229 | if amt == 1 { | |
230 | buf[0] = a[0]; | |
231 | } else { | |
232 | buf[..amt].copy_from_slice(a); | |
233 | } | |
234 | ||
85aaf69f SL |
235 | *self = b; |
236 | Ok(amt) | |
237 | } | |
e9174d1e | 238 | |
9fa01778 | 239 | #[inline] |
48663c56 | 240 | fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { |
9fa01778 XL |
241 | let mut nread = 0; |
242 | for buf in bufs { | |
243 | nread += self.read(buf)?; | |
244 | if self.is_empty() { | |
245 | break; | |
246 | } | |
247 | } | |
248 | ||
249 | Ok(nread) | |
250 | } | |
251 | ||
f9f354fc XL |
252 | #[inline] |
253 | fn is_read_vectored(&self) -> bool { | |
254 | true | |
255 | } | |
256 | ||
041b39d2 XL |
257 | #[inline] |
258 | unsafe fn initializer(&self) -> Initializer { | |
259 | Initializer::nop() | |
260 | } | |
261 | ||
e9174d1e SL |
262 | #[inline] |
263 | fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { | |
264 | if buf.len() > self.len() { | |
60c5eb7d | 265 | return Err(Error::new(ErrorKind::UnexpectedEof, "failed to fill whole buffer")); |
e9174d1e SL |
266 | } |
267 | let (a, b) = self.split_at(buf.len()); | |
476ff2be SL |
268 | |
269 | // First check if the amount of bytes we want to read is small: | |
270 | // `copy_from_slice` will generally expand to a call to `memcpy`, and | |
271 | // for a single byte the overhead is significant. | |
272 | if buf.len() == 1 { | |
273 | buf[0] = a[0]; | |
274 | } else { | |
275 | buf.copy_from_slice(a); | |
276 | } | |
277 | ||
e9174d1e SL |
278 | *self = b; |
279 | Ok(()) | |
280 | } | |
ea8adc8c XL |
281 | |
282 | #[inline] | |
283 | fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { | |
284 | buf.extend_from_slice(*self); | |
285 | let len = self.len(); | |
286 | *self = &self[len..]; | |
287 | Ok(len) | |
288 | } | |
85aaf69f SL |
289 | } |
290 | ||
c34b1796 | 291 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 292 | impl BufRead for &[u8] { |
c34b1796 | 293 | #[inline] |
60c5eb7d XL |
294 | fn fill_buf(&mut self) -> io::Result<&[u8]> { |
295 | Ok(*self) | |
296 | } | |
c34b1796 AL |
297 | |
298 | #[inline] | |
60c5eb7d XL |
299 | fn consume(&mut self, amt: usize) { |
300 | *self = &self[amt..]; | |
301 | } | |
85aaf69f SL |
302 | } |
303 | ||
c30ab7b3 SL |
304 | /// Write is implemented for `&mut [u8]` by copying into the slice, overwriting |
305 | /// its data. | |
306 | /// | |
307 | /// Note that writing updates the slice to point to the yet unwritten part. | |
308 | /// The slice will be empty when it has been completely overwritten. | |
fc512014 XL |
309 | /// |
310 | /// If the number of bytes to be written exceeds the size of the slice, write operations will | |
311 | /// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of | |
312 | /// kind `ErrorKind::WriteZero`. | |
c34b1796 | 313 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 314 | impl Write for &mut [u8] { |
c34b1796 | 315 | #[inline] |
85aaf69f SL |
316 | fn write(&mut self, data: &[u8]) -> io::Result<usize> { |
317 | let amt = cmp::min(data.len(), self.len()); | |
318 | let (a, b) = mem::replace(self, &mut []).split_at_mut(amt); | |
7453a54e | 319 | a.copy_from_slice(&data[..amt]); |
85aaf69f SL |
320 | *self = b; |
321 | Ok(amt) | |
322 | } | |
c34b1796 | 323 | |
9fa01778 | 324 | #[inline] |
48663c56 | 325 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
326 | let mut nwritten = 0; |
327 | for buf in bufs { | |
328 | nwritten += self.write(buf)?; | |
329 | if self.is_empty() { | |
330 | break; | |
331 | } | |
332 | } | |
333 | ||
334 | Ok(nwritten) | |
335 | } | |
336 | ||
f9f354fc XL |
337 | #[inline] |
338 | fn is_write_vectored(&self) -> bool { | |
339 | true | |
340 | } | |
341 | ||
c34b1796 AL |
342 | #[inline] |
343 | fn write_all(&mut self, data: &[u8]) -> io::Result<()> { | |
54a0048b | 344 | if self.write(data)? == data.len() { |
c34b1796 AL |
345 | Ok(()) |
346 | } else { | |
347 | Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer")) | |
348 | } | |
349 | } | |
350 | ||
351 | #[inline] | |
60c5eb7d XL |
352 | fn flush(&mut self) -> io::Result<()> { |
353 | Ok(()) | |
354 | } | |
85aaf69f SL |
355 | } |
356 | ||
c30ab7b3 SL |
357 | /// Write is implemented for `Vec<u8>` by appending to the vector. |
358 | /// The vector will grow as needed. | |
c34b1796 | 359 | #[stable(feature = "rust1", since = "1.0.0")] |
85aaf69f | 360 | impl Write for Vec<u8> { |
c34b1796 | 361 | #[inline] |
85aaf69f | 362 | fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
92a42be0 | 363 | self.extend_from_slice(buf); |
85aaf69f SL |
364 | Ok(buf.len()) |
365 | } | |
c34b1796 | 366 | |
9fa01778 | 367 | #[inline] |
48663c56 | 368 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
369 | let len = bufs.iter().map(|b| b.len()).sum(); |
370 | self.reserve(len); | |
371 | for buf in bufs { | |
372 | self.extend_from_slice(buf); | |
373 | } | |
374 | Ok(len) | |
375 | } | |
376 | ||
f9f354fc XL |
377 | #[inline] |
378 | fn is_write_vectored(&self) -> bool { | |
379 | true | |
380 | } | |
381 | ||
c34b1796 AL |
382 | #[inline] |
383 | fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { | |
92a42be0 | 384 | self.extend_from_slice(buf); |
c34b1796 AL |
385 | Ok(()) |
386 | } | |
387 | ||
388 | #[inline] | |
60c5eb7d XL |
389 | fn flush(&mut self) -> io::Result<()> { |
390 | Ok(()) | |
391 | } | |
85aaf69f | 392 | } |