src/libstd/io/buffered.rs

   1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Buffering wrappers for I/O traits
  12
  13 use cmp;
  14 use container::Container;
  15 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
  16 use iter::ExactSize;
  17 use ops::Drop;
  18 use option::{Some, None, Option};
  19 use result::{Ok, Err};
  20 use slice::{OwnedVector, ImmutableVector, MutableVector};
  21 use slice;
  22
  23 /// Wraps a Reader and buffers input from it
  24 ///
  25 /// It can be excessively inefficient to work directly with a `Reader` or
  26 /// `Writer`. Every call to `read` or `write` on `TcpStream` results in a
  27 /// system call, for example. This module provides structures that wrap
  28 /// `Readers`, `Writers`, and `Streams` and buffer input and output to them.
  29 ///
  30 /// # Example
  31 ///
  32 /// ```rust
  33 /// use std::io::{BufferedReader, File};
  34 ///
  35 /// let file = File::open(&Path::new("message.txt"));
  36 /// let mut reader = BufferedReader::new(file);
  37 ///
  38 /// let mut buf = [0, ..100];
  39 /// match reader.read(buf) {
  40 ///     Ok(nread) => println!("Read {} bytes", nread),
  41 ///     Err(e) => println!("error reading: {}", e)
  42 /// }
  43 /// ```
  44 pub struct BufferedReader<R> {
  45     priv inner: R,
  46     priv buf: ~[u8],
  47     priv pos: uint,
  48     priv cap: uint,
  49     priv eof: bool,
  50 }
  51
  52 impl<R: Reader> BufferedReader<R> {
  53     /// Creates a new `BufferedReader` with the specified buffer capacity
  54     pub fn with_capacity(cap: uint, inner: R) -> BufferedReader<R> {
  55         // It's *much* faster to create an uninitialized buffer than it is to
  56         // fill everything in with 0. This buffer is entirely an implementation
  57         // detail and is never exposed, so we're safe to not initialize
  58         // everything up-front. This allows creation of BufferedReader instances
  59         // to be very cheap (large mallocs are not nearly as expensive as large
  60         // callocs).
  61         let mut buf = slice::with_capacity(cap);
  62         unsafe { buf.set_len(cap); }
  63         BufferedReader {
  64             inner: inner,
  65             buf: buf,
  66             pos: 0,
  67             cap: 0,
  68             eof: false,
  69         }
  70     }
  71
  72     /// Creates a new `BufferedReader` with a default buffer capacity
  73     pub fn new(inner: R) -> BufferedReader<R> {
  74         BufferedReader::with_capacity(DEFAULT_BUF_SIZE, inner)
  75     }
  76
  77     /// Gets a reference to the underlying reader.
  78     ///
  79     /// This type does not expose the ability to get a mutable reference to the
  80     /// underlying reader because that could possibly corrupt the buffer.
  81     pub fn get_ref<'a>(&'a self) -> &'a R { &self.inner }
  82
  83     /// Unwraps this buffer, returning the underlying reader.
  84     ///
  85     /// Note that any leftover data in the internal buffer is lost.
  86     pub fn unwrap(self) -> R { self.inner }
  87 }
  88
  89 impl<R: Reader> Buffer for BufferedReader<R> {
  90     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
  91         if self.pos == self.cap {
  92             self.cap = try!(self.inner.read(self.buf));
  93             self.pos = 0;
  94         }
  95         Ok(self.buf.slice(self.pos, self.cap))
  96     }
  97
  98     fn consume(&mut self, amt: uint) {
  99         self.pos += amt;
 100         assert!(self.pos <= self.cap);
 101     }
 102 }
 103
 104 impl<R: Reader> Reader for BufferedReader<R> {
 105     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 106         let nread = {
 107             let available = try!(self.fill_buf());
 108             let nread = cmp::min(available.len(), buf.len());
 109             slice::bytes::copy_memory(buf, available.slice_to(nread));
 110             nread
 111         };
 112         self.pos += nread;
 113         Ok(nread)
 114     }
 115 }
 116
 117 /// Wraps a Writer and buffers output to it
 118 ///
 119 /// This writer will be flushed when it is dropped.
 120 ///
 121 /// # Example
 122 ///
 123 /// ```rust
 124 /// # #[allow(unused_must_use)];
 125 /// use std::io::{BufferedWriter, File};
 126 ///
 127 /// let file = File::open(&Path::new("message.txt"));
 128 /// let mut writer = BufferedWriter::new(file);
 129 ///
 130 /// writer.write_str("hello, world");
 131 /// writer.flush();
 132 /// ```
 133 pub struct BufferedWriter<W> {
 134     priv inner: Option<W>,
 135     priv buf: ~[u8],
 136     priv pos: uint
 137 }
 138
 139 impl<W: Writer> BufferedWriter<W> {
 140     /// Creates a new `BufferedWriter` with the specified buffer capacity
 141     pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
 142         // See comments in BufferedReader for why this uses unsafe code.
 143         let mut buf = slice::with_capacity(cap);
 144         unsafe { buf.set_len(cap); }
 145         BufferedWriter {
 146             inner: Some(inner),
 147             buf: buf,
 148             pos: 0
 149         }
 150     }
 151
 152     /// Creates a new `BufferedWriter` with a default buffer capacity
 153     pub fn new(inner: W) -> BufferedWriter<W> {
 154         BufferedWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
 155     }
 156
 157     fn flush_buf(&mut self) -> IoResult<()> {
 158         if self.pos != 0 {
 159             let ret = self.inner.get_mut_ref().write(self.buf.slice_to(self.pos));
 160             self.pos = 0;
 161             ret
 162         } else {
 163             Ok(())
 164         }
 165     }
 166
 167     /// Gets a reference to the underlying writer.
 168     ///
 169     /// This type does not expose the ability to get a mutable reference to the
 170     /// underlying reader because that could possibly corrupt the buffer.
 171     pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() }
 172
 173     /// Unwraps this buffer, returning the underlying writer.
 174     ///
 175     /// The buffer is flushed before returning the writer.
 176     pub fn unwrap(mut self) -> W {
 177         // FIXME(#12628): is failing the right thing to do if flushing fails?
 178         self.flush_buf().unwrap();
 179         self.inner.take_unwrap()
 180     }
 181 }
 182
 183 impl<W: Writer> Writer for BufferedWriter<W> {
 184     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
 185         if self.pos + buf.len() > self.buf.len() {
 186             try!(self.flush_buf());
 187         }
 188
 189         if buf.len() > self.buf.len() {
 190             self.inner.get_mut_ref().write(buf)
 191         } else {
 192             let dst = self.buf.mut_slice_from(self.pos);
 193             slice::bytes::copy_memory(dst, buf);
 194             self.pos += buf.len();
 195             Ok(())
 196         }
 197     }
 198
 199     fn flush(&mut self) -> IoResult<()> {
 200         self.flush_buf().and_then(|()| self.inner.get_mut_ref().flush())
 201     }
 202 }
 203
 204 #[unsafe_destructor]
 205 impl<W: Writer> Drop for BufferedWriter<W> {
 206     fn drop(&mut self) {
 207         if self.inner.is_some() {
 208             // FIXME(#12628): should this error be ignored?
 209             let _ = self.flush_buf();
 210         }
 211     }
 212 }
 213
 214 /// Wraps a Writer and buffers output to it, flushing whenever a newline (`0x0a`,
 215 /// `'\n'`) is detected.
 216 ///
 217 /// This writer will be flushed when it is dropped.
 218 pub struct LineBufferedWriter<W> {
 219     priv inner: BufferedWriter<W>,
 220 }
 221
 222 impl<W: Writer> LineBufferedWriter<W> {
 223     /// Creates a new `LineBufferedWriter`
 224     pub fn new(inner: W) -> LineBufferedWriter<W> {
 225         // Lines typically aren't that long, don't use a giant buffer
 226         LineBufferedWriter {
 227             inner: BufferedWriter::with_capacity(1024, inner)
 228         }
 229     }
 230
 231     /// Gets a reference to the underlying writer.
 232     ///
 233     /// This type does not expose the ability to get a mutable reference to the
 234     /// underlying reader because that could possibly corrupt the buffer.
 235     pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() }
 236
 237     /// Unwraps this buffer, returning the underlying writer.
 238     ///
 239     /// The internal buffer is flushed before returning the writer.
 240     pub fn unwrap(self) -> W { self.inner.unwrap() }
 241 }
 242
 243 impl<W: Writer> Writer for LineBufferedWriter<W> {
 244     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
 245         match buf.iter().rposition(|&b| b == '\n' as u8) {
 246             Some(i) => {
 247                 try!(self.inner.write(buf.slice_to(i + 1)));
 248                 try!(self.inner.flush());
 249                 try!(self.inner.write(buf.slice_from(i + 1)));
 250                 Ok(())
 251             }
 252             None => self.inner.write(buf),
 253         }
 254     }
 255
 256     fn flush(&mut self) -> IoResult<()> { self.inner.flush() }
 257 }
 258
 259 struct InternalBufferedWriter<W>(BufferedWriter<W>);
 260
 261 impl<W> InternalBufferedWriter<W> {
 262     fn get_mut_ref<'a>(&'a mut self) -> &'a mut BufferedWriter<W> {
 263         let InternalBufferedWriter(ref mut w) = *self;
 264         return w;
 265     }
 266 }
 267
 268 impl<W: Reader> Reader for InternalBufferedWriter<W> {
 269     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 270         self.get_mut_ref().inner.get_mut_ref().read(buf)
 271     }
 272 }
 273
 274 /// Wraps a Stream and buffers input and output to and from it.
 275 ///
 276 /// The output half will be flushed when this stream is dropped.
 277 ///
 278 /// # Example
 279 ///
 280 /// ```rust
 281 /// # #[allow(unused_must_use)];
 282 /// use std::io::{BufferedStream, File};
 283 ///
 284 /// let file = File::open(&Path::new("message.txt"));
 285 /// let mut stream = BufferedStream::new(file);
 286 ///
 287 /// stream.write("hello, world".as_bytes());
 288 /// stream.flush();
 289 ///
 290 /// let mut buf = [0, ..100];
 291 /// match stream.read(buf) {
 292 ///     Ok(nread) => println!("Read {} bytes", nread),
 293 ///     Err(e) => println!("error reading: {}", e)
 294 /// }
 295 /// ```
 296 pub struct BufferedStream<S> {
 297     priv inner: BufferedReader<InternalBufferedWriter<S>>
 298 }
 299
 300 impl<S: Stream> BufferedStream<S> {
 301     /// Creates a new buffered stream with explicitly listed capacities for the
 302     /// reader/writer buffer.
 303     pub fn with_capacities(reader_cap: uint, writer_cap: uint, inner: S)
 304                            -> BufferedStream<S> {
 305         let writer = BufferedWriter::with_capacity(writer_cap, inner);
 306         let internal_writer = InternalBufferedWriter(writer);
 307         let reader = BufferedReader::with_capacity(reader_cap,
 308                                                    internal_writer);
 309         BufferedStream { inner: reader }
 310     }
 311
 312     /// Creates a new buffered stream with the default reader/writer buffer
 313     /// capacities.
 314     pub fn new(inner: S) -> BufferedStream<S> {
 315         BufferedStream::with_capacities(DEFAULT_BUF_SIZE, DEFAULT_BUF_SIZE,
 316                                         inner)
 317     }
 318
 319     /// Gets a reference to the underlying stream.
 320     ///
 321     /// This type does not expose the ability to get a mutable reference to the
 322     /// underlying reader because that could possibly corrupt the buffer.
 323     pub fn get_ref<'a>(&'a self) -> &'a S {
 324         let InternalBufferedWriter(ref w) = self.inner.inner;
 325         w.get_ref()
 326     }
 327
 328     /// Unwraps this buffer, returning the underlying stream.
 329     ///
 330     /// The internal buffer is flushed before returning the stream. Any leftover
 331     /// data in the read buffer is lost.
 332     pub fn unwrap(self) -> S {
 333         let InternalBufferedWriter(w) = self.inner.inner;
 334         w.unwrap()
 335     }
 336 }
 337
 338 impl<S: Stream> Buffer for BufferedStream<S> {
 339     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> { self.inner.fill_buf() }
 340     fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
 341 }
 342
 343 impl<S: Stream> Reader for BufferedStream<S> {
 344     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 345         self.inner.read(buf)
 346     }
 347 }
 348
 349 impl<S: Stream> Writer for BufferedStream<S> {
 350     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
 351         self.inner.inner.get_mut_ref().write(buf)
 352     }
 353     fn flush(&mut self) -> IoResult<()> {
 354         self.inner.inner.get_mut_ref().flush()
 355     }
 356 }
 357
 358 #[cfg(test)]
 359 mod test {
 360     extern crate test;
 361     use io;
 362     use prelude::*;
 363     use super::*;
 364     use super::super::mem::{MemReader, MemWriter, BufReader};
 365     use Harness = self::test::BenchHarness;
 366
 367     /// A type, free to create, primarily intended for benchmarking creation of
 368     /// wrappers that, just for construction, don't need a Reader/Writer that
 369     /// does anything useful. Is equivalent to `/dev/null` in semantics.
 370     #[deriving(Clone,Eq,Ord)]
 371     pub struct NullStream;
 372
 373     impl Reader for NullStream {
 374         fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
 375             Err(io::standard_error(io::EndOfFile))
 376         }
 377     }
 378
 379     impl Writer for NullStream {
 380         fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
 381     }
 382
 383     /// A dummy reader intended at testing short-reads propagation.
 384     pub struct ShortReader {
 385         priv lengths: ~[uint],
 386     }
 387
 388     impl Reader for ShortReader {
 389         fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
 390             match self.lengths.shift() {
 391                 Some(i) => Ok(i),
 392                 None => Err(io::standard_error(io::EndOfFile))
 393             }
 394         }
 395     }
 396
 397     #[test]
 398     fn test_buffered_reader() {
 399         let inner = MemReader::new(~[0, 1, 2, 3, 4]);
 400         let mut reader = BufferedReader::with_capacity(2, inner);
 401
 402         let mut buf = [0, 0, 0];
 403         let nread = reader.read(buf);
 404         assert_eq!(Ok(2), nread);
 405         assert_eq!(buf.as_slice(), &[0, 1, 0]);
 406
 407         let mut buf = [0];
 408         let nread = reader.read(buf);
 409         assert_eq!(Ok(1), nread);
 410         assert_eq!(buf.as_slice(), &[2]);
 411
 412         let mut buf = [0, 0, 0];
 413         let nread = reader.read(buf);
 414         assert_eq!(Ok(1), nread);
 415         assert_eq!(buf.as_slice(), &[3, 0, 0]);
 416
 417         let nread = reader.read(buf);
 418         assert_eq!(Ok(1), nread);
 419         assert_eq!(buf.as_slice(), &[4, 0, 0]);
 420
 421         assert!(reader.read(buf).is_err());
 422     }
 423
 424     #[test]
 425     fn test_buffered_writer() {
 426         let inner = MemWriter::new();
 427         let mut writer = BufferedWriter::with_capacity(2, inner);
 428
 429         writer.write([0, 1]).unwrap();
 430         assert_eq!(writer.get_ref().get_ref(), &[]);
 431
 432         writer.write([2]).unwrap();
 433         assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 434
 435         writer.write([3]).unwrap();
 436         assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 437
 438         writer.flush().unwrap();
 439         assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
 440
 441         writer.write([4]).unwrap();
 442         writer.write([5]).unwrap();
 443         assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
 444
 445         writer.write([6]).unwrap();
 446         assert_eq!(&[0, 1, 2, 3, 4, 5],
 447                    writer.get_ref().get_ref());
 448
 449         writer.write([7, 8]).unwrap();
 450         assert_eq!(&[0, 1, 2, 3, 4, 5, 6],
 451                    writer.get_ref().get_ref());
 452
 453         writer.write([9, 10, 11]).unwrap();
 454         assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
 455                    writer.get_ref().get_ref());
 456
 457         writer.flush().unwrap();
 458         assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
 459                    writer.get_ref().get_ref());
 460     }
 461
 462     #[test]
 463     fn test_buffered_writer_inner_flushes() {
 464         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
 465         w.write([0, 1]).unwrap();
 466         assert_eq!(&[], w.get_ref().get_ref());
 467         let w = w.unwrap();
 468         assert_eq!(&[0, 1], w.get_ref());
 469     }
 470
 471     // This is just here to make sure that we don't infinite loop in the
 472     // newtype struct autoderef weirdness
 473     #[test]
 474     fn test_buffered_stream() {
 475         struct S;
 476
 477         impl io::Writer for S {
 478             fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
 479         }
 480
 481         impl io::Reader for S {
 482             fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
 483                 Err(io::standard_error(io::EndOfFile))
 484             }
 485         }
 486
 487         let mut stream = BufferedStream::new(S);
 488         let mut buf = [];
 489         assert!(stream.read(buf).is_err());
 490         stream.write(buf).unwrap();
 491         stream.flush().unwrap();
 492     }
 493
 494     #[test]
 495     fn test_read_until() {
 496         let inner = MemReader::new(~[0, 1, 2, 1, 0]);
 497         let mut reader = BufferedReader::with_capacity(2, inner);
 498         assert_eq!(reader.read_until(0), Ok(~[0]));
 499         assert_eq!(reader.read_until(2), Ok(~[1, 2]));
 500         assert_eq!(reader.read_until(1), Ok(~[1]));
 501         assert_eq!(reader.read_until(8), Ok(~[0]));
 502         assert!(reader.read_until(9).is_err());
 503     }
 504
 505     #[test]
 506     fn test_line_buffer() {
 507         let mut writer = LineBufferedWriter::new(MemWriter::new());
 508         writer.write([0]).unwrap();
 509         assert_eq!(writer.get_ref().get_ref(), &[]);
 510         writer.write([1]).unwrap();
 511         assert_eq!(writer.get_ref().get_ref(), &[]);
 512         writer.flush().unwrap();
 513         assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 514         writer.write([0, '\n' as u8, 1, '\n' as u8, 2]).unwrap();
 515         assert_eq!(writer.get_ref().get_ref(),
 516                    &[0, 1, 0, '\n' as u8, 1, '\n' as u8]);
 517         writer.flush().unwrap();
 518         assert_eq!(writer.get_ref().get_ref(),
 519                    &[0, 1, 0, '\n' as u8, 1, '\n' as u8, 2]);
 520         writer.write([3, '\n' as u8]).unwrap();
 521         assert_eq!(writer.get_ref().get_ref(),
 522             &[0, 1, 0, '\n' as u8, 1, '\n' as u8, 2, 3, '\n' as u8]);
 523     }
 524
 525     #[test]
 526     fn test_read_line() {
 527         let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
 528         let mut reader = BufferedReader::with_capacity(2, in_buf);
 529         assert_eq!(reader.read_line(), Ok(~"a\n"));
 530         assert_eq!(reader.read_line(), Ok(~"b\n"));
 531         assert_eq!(reader.read_line(), Ok(~"c"));
 532         assert!(reader.read_line().is_err());
 533     }
 534
 535     #[test]
 536     fn test_lines() {
 537         let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
 538         let mut reader = BufferedReader::with_capacity(2, in_buf);
 539         let mut it = reader.lines();
 540         assert_eq!(it.next(), Some(Ok(~"a\n")));
 541         assert_eq!(it.next(), Some(Ok(~"b\n")));
 542         assert_eq!(it.next(), Some(Ok(~"c")));
 543         assert_eq!(it.next(), None);
 544     }
 545
 546     #[test]
 547     fn test_short_reads() {
 548         let inner = ShortReader{lengths: ~[0, 1, 2, 0, 1, 0]};
 549         let mut reader = BufferedReader::new(inner);
 550         let mut buf = [0, 0];
 551         assert_eq!(reader.read(buf), Ok(0));
 552         assert_eq!(reader.read(buf), Ok(1));
 553         assert_eq!(reader.read(buf), Ok(2));
 554         assert_eq!(reader.read(buf), Ok(0));
 555         assert_eq!(reader.read(buf), Ok(1));
 556         assert_eq!(reader.read(buf), Ok(0));
 557         assert!(reader.read(buf).is_err());
 558     }
 559
 560     #[test]
 561     fn read_char_buffered() {
 562         let buf = [195u8, 159u8];
 563         let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
 564         assert_eq!(reader.read_char(), Ok('ß'));
 565     }
 566
 567     #[test]
 568     fn test_chars() {
 569         let buf = [195u8, 159u8, 'a' as u8];
 570         let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
 571         let mut it = reader.chars();
 572         assert_eq!(it.next(), Some(Ok('ß')));
 573         assert_eq!(it.next(), Some(Ok('a')));
 574         assert_eq!(it.next(), None);
 575     }
 576
 577     #[bench]
 578     fn bench_buffered_reader(bh: &mut Harness) {
 579         bh.iter(|| {
 580             BufferedReader::new(NullStream)
 581         });
 582     }
 583
 584     #[bench]
 585     fn bench_buffered_writer(bh: &mut Harness) {
 586         bh.iter(|| {
 587             BufferedWriter::new(NullStream)
 588         });
 589     }
 590
 591     #[bench]
 592     fn bench_buffered_stream(bh: &mut Harness) {
 593         bh.iter(|| {
 594             BufferedStream::new(NullStream);
 595         });
 596     }
 597 }