core/io/
impls.rs

1use crate::io::{self, IoSlice, Seek, SeekFrom, SizeHint, Write};
2use crate::{cmp, fmt, mem};
3
4// =============================================================================
5// Forwarding implementations
6
7#[doc(hidden)]
8#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
9impl<T> SizeHint for &mut T {
10    #[inline]
11    fn lower_bound(&self) -> usize {
12        SizeHint::lower_bound(*self)
13    }
14
15    #[inline]
16    fn upper_bound(&self) -> Option<usize> {
17        SizeHint::upper_bound(*self)
18    }
19}
20
21#[stable(feature = "rust1", since = "1.0.0")]
22impl<W: Write + ?Sized> Write for &mut W {
23    #[inline]
24    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
25        (**self).write(buf)
26    }
27
28    #[inline]
29    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
30        (**self).write_vectored(bufs)
31    }
32
33    #[inline]
34    fn is_write_vectored(&self) -> bool {
35        (**self).is_write_vectored()
36    }
37
38    #[inline]
39    fn flush(&mut self) -> io::Result<()> {
40        (**self).flush()
41    }
42
43    #[inline]
44    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
45        (**self).write_all(buf)
46    }
47
48    #[inline]
49    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
50        (**self).write_all_vectored(bufs)
51    }
52
53    #[inline]
54    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
55        (**self).write_fmt(fmt)
56    }
57}
58#[stable(feature = "rust1", since = "1.0.0")]
59impl<S: Seek + ?Sized> Seek for &mut S {
60    #[inline]
61    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
62        (**self).seek(pos)
63    }
64
65    #[inline]
66    fn rewind(&mut self) -> io::Result<()> {
67        (**self).rewind()
68    }
69
70    #[inline]
71    fn stream_len(&mut self) -> io::Result<u64> {
72        (**self).stream_len()
73    }
74
75    #[inline]
76    fn stream_position(&mut self) -> io::Result<u64> {
77        (**self).stream_position()
78    }
79
80    #[inline]
81    fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
82        (**self).seek_relative(offset)
83    }
84}
85
86// =============================================================================
87// In-memory buffer implementations
88
89#[doc(hidden)]
90#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
91impl SizeHint for &[u8] {
92    #[inline]
93    fn lower_bound(&self) -> usize {
94        self.len()
95    }
96
97    #[inline]
98    fn upper_bound(&self) -> Option<usize> {
99        Some(self.len())
100    }
101}
102
103/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
104/// its data.
105///
106/// Note that writing updates the slice to point to the yet unwritten part.
107/// The slice will be empty when it has been completely overwritten.
108///
109/// If the number of bytes to be written exceeds the size of the slice, write operations will
110/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
111/// kind `ErrorKind::WriteZero`.
112#[stable(feature = "rust1", since = "1.0.0")]
113impl Write for &mut [u8] {
114    #[inline]
115    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
116        let amt = cmp::min(data.len(), self.len());
117        let (a, b) = mem::take(self).split_at_mut(amt);
118        a.copy_from_slice(&data[..amt]);
119        *self = b;
120        Ok(amt)
121    }
122
123    #[inline]
124    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
125        let mut nwritten = 0;
126        for buf in bufs {
127            nwritten += self.write(buf)?;
128            if self.is_empty() {
129                break;
130            }
131        }
132
133        Ok(nwritten)
134    }
135
136    #[inline]
137    fn is_write_vectored(&self) -> bool {
138        true
139    }
140
141    #[inline]
142    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
143        if self.write(data)? < data.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
144    }
145
146    #[inline]
147    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
148        for buf in bufs {
149            if self.write(buf)? < buf.len() {
150                return Err(io::Error::WRITE_ALL_EOF);
151            }
152        }
153        Ok(())
154    }
155
156    #[inline]
157    fn flush(&mut self) -> io::Result<()> {
158        Ok(())
159    }
160}
161
162#[unstable(feature = "read_buf", issue = "78485")]
163impl<'a> io::Write for core::io::BorrowedCursor<'a, u8> {
164    #[inline]
165    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
166        let amt = cmp::min(buf.len(), self.capacity());
167        self.append(&buf[..amt]);
168        Ok(amt)
169    }
170
171    #[inline]
172    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
173        let mut nwritten = 0;
174        for buf in bufs {
175            let n = self.write(buf)?;
176            nwritten += n;
177            if n < buf.len() {
178                break;
179            }
180        }
181        Ok(nwritten)
182    }
183
184    #[inline]
185    fn is_write_vectored(&self) -> bool {
186        true
187    }
188
189    #[inline]
190    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
191        if self.write(buf)? < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
192    }
193
194    #[inline]
195    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
196        for buf in bufs {
197            if self.write(buf)? < buf.len() {
198                return Err(io::Error::WRITE_ALL_EOF);
199            }
200        }
201        Ok(())
202    }
203
204    #[inline]
205    fn flush(&mut self) -> io::Result<()> {
206        Ok(())
207    }
208}
core/io/impls.rs

core/io/
impls.rs
