std/io/
impls.rs

1#[cfg(test)]
2mod tests;
3
4use crate::alloc::Allocator;
5use crate::collections::VecDeque;
6use crate::io::{self, BorrowedCursor, BufRead, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
7use crate::{cmp, fmt, mem, str};
8
9// =============================================================================
10// Forwarding implementations
11
12#[stable(feature = "rust1", since = "1.0.0")]
13impl<R: Read + ?Sized> Read for &mut R {
14    #[inline]
15    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
16        (**self).read(buf)
17    }
18
19    #[inline]
20    fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
21        (**self).read_buf(cursor)
22    }
23
24    #[inline]
25    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
26        (**self).read_vectored(bufs)
27    }
28
29    #[inline]
30    fn is_read_vectored(&self) -> bool {
31        (**self).is_read_vectored()
32    }
33
34    #[inline]
35    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
36        (**self).read_to_end(buf)
37    }
38
39    #[inline]
40    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
41        (**self).read_to_string(buf)
42    }
43
44    #[inline]
45    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
46        (**self).read_exact(buf)
47    }
48
49    #[inline]
50    fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
51        (**self).read_buf_exact(cursor)
52    }
53}
54#[stable(feature = "rust1", since = "1.0.0")]
55impl<W: Write + ?Sized> Write for &mut W {
56    #[inline]
57    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
58        (**self).write(buf)
59    }
60
61    #[inline]
62    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
63        (**self).write_vectored(bufs)
64    }
65
66    #[inline]
67    fn is_write_vectored(&self) -> bool {
68        (**self).is_write_vectored()
69    }
70
71    #[inline]
72    fn flush(&mut self) -> io::Result<()> {
73        (**self).flush()
74    }
75
76    #[inline]
77    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
78        (**self).write_all(buf)
79    }
80
81    #[inline]
82    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
83        (**self).write_all_vectored(bufs)
84    }
85
86    #[inline]
87    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
88        (**self).write_fmt(fmt)
89    }
90}
91#[stable(feature = "rust1", since = "1.0.0")]
92impl<S: Seek + ?Sized> Seek for &mut S {
93    #[inline]
94    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
95        (**self).seek(pos)
96    }
97
98    #[inline]
99    fn rewind(&mut self) -> io::Result<()> {
100        (**self).rewind()
101    }
102
103    #[inline]
104    fn stream_len(&mut self) -> io::Result<u64> {
105        (**self).stream_len()
106    }
107
108    #[inline]
109    fn stream_position(&mut self) -> io::Result<u64> {
110        (**self).stream_position()
111    }
112
113    #[inline]
114    fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
115        (**self).seek_relative(offset)
116    }
117}
118#[stable(feature = "rust1", since = "1.0.0")]
119impl<B: BufRead + ?Sized> BufRead for &mut B {
120    #[inline]
121    fn fill_buf(&mut self) -> io::Result<&[u8]> {
122        (**self).fill_buf()
123    }
124
125    #[inline]
126    fn consume(&mut self, amt: usize) {
127        (**self).consume(amt)
128    }
129
130    #[inline]
131    fn has_data_left(&mut self) -> io::Result<bool> {
132        (**self).has_data_left()
133    }
134
135    #[inline]
136    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
137        (**self).read_until(byte, buf)
138    }
139
140    #[inline]
141    fn skip_until(&mut self, byte: u8) -> io::Result<usize> {
142        (**self).skip_until(byte)
143    }
144
145    #[inline]
146    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
147        (**self).read_line(buf)
148    }
149}
150
151#[stable(feature = "rust1", since = "1.0.0")]
152impl<R: Read + ?Sized> Read for Box<R> {
153    #[inline]
154    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
155        (**self).read(buf)
156    }
157
158    #[inline]
159    fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
160        (**self).read_buf(cursor)
161    }
162
163    #[inline]
164    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
165        (**self).read_vectored(bufs)
166    }
167
168    #[inline]
169    fn is_read_vectored(&self) -> bool {
170        (**self).is_read_vectored()
171    }
172
173    #[inline]
174    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
175        (**self).read_to_end(buf)
176    }
177
178    #[inline]
179    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
180        (**self).read_to_string(buf)
181    }
182
183    #[inline]
184    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
185        (**self).read_exact(buf)
186    }
187
188    #[inline]
189    fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
190        (**self).read_buf_exact(cursor)
191    }
192}
193#[stable(feature = "rust1", since = "1.0.0")]
194impl<W: Write + ?Sized> Write for Box<W> {
195    #[inline]
196    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
197        (**self).write(buf)
198    }
199
200    #[inline]
201    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
202        (**self).write_vectored(bufs)
203    }
204
205    #[inline]
206    fn is_write_vectored(&self) -> bool {
207        (**self).is_write_vectored()
208    }
209
210    #[inline]
211    fn flush(&mut self) -> io::Result<()> {
212        (**self).flush()
213    }
214
215    #[inline]
216    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
217        (**self).write_all(buf)
218    }
219
220    #[inline]
221    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
222        (**self).write_all_vectored(bufs)
223    }
224
225    #[inline]
226    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
227        (**self).write_fmt(fmt)
228    }
229}
230#[stable(feature = "rust1", since = "1.0.0")]
231impl<S: Seek + ?Sized> Seek for Box<S> {
232    #[inline]
233    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
234        (**self).seek(pos)
235    }
236
237    #[inline]
238    fn rewind(&mut self) -> io::Result<()> {
239        (**self).rewind()
240    }
241
242    #[inline]
243    fn stream_len(&mut self) -> io::Result<u64> {
244        (**self).stream_len()
245    }
246
247    #[inline]
248    fn stream_position(&mut self) -> io::Result<u64> {
249        (**self).stream_position()
250    }
251
252    #[inline]
253    fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
254        (**self).seek_relative(offset)
255    }
256}
257#[stable(feature = "rust1", since = "1.0.0")]
258impl<B: BufRead + ?Sized> BufRead for Box<B> {
259    #[inline]
260    fn fill_buf(&mut self) -> io::Result<&[u8]> {
261        (**self).fill_buf()
262    }
263
264    #[inline]
265    fn consume(&mut self, amt: usize) {
266        (**self).consume(amt)
267    }
268
269    #[inline]
270    fn has_data_left(&mut self) -> io::Result<bool> {
271        (**self).has_data_left()
272    }
273
274    #[inline]
275    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
276        (**self).read_until(byte, buf)
277    }
278
279    #[inline]
280    fn skip_until(&mut self, byte: u8) -> io::Result<usize> {
281        (**self).skip_until(byte)
282    }
283
284    #[inline]
285    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
286        (**self).read_line(buf)
287    }
288}
289
290// =============================================================================
291// In-memory buffer implementations
292
293/// Read is implemented for `&[u8]` by copying from the slice.
294///
295/// Note that reading updates the slice to point to the yet unread part.
296/// The slice will be empty when EOF is reached.
297#[stable(feature = "rust1", since = "1.0.0")]
298impl Read for &[u8] {
299    #[inline]
300    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
301        let amt = cmp::min(buf.len(), self.len());
302        let (a, b) = self.split_at(amt);
303
304        // First check if the amount of bytes we want to read is small:
305        // `copy_from_slice` will generally expand to a call to `memcpy`, and
306        // for a single byte the overhead is significant.
307        if amt == 1 {
308            buf[0] = a[0];
309        } else {
310            buf[..amt].copy_from_slice(a);
311        }
312
313        *self = b;
314        Ok(amt)
315    }
316
317    #[inline]
318    fn read_buf(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
319        let amt = cmp::min(cursor.capacity(), self.len());
320        let (a, b) = self.split_at(amt);
321
322        cursor.append(a);
323
324        *self = b;
325        Ok(())
326    }
327
328    #[inline]
329    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
330        let mut nread = 0;
331        for buf in bufs {
332            nread += self.read(buf)?;
333            if self.is_empty() {
334                break;
335            }
336        }
337
338        Ok(nread)
339    }
340
341    #[inline]
342    fn is_read_vectored(&self) -> bool {
343        true
344    }
345
346    #[inline]
347    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
348        if buf.len() > self.len() {
349            // `read_exact` makes no promise about the content of `buf` if it
350            // fails so don't bother about that.
351            *self = &self[self.len()..];
352            return Err(io::Error::READ_EXACT_EOF);
353        }
354        let (a, b) = self.split_at(buf.len());
355
356        // First check if the amount of bytes we want to read is small:
357        // `copy_from_slice` will generally expand to a call to `memcpy`, and
358        // for a single byte the overhead is significant.
359        if buf.len() == 1 {
360            buf[0] = a[0];
361        } else {
362            buf.copy_from_slice(a);
363        }
364
365        *self = b;
366        Ok(())
367    }
368
369    #[inline]
370    fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
371        if cursor.capacity() > self.len() {
372            // Append everything we can to the cursor.
373            cursor.append(*self);
374            *self = &self[self.len()..];
375            return Err(io::Error::READ_EXACT_EOF);
376        }
377        let (a, b) = self.split_at(cursor.capacity());
378
379        cursor.append(a);
380
381        *self = b;
382        Ok(())
383    }
384
385    #[inline]
386    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
387        let len = self.len();
388        buf.try_reserve(len)?;
389        buf.extend_from_slice(*self);
390        *self = &self[len..];
391        Ok(len)
392    }
393
394    #[inline]
395    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
396        let content = str::from_utf8(self).map_err(|_| io::Error::INVALID_UTF8)?;
397        let len = self.len();
398        buf.try_reserve(len)?;
399        buf.push_str(content);
400        *self = &self[len..];
401        Ok(len)
402    }
403}
404
405#[stable(feature = "rust1", since = "1.0.0")]
406impl BufRead for &[u8] {
407    #[inline]
408    fn fill_buf(&mut self) -> io::Result<&[u8]> {
409        Ok(*self)
410    }
411
412    #[inline]
413    fn consume(&mut self, amt: usize) {
414        *self = &self[amt..];
415    }
416}
417
418/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
419/// its data.
420///
421/// Note that writing updates the slice to point to the yet unwritten part.
422/// The slice will be empty when it has been completely overwritten.
423///
424/// If the number of bytes to be written exceeds the size of the slice, write operations will
425/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
426/// kind `ErrorKind::WriteZero`.
427#[stable(feature = "rust1", since = "1.0.0")]
428impl Write for &mut [u8] {
429    #[inline]
430    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
431        let amt = cmp::min(data.len(), self.len());
432        let (a, b) = mem::take(self).split_at_mut(amt);
433        a.copy_from_slice(&data[..amt]);
434        *self = b;
435        Ok(amt)
436    }
437
438    #[inline]
439    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
440        let mut nwritten = 0;
441        for buf in bufs {
442            nwritten += self.write(buf)?;
443            if self.is_empty() {
444                break;
445            }
446        }
447
448        Ok(nwritten)
449    }
450
451    #[inline]
452    fn is_write_vectored(&self) -> bool {
453        true
454    }
455
456    #[inline]
457    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
458        if self.write(data)? < data.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
459    }
460
461    #[inline]
462    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
463        for buf in bufs {
464            if self.write(buf)? < buf.len() {
465                return Err(io::Error::WRITE_ALL_EOF);
466            }
467        }
468        Ok(())
469    }
470
471    #[inline]
472    fn flush(&mut self) -> io::Result<()> {
473        Ok(())
474    }
475}
476
477/// Write is implemented for `Vec<u8>` by appending to the vector.
478/// The vector will grow as needed.
479#[stable(feature = "rust1", since = "1.0.0")]
480impl<A: Allocator> Write for Vec<u8, A> {
481    #[inline]
482    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
483        self.extend_from_slice(buf);
484        Ok(buf.len())
485    }
486
487    #[inline]
488    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
489        let len = bufs.iter().map(|b| b.len()).sum();
490        self.reserve(len);
491        for buf in bufs {
492            self.extend_from_slice(buf);
493        }
494        Ok(len)
495    }
496
497    #[inline]
498    fn is_write_vectored(&self) -> bool {
499        true
500    }
501
502    #[inline]
503    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
504        self.extend_from_slice(buf);
505        Ok(())
506    }
507
508    #[inline]
509    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
510        self.write_vectored(bufs)?;
511        Ok(())
512    }
513
514    #[inline]
515    fn flush(&mut self) -> io::Result<()> {
516        Ok(())
517    }
518}
519
520/// Read is implemented for `VecDeque<u8>` by consuming bytes from the front of the `VecDeque`.
521#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
522impl<A: Allocator> Read for VecDeque<u8, A> {
523    /// Fill `buf` with the contents of the "front" slice as returned by
524    /// [`as_slices`][`VecDeque::as_slices`]. If the contained byte slices of the `VecDeque` are
525    /// discontiguous, multiple calls to `read` will be needed to read the entire content.
526    #[inline]
527    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
528        let (ref mut front, _) = self.as_slices();
529        let n = Read::read(front, buf)?;
530        self.drain(..n);
531        Ok(n)
532    }
533
534    #[inline]
535    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
536        let (front, back) = self.as_slices();
537
538        // Use only the front buffer if it is big enough to fill `buf`, else use
539        // the back buffer too.
540        match buf.split_at_mut_checked(front.len()) {
541            None => buf.copy_from_slice(&front[..buf.len()]),
542            Some((buf_front, buf_back)) => match back.split_at_checked(buf_back.len()) {
543                Some((back, _)) => {
544                    buf_front.copy_from_slice(front);
545                    buf_back.copy_from_slice(back);
546                }
547                None => {
548                    self.clear();
549                    return Err(io::Error::READ_EXACT_EOF);
550                }
551            },
552        }
553
554        self.drain(..buf.len());
555        Ok(())
556    }
557
558    #[inline]
559    fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
560        let (ref mut front, _) = self.as_slices();
561        let n = cmp::min(cursor.capacity(), front.len());
562        Read::read_buf(front, cursor)?;
563        self.drain(..n);
564        Ok(())
565    }
566
567    #[inline]
568    fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
569        let len = cursor.capacity();
570        let (front, back) = self.as_slices();
571
572        match front.split_at_checked(cursor.capacity()) {
573            Some((front, _)) => cursor.append(front),
574            None => {
575                cursor.append(front);
576                match back.split_at_checked(cursor.capacity()) {
577                    Some((back, _)) => cursor.append(back),
578                    None => {
579                        cursor.append(back);
580                        self.clear();
581                        return Err(io::Error::READ_EXACT_EOF);
582                    }
583                }
584            }
585        }
586
587        self.drain(..len);
588        Ok(())
589    }
590
591    #[inline]
592    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
593        // The total len is known upfront so we can reserve it in a single call.
594        let len = self.len();
595        buf.try_reserve(len)?;
596
597        let (front, back) = self.as_slices();
598        buf.extend_from_slice(front);
599        buf.extend_from_slice(back);
600        self.clear();
601        Ok(len)
602    }
603
604    #[inline]
605    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
606        // SAFETY: We only append to the buffer
607        unsafe { io::append_to_string(buf, |buf| self.read_to_end(buf)) }
608    }
609}
610
611/// BufRead is implemented for `VecDeque<u8>` by reading bytes from the front of the `VecDeque`.
612#[stable(feature = "vecdeque_buf_read", since = "1.75.0")]
613impl<A: Allocator> BufRead for VecDeque<u8, A> {
614    /// Returns the contents of the "front" slice as returned by
615    /// [`as_slices`][`VecDeque::as_slices`]. If the contained byte slices of the `VecDeque` are
616    /// discontiguous, multiple calls to `fill_buf` will be needed to read the entire content.
617    #[inline]
618    fn fill_buf(&mut self) -> io::Result<&[u8]> {
619        let (front, _) = self.as_slices();
620        Ok(front)
621    }
622
623    #[inline]
624    fn consume(&mut self, amt: usize) {
625        self.drain(..amt);
626    }
627}
628
629/// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.
630#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
631impl<A: Allocator> Write for VecDeque<u8, A> {
632    #[inline]
633    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
634        self.extend(buf);
635        Ok(buf.len())
636    }
637
638    #[inline]
639    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
640        let len = bufs.iter().map(|b| b.len()).sum();
641        self.reserve(len);
642        for buf in bufs {
643            self.extend(&**buf);
644        }
645        Ok(len)
646    }
647
648    #[inline]
649    fn is_write_vectored(&self) -> bool {
650        true
651    }
652
653    #[inline]
654    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
655        self.extend(buf);
656        Ok(())
657    }
658
659    #[inline]
660    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
661        self.write_vectored(bufs)?;
662        Ok(())
663    }
664
665    #[inline]
666    fn flush(&mut self) -> io::Result<()> {
667        Ok(())
668    }
669}
670
671#[unstable(feature = "read_buf", issue = "78485")]
672impl<'a> io::Write for core::io::BorrowedCursor<'a> {
673    #[inline]
674    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
675        let amt = cmp::min(buf.len(), self.capacity());
676        self.append(&buf[..amt]);
677        Ok(amt)
678    }
679
680    #[inline]
681    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
682        let mut nwritten = 0;
683        for buf in bufs {
684            let n = self.write(buf)?;
685            nwritten += n;
686            if n < buf.len() {
687                break;
688            }
689        }
690        Ok(nwritten)
691    }
692
693    #[inline]
694    fn is_write_vectored(&self) -> bool {
695        true
696    }
697
698    #[inline]
699    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
700        if self.write(buf)? < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
701    }
702
703    #[inline]
704    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
705        for buf in bufs {
706            if self.write(buf)? < buf.len() {
707                return Err(io::Error::WRITE_ALL_EOF);
708            }
709        }
710        Ok(())
711    }
712
713    #[inline]
714    fn flush(&mut self) -> io::Result<()> {
715        Ok(())
716    }
717}
std/io/impls.rs

std/io/
impls.rs
