src/libstd/io/impls.rs

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