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.
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.
11 // ignore-lexer-test FIXME #15883
13 //! Buffering wrappers for I/O traits
17 use old_io
::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult}
;
18 use iter
::{IteratorExt, ExactSizeIterator, repeat}
;
21 use option
::Option
::{Some, None}
;
22 use result
::Result
::Ok
;
23 use slice
::{SliceExt}
;
27 /// Wraps a Reader and buffers input from it
29 /// It can be excessively inefficient to work directly with a `Reader`. For
30 /// example, every call to `read` on `TcpStream` results in a system call. A
31 /// `BufferedReader` performs large, infrequent reads on the underlying
32 /// `Reader` and maintains an in-memory buffer of the results.
37 /// use std::old_io::{BufferedReader, File};
39 /// let file = File::open(&Path::new("message.txt"));
40 /// let mut reader = BufferedReader::new(file);
42 /// let mut buf = [0; 100];
43 /// match reader.read(&mut buf) {
44 /// Ok(nread) => println!("Read {} bytes", nread),
45 /// Err(e) => println!("error reading: {}", e)
48 pub struct BufferedReader
<R
> {
55 #[stable(feature = "rust1", since = "1.0.0")]
56 impl<R
> fmt
::Debug
for BufferedReader
<R
> where R
: fmt
::Debug
{
57 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
58 write
!(fmt
, "BufferedReader {{ reader: {:?}, buffer: {}/{} }}",
59 self.inner
, self.cap
- self.pos
, self.buf
.len())
63 impl<R
: Reader
> BufferedReader
<R
> {
64 /// Creates a new `BufferedReader` with the specified buffer capacity
65 pub fn with_capacity(cap
: uint
, inner
: R
) -> BufferedReader
<R
> {
68 // We can't use the same trick here as we do for BufferedWriter,
69 // since this memory is visible to the inner Reader.
70 buf
: repeat(0).take(cap
).collect(),
76 /// Creates a new `BufferedReader` with a default buffer capacity
77 pub fn new(inner
: R
) -> BufferedReader
<R
> {
78 BufferedReader
::with_capacity(DEFAULT_BUF_SIZE
, inner
)
81 /// Gets a reference to the underlying reader.
82 pub fn get_ref
<'a
>(&self) -> &R { &self.inner }
84 /// Gets a mutable reference to the underlying reader.
88 /// It is inadvisable to directly read from the underlying reader.
89 pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
91 /// Unwraps this `BufferedReader`, returning the underlying reader.
93 /// Note that any leftover data in the internal buffer is lost.
94 pub fn into_inner(self) -> R { self.inner }
97 impl<R
: Reader
> Buffer
for BufferedReader
<R
> {
98 fn fill_buf
<'a
>(&'a
mut self) -> IoResult
<&'a
[u8]> {
99 if self.pos
== self.cap
{
100 self.cap
= try
!(self.inner
.read(&mut self.buf
));
103 Ok(&self.buf
[self.pos
..self.cap
])
106 fn consume(&mut self, amt
: uint
) {
108 assert
!(self.pos
<= self.cap
);
112 impl<R
: Reader
> Reader
for BufferedReader
<R
> {
113 fn read(&mut self, buf
: &mut [u8]) -> IoResult
<uint
> {
114 if self.pos
== self.cap
&& buf
.len() >= self.buf
.len() {
115 return self.inner
.read(buf
);
118 let available
= try
!(self.fill_buf());
119 let nread
= cmp
::min(available
.len(), buf
.len());
120 slice
::bytes
::copy_memory(buf
, &available
[..nread
]);
128 /// Wraps a Writer and buffers output to it
130 /// It can be excessively inefficient to work directly with a `Writer`. For
131 /// example, every call to `write` on `TcpStream` results in a system call. A
132 /// `BufferedWriter` keeps an in memory buffer of data and writes it to the
133 /// underlying `Writer` in large, infrequent batches.
135 /// This writer will be flushed when it is dropped.
140 /// use std::old_io::{BufferedWriter, File};
142 /// let file = File::create(&Path::new("message.txt")).unwrap();
143 /// let mut writer = BufferedWriter::new(file);
145 /// writer.write_str("hello, world").unwrap();
146 /// writer.flush().unwrap();
148 pub struct BufferedWriter
<W
> {
154 #[stable(feature = "rust1", since = "1.0.0")]
155 impl<W
> fmt
::Debug
for BufferedWriter
<W
> where W
: fmt
::Debug
{
156 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
157 write
!(fmt
, "BufferedWriter {{ writer: {:?}, buffer: {}/{} }}",
158 self.inner
.as_ref().unwrap(), self.pos
, self.buf
.len())
162 impl<W
: Writer
> BufferedWriter
<W
> {
163 /// Creates a new `BufferedWriter` with the specified buffer capacity
164 pub fn with_capacity(cap
: uint
, inner
: W
) -> BufferedWriter
<W
> {
165 // It's *much* faster to create an uninitialized buffer than it is to
166 // fill everything in with 0. This buffer is entirely an implementation
167 // detail and is never exposed, so we're safe to not initialize
168 // everything up-front. This allows creation of BufferedWriter instances
169 // to be very cheap (large mallocs are not nearly as expensive as large
171 let mut buf
= Vec
::with_capacity(cap
);
172 unsafe { buf.set_len(cap); }
180 /// Creates a new `BufferedWriter` with a default buffer capacity
181 pub fn new(inner
: W
) -> BufferedWriter
<W
> {
182 BufferedWriter
::with_capacity(DEFAULT_BUF_SIZE
, inner
)
185 fn flush_buf(&mut self) -> IoResult
<()> {
187 let ret
= self.inner
.as_mut().unwrap().write_all(&self.buf
[..self.pos
]);
195 /// Gets a reference to the underlying writer.
196 pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
198 /// Gets a mutable reference to the underlying write.
202 /// It is inadvisable to directly read from the underlying writer.
203 pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
205 /// Unwraps this `BufferedWriter`, returning the underlying writer.
207 /// The buffer is flushed before returning the writer.
208 pub fn into_inner(mut self) -> W
{
209 // FIXME(#12628): is panicking the right thing to do if flushing panicks?
210 self.flush_buf().unwrap();
211 self.inner
.take().unwrap()
215 impl<W
: Writer
> Writer
for BufferedWriter
<W
> {
216 fn write_all(&mut self, buf
: &[u8]) -> IoResult
<()> {
217 if self.pos
+ buf
.len() > self.buf
.len() {
218 try
!(self.flush_buf());
221 if buf
.len() > self.buf
.len() {
222 self.inner
.as_mut().unwrap().write_all(buf
)
224 let dst
= &mut self.buf
[self.pos
..];
225 slice
::bytes
::copy_memory(dst
, buf
);
226 self.pos
+= buf
.len();
231 fn flush(&mut self) -> IoResult
<()> {
232 self.flush_buf().and_then(|()| self.inner
.as_mut().unwrap().flush())
237 impl<W
: Writer
> Drop
for BufferedWriter
<W
> {
239 if self.inner
.is_some() {
240 // dtors should not panic, so we ignore a panicked flush
241 let _
= self.flush_buf();
246 /// Wraps a Writer and buffers output to it, flushing whenever a newline (`0x0a`,
247 /// `'\n'`) is detected.
249 /// This writer will be flushed when it is dropped.
250 pub struct LineBufferedWriter
<W
> {
251 inner
: BufferedWriter
<W
>,
254 #[stable(feature = "rust1", since = "1.0.0")]
255 impl<W
> fmt
::Debug
for LineBufferedWriter
<W
> where W
: fmt
::Debug
{
256 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
257 write
!(fmt
, "LineBufferedWriter {{ writer: {:?}, buffer: {}/{} }}",
258 self.inner
.inner
, self.inner
.pos
, self.inner
.buf
.len())
262 impl<W
: Writer
> LineBufferedWriter
<W
> {
263 /// Creates a new `LineBufferedWriter`
264 pub fn new(inner
: W
) -> LineBufferedWriter
<W
> {
265 // Lines typically aren't that long, don't use a giant buffer
267 inner
: BufferedWriter
::with_capacity(1024, inner
)
271 /// Gets a reference to the underlying writer.
273 /// This type does not expose the ability to get a mutable reference to the
274 /// underlying reader because that could possibly corrupt the buffer.
275 pub fn get_ref
<'a
>(&'a
self) -> &'a W { self.inner.get_ref() }
277 /// Unwraps this `LineBufferedWriter`, returning the underlying writer.
279 /// The internal buffer is flushed before returning the writer.
280 pub fn into_inner(self) -> W { self.inner.into_inner() }
283 impl<W
: Writer
> Writer
for LineBufferedWriter
<W
> {
284 fn write_all(&mut self, buf
: &[u8]) -> IoResult
<()> {
285 match buf
.iter().rposition(|&b
| b
== b'
\n'
) {
287 try
!(self.inner
.write_all(&buf
[..i
+ 1]));
288 try
!(self.inner
.flush());
289 try
!(self.inner
.write_all(&buf
[i
+ 1..]));
292 None
=> self.inner
.write_all(buf
),
296 fn flush(&mut self) -> IoResult
<()> { self.inner.flush() }
299 struct InternalBufferedWriter
<W
>(BufferedWriter
<W
>);
301 impl<W
> InternalBufferedWriter
<W
> {
302 fn get_mut
<'a
>(&'a
mut self) -> &'a
mut BufferedWriter
<W
> {
303 let InternalBufferedWriter(ref mut w
) = *self;
308 impl<W
: Reader
> Reader
for InternalBufferedWriter
<W
> {
309 fn read(&mut self, buf
: &mut [u8]) -> IoResult
<uint
> {
310 self.get_mut().inner
.as_mut().unwrap().read(buf
)
314 /// Wraps a Stream and buffers input and output to and from it.
316 /// It can be excessively inefficient to work directly with a `Stream`. For
317 /// example, every call to `read` or `write` on `TcpStream` results in a system
318 /// call. A `BufferedStream` keeps in memory buffers of data, making large,
319 /// infrequent calls to `read` and `write` on the underlying `Stream`.
321 /// The output half will be flushed when this stream is dropped.
326 /// # #![allow(unused_must_use)]
327 /// use std::old_io::{BufferedStream, File};
329 /// let file = File::open(&Path::new("message.txt"));
330 /// let mut stream = BufferedStream::new(file);
332 /// stream.write_all("hello, world".as_bytes());
335 /// let mut buf = [0; 100];
336 /// match stream.read(&mut buf) {
337 /// Ok(nread) => println!("Read {} bytes", nread),
338 /// Err(e) => println!("error reading: {}", e)
341 pub struct BufferedStream
<S
> {
342 inner
: BufferedReader
<InternalBufferedWriter
<S
>>
345 #[stable(feature = "rust1", since = "1.0.0")]
346 impl<S
> fmt
::Debug
for BufferedStream
<S
> where S
: fmt
::Debug
{
347 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
348 let reader
= &self.inner
;
349 let writer
= &self.inner
.inner
.0;
350 write
!(fmt
, "BufferedStream {{ stream: {:?}, write_buffer: {}/{}, read_buffer: {}/{} }}",
352 writer
.pos
, writer
.buf
.len(),
353 reader
.cap
- reader
.pos
, reader
.buf
.len())
357 impl<S
: Stream
> BufferedStream
<S
> {
358 /// Creates a new buffered stream with explicitly listed capacities for the
359 /// reader/writer buffer.
360 pub fn with_capacities(reader_cap
: uint
, writer_cap
: uint
, inner
: S
)
361 -> BufferedStream
<S
> {
362 let writer
= BufferedWriter
::with_capacity(writer_cap
, inner
);
363 let internal_writer
= InternalBufferedWriter(writer
);
364 let reader
= BufferedReader
::with_capacity(reader_cap
,
366 BufferedStream { inner: reader }
369 /// Creates a new buffered stream with the default reader/writer buffer
371 pub fn new(inner
: S
) -> BufferedStream
<S
> {
372 BufferedStream
::with_capacities(DEFAULT_BUF_SIZE
, DEFAULT_BUF_SIZE
,
376 /// Gets a reference to the underlying stream.
377 pub fn get_ref(&self) -> &S
{
378 let InternalBufferedWriter(ref w
) = self.inner
.inner
;
382 /// Gets a mutable reference to the underlying stream.
386 /// It is inadvisable to read directly from or write directly to the
387 /// underlying stream.
388 pub fn get_mut(&mut self) -> &mut S
{
389 let InternalBufferedWriter(ref mut w
) = self.inner
.inner
;
393 /// Unwraps this `BufferedStream`, returning the underlying stream.
395 /// The internal buffer is flushed before returning the stream. Any leftover
396 /// data in the read buffer is lost.
397 pub fn into_inner(self) -> S
{
398 let InternalBufferedWriter(w
) = self.inner
.inner
;
403 impl<S
: Stream
> Buffer
for BufferedStream
<S
> {
404 fn fill_buf
<'a
>(&'a
mut self) -> IoResult
<&'a
[u8]> { self.inner.fill_buf() }
405 fn consume(&mut self, amt
: uint
) { self.inner.consume(amt) }
408 impl<S
: Stream
> Reader
for BufferedStream
<S
> {
409 fn read(&mut self, buf
: &mut [u8]) -> IoResult
<uint
> {
414 impl<S
: Stream
> Writer
for BufferedStream
<S
> {
415 fn write_all(&mut self, buf
: &[u8]) -> IoResult
<()> {
416 self.inner
.inner
.get_mut().write_all(buf
)
418 fn flush(&mut self) -> IoResult
<()> {
419 self.inner
.inner
.get_mut().flush()
429 use super::super::{IoResult, EndOfFile}
;
430 use super::super::mem
::MemReader
;
431 use self::test
::Bencher
;
433 /// A type, free to create, primarily intended for benchmarking creation of
434 /// wrappers that, just for construction, don't need a Reader/Writer that
435 /// does anything useful. Is equivalent to `/dev/null` in semantics.
436 #[derive(Clone,PartialEq,PartialOrd)]
437 pub struct NullStream
;
439 impl Reader
for NullStream
{
440 fn read(&mut self, _
: &mut [u8]) -> old_io
::IoResult
<uint
> {
441 Err(old_io
::standard_error(old_io
::EndOfFile
))
445 impl Writer
for NullStream
{
446 fn write_all(&mut self, _
: &[u8]) -> old_io
::IoResult
<()> { Ok(()) }
449 /// A dummy reader intended at testing short-reads propagation.
450 pub struct ShortReader
{
454 impl Reader
for ShortReader
{
455 fn read(&mut self, _
: &mut [u8]) -> old_io
::IoResult
<uint
> {
456 if self.lengths
.is_empty() {
457 Err(old_io
::standard_error(old_io
::EndOfFile
))
459 Ok(self.lengths
.remove(0))
465 fn test_buffered_reader() {
466 let inner
= MemReader
::new(vec
!(5, 6, 7, 0, 1, 2, 3, 4));
467 let mut reader
= BufferedReader
::with_capacity(2, inner
);
469 let mut buf
= [0, 0, 0];
470 let nread
= reader
.read(&mut buf
);
471 assert_eq
!(Ok(3), nread
);
472 let b
: &[_
] = &[5, 6, 7];
475 let mut buf
= [0, 0];
476 let nread
= reader
.read(&mut buf
);
477 assert_eq
!(Ok(2), nread
);
478 let b
: &[_
] = &[0, 1];
482 let nread
= reader
.read(&mut buf
);
483 assert_eq
!(Ok(1), nread
);
487 let mut buf
= [0, 0, 0];
488 let nread
= reader
.read(&mut buf
);
489 assert_eq
!(Ok(1), nread
);
490 let b
: &[_
] = &[3, 0, 0];
493 let nread
= reader
.read(&mut buf
);
494 assert_eq
!(Ok(1), nread
);
495 let b
: &[_
] = &[4, 0, 0];
498 assert
!(reader
.read(&mut buf
).is_err());
502 fn test_buffered_writer() {
503 let inner
= Vec
::new();
504 let mut writer
= BufferedWriter
::with_capacity(2, inner
);
506 writer
.write_all(&[0, 1]).unwrap();
508 assert_eq
!(&writer
.get_ref()[], b
);
510 writer
.write_all(&[2]).unwrap();
511 let b
: &[_
] = &[0, 1];
512 assert_eq
!(&writer
.get_ref()[], b
);
514 writer
.write_all(&[3]).unwrap();
515 assert_eq
!(&writer
.get_ref()[], b
);
517 writer
.flush().unwrap();
518 let a
: &[_
] = &[0, 1, 2, 3];
519 assert_eq
!(a
, &writer
.get_ref()[]);
521 writer
.write_all(&[4]).unwrap();
522 writer
.write_all(&[5]).unwrap();
523 assert_eq
!(a
, &writer
.get_ref()[]);
525 writer
.write_all(&[6]).unwrap();
526 let a
: &[_
] = &[0, 1, 2, 3, 4, 5];
527 assert_eq
!(a
, &writer
.get_ref()[]);
529 writer
.write_all(&[7, 8]).unwrap();
530 let a
: &[_
] = &[0, 1, 2, 3, 4, 5, 6];
531 assert_eq
!(a
, &writer
.get_ref()[]);
533 writer
.write_all(&[9, 10, 11]).unwrap();
534 let a
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
535 assert_eq
!(a
, &writer
.get_ref()[]);
537 writer
.flush().unwrap();
538 assert_eq
!(a
, &writer
.get_ref()[]);
542 fn test_buffered_writer_inner_flushes() {
543 let mut w
= BufferedWriter
::with_capacity(3, Vec
::new());
544 w
.write_all(&[0, 1]).unwrap();
546 assert_eq
!(a
, &w
.get_ref()[]);
547 let w
= w
.into_inner();
548 let a
: &[_
] = &[0, 1];
549 assert_eq
!(a
, &w
[..]);
552 // This is just here to make sure that we don't infinite loop in the
553 // newtype struct autoderef weirdness
555 fn test_buffered_stream() {
558 impl old_io
::Writer
for S
{
559 fn write_all(&mut self, _
: &[u8]) -> old_io
::IoResult
<()> { Ok(()) }
562 impl old_io
::Reader
for S
{
563 fn read(&mut self, _
: &mut [u8]) -> old_io
::IoResult
<uint
> {
564 Err(old_io
::standard_error(old_io
::EndOfFile
))
568 let mut stream
= BufferedStream
::new(S
);
570 assert
!(stream
.read(&mut buf
).is_err());
571 stream
.write_all(&buf
).unwrap();
572 stream
.flush().unwrap();
576 fn test_read_until() {
577 let inner
= MemReader
::new(vec
!(0, 1, 2, 1, 0));
578 let mut reader
= BufferedReader
::with_capacity(2, inner
);
579 assert_eq
!(reader
.read_until(0), Ok(vec
!(0)));
580 assert_eq
!(reader
.read_until(2), Ok(vec
!(1, 2)));
581 assert_eq
!(reader
.read_until(1), Ok(vec
!(1)));
582 assert_eq
!(reader
.read_until(8), Ok(vec
!(0)));
583 assert
!(reader
.read_until(9).is_err());
587 fn test_line_buffer() {
588 let mut writer
= LineBufferedWriter
::new(Vec
::new());
589 writer
.write_all(&[0]).unwrap();
591 assert_eq
!(&writer
.get_ref()[], b
);
592 writer
.write_all(&[1]).unwrap();
593 assert_eq
!(&writer
.get_ref()[], b
);
594 writer
.flush().unwrap();
595 let b
: &[_
] = &[0, 1];
596 assert_eq
!(&writer
.get_ref()[], b
);
597 writer
.write_all(&[0, b'
\n'
, 1, b'
\n'
, 2]).unwrap();
598 let b
: &[_
] = &[0, 1, 0, b'
\n'
, 1, b'
\n'
];
599 assert_eq
!(&writer
.get_ref()[], b
);
600 writer
.flush().unwrap();
601 let b
: &[_
] = &[0, 1, 0, b'
\n'
, 1, b'
\n'
, 2];
602 assert_eq
!(&writer
.get_ref()[], b
);
603 writer
.write_all(&[3, b'
\n'
]).unwrap();
604 let b
: &[_
] = &[0, 1, 0, b'
\n'
, 1, b'
\n'
, 2, 3, b'
\n'
];
605 assert_eq
!(&writer
.get_ref()[], b
);
609 fn test_read_line() {
610 let in_buf
= MemReader
::new(b
"a\nb\nc".to_vec());
611 let mut reader
= BufferedReader
::with_capacity(2, in_buf
);
612 assert_eq
!(reader
.read_line(), Ok("a\n".to_string()));
613 assert_eq
!(reader
.read_line(), Ok("b\n".to_string()));
614 assert_eq
!(reader
.read_line(), Ok("c".to_string()));
615 assert
!(reader
.read_line().is_err());
620 let in_buf
= MemReader
::new(b
"a\nb\nc".to_vec());
621 let mut reader
= BufferedReader
::with_capacity(2, in_buf
);
622 let mut it
= reader
.lines();
623 assert_eq
!(it
.next(), Some(Ok("a\n".to_string())));
624 assert_eq
!(it
.next(), Some(Ok("b\n".to_string())));
625 assert_eq
!(it
.next(), Some(Ok("c".to_string())));
626 assert_eq
!(it
.next(), None
);
630 fn test_short_reads() {
631 let inner
= ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]}
;
632 let mut reader
= BufferedReader
::new(inner
);
633 let mut buf
= [0, 0];
634 assert_eq
!(reader
.read(&mut buf
), Ok(0));
635 assert_eq
!(reader
.read(&mut buf
), Ok(1));
636 assert_eq
!(reader
.read(&mut buf
), Ok(2));
637 assert_eq
!(reader
.read(&mut buf
), Ok(0));
638 assert_eq
!(reader
.read(&mut buf
), Ok(1));
639 assert_eq
!(reader
.read(&mut buf
), Ok(0));
640 assert
!(reader
.read(&mut buf
).is_err());
644 fn read_char_buffered() {
645 let buf
= [195u8, 159u8];
646 let mut reader
= BufferedReader
::with_capacity(1, &buf
[..]);
647 assert_eq
!(reader
.read_char(), Ok('ß'
));
652 let buf
= [195u8, 159u8, b'a'
];
653 let mut reader
= BufferedReader
::with_capacity(1, &buf
[..]);
654 let mut it
= reader
.chars();
655 assert_eq
!(it
.next(), Some(Ok('ß'
)));
656 assert_eq
!(it
.next(), Some(Ok('a'
)));
657 assert_eq
!(it
.next(), None
);
662 fn dont_panic_in_drop_on_panicked_flush() {
663 struct FailFlushWriter
;
665 impl Writer
for FailFlushWriter
{
666 fn write_all(&mut self, _buf
: &[u8]) -> IoResult
<()> { Ok(()) }
667 fn flush(&mut self) -> IoResult
<()> { Err(old_io::standard_error(EndOfFile)) }
670 let writer
= FailFlushWriter
;
671 let _writer
= BufferedWriter
::new(writer
);
673 // If writer panics *again* due to the flush error then the process will abort.
678 fn bench_buffered_reader(b
: &mut Bencher
) {
680 BufferedReader
::new(NullStream
)
685 fn bench_buffered_writer(b
: &mut Bencher
) {
687 BufferedWriter
::new(NullStream
)
692 fn bench_buffered_stream(b
: &mut Bencher
) {
694 BufferedStream
::new(NullStream
);