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 //! Utility implementations of Reader and Writer
16 use slice::bytes::MutableByteVector;
18 /// Wraps a `Reader`, limiting the number of bytes that can be read from it.
19 pub struct LimitReader<R> {
24 impl<R: Reader> LimitReader<R> {
25 /// Creates a new `LimitReader`
26 pub fn new(r: R, limit: uint) -> LimitReader<R> {
27 LimitReader { limit: limit, inner: r }
30 /// Consumes the `LimitReader`, returning the underlying `Reader`.
31 pub fn into_inner(self) -> R { self.inner }
33 /// Deprecated, use into_inner() instead
34 #[deprecated = "renamed to into_inner"]
35 pub fn unwrap(self) -> R { self.into_inner() }
37 /// Returns the number of bytes that can be read before the `LimitReader`
42 /// The reader may reach EOF after reading fewer bytes than indicated by
43 /// this method if the underlying reader reaches EOF.
44 pub fn limit(&self) -> uint { self.limit }
47 impl<R: Reader> Reader for LimitReader<R> {
48 fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
50 return Err(io::standard_error(io::EndOfFile));
53 let len = cmp::min(self.limit, buf.len());
54 let res = self.inner.read(buf.slice_to_mut(len));
56 Ok(len) => self.limit -= len,
63 impl<R: Buffer> Buffer for LimitReader<R> {
64 fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
65 let amt = try!(self.inner.fill_buf());
66 let buf = amt[..cmp::min(amt.len(), self.limit)];
68 Err(io::standard_error(io::EndOfFile))
74 fn consume(&mut self, amt: uint) {
75 // Don't let callers reset the limit by passing an overlarge value
76 let amt = cmp::min(amt, self.limit);
78 self.inner.consume(amt);
83 /// A `Writer` which ignores bytes written to it, like /dev/null.
85 pub struct NullWriter;
87 impl Writer for NullWriter {
89 fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> { Ok(()) }
92 /// A `Reader` which returns an infinite stream of 0 bytes, like /dev/zero.
94 pub struct ZeroReader;
96 impl Reader for ZeroReader {
98 fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
104 impl Buffer for ZeroReader {
105 fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
106 static DATA: [u8, ..64] = [0, ..64];
110 fn consume(&mut self, _amt: uint) {}
113 /// A `Reader` which is always at EOF, like /dev/null.
115 pub struct NullReader;
117 impl Reader for NullReader {
119 fn read(&mut self, _buf: &mut [u8]) -> io::IoResult<uint> {
120 Err(io::standard_error(io::EndOfFile))
124 impl Buffer for NullReader {
125 fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
126 Err(io::standard_error(io::EndOfFile))
128 fn consume(&mut self, _amt: uint) {}
131 /// A `Writer` which multiplexes writes to a set of `Writer`s.
133 /// The `Writer`s are delegated to in order. If any `Writer` returns an error,
134 /// that error is returned immediately and remaining `Writer`s are not called.
135 pub struct MultiWriter {
136 writers: Vec<Box<Writer+'static>>
140 /// Creates a new `MultiWriter`
141 pub fn new(writers: Vec<Box<Writer+'static>>) -> MultiWriter {
142 MultiWriter { writers: writers }
146 impl Writer for MultiWriter {
148 fn write(&mut self, buf: &[u8]) -> io::IoResult<()> {
149 for writer in self.writers.iter_mut() {
150 try!(writer.write(buf));
156 fn flush(&mut self) -> io::IoResult<()> {
157 for writer in self.writers.iter_mut() {
158 try!(writer.flush());
164 /// A `Reader` which chains input from multiple `Reader`s, reading each to
165 /// completion before moving onto the next.
166 pub struct ChainedReader<I, R> {
168 cur_reader: Option<R>,
171 impl<R: Reader, I: Iterator<R>> ChainedReader<I, R> {
172 /// Creates a new `ChainedReader`
173 pub fn new(mut readers: I) -> ChainedReader<I, R> {
174 let r = readers.next();
175 ChainedReader { readers: readers, cur_reader: r }
179 impl<R: Reader, I: Iterator<R>> Reader for ChainedReader<I, R> {
180 fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
182 let err = match self.cur_reader {
185 Ok(len) => return Ok(len),
186 Err(ref e) if e.kind == io::EndOfFile => None,
192 self.cur_reader = self.readers.next();
194 Some(e) => return Err(e),
198 Err(io::standard_error(io::EndOfFile))
202 /// A `Reader` which forwards input from another `Reader`, passing it along to
203 /// a `Writer` as well. Similar to the `tee(1)` command.
204 pub struct TeeReader<R, W> {
209 impl<R: Reader, W: Writer> TeeReader<R, W> {
210 /// Creates a new `TeeReader`
211 pub fn new(r: R, w: W) -> TeeReader<R, W> {
212 TeeReader { reader: r, writer: w }
215 /// Consumes the `TeeReader`, returning the underlying `Reader` and
217 pub fn into_inner(self) -> (R, W) {
218 let TeeReader { reader, writer } = self;
222 /// Deprecated, use into_inner() instead
223 #[deprecated = "renamed to into_inner"]
224 pub fn unwrap(self) -> (R, W) { self.into_inner() }
227 impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
228 fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
229 self.reader.read(buf).and_then(|len| {
230 self.writer.write(buf[mut ..len]).map(|()| len)
235 /// Copies all data from a `Reader` to a `Writer`.
236 pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
237 let mut buf = [0, ..super::DEFAULT_BUF_SIZE];
239 let len = match r.read(&mut buf) {
241 Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
242 Err(e) => return Err(e),
244 try!(w.write(buf[..len]));
248 /// An adaptor converting an `Iterator<u8>` to a `Reader`.
249 pub struct IterReader<T> {
253 impl<T: Iterator<u8>> IterReader<T> {
254 /// Creates a new `IterReader` which will read from the specified
256 pub fn new(iter: T) -> IterReader<T> {
257 IterReader { iter: iter }
261 impl<T: Iterator<u8>> Reader for IterReader<T> {
263 fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
265 for (slot, elt) in buf.iter_mut().zip(self.iter.by_ref()) {
269 if len == 0 && buf.len() != 0 {
270 Err(io::standard_error(io::EndOfFile))
279 use io::{MemReader, ByRefReader};
283 use prelude::{Ok, range, Vec, Buffer, Writer, Reader, ToString, AsSlice};
286 fn test_limit_reader_unlimited() {
287 let mut r = MemReader::new(vec!(0, 1, 2));
289 let mut r = LimitReader::new(r.by_ref(), 4);
290 assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
295 fn test_limit_reader_limited() {
296 let mut r = MemReader::new(vec!(0, 1, 2));
298 let mut r = LimitReader::new(r.by_ref(), 2);
299 assert_eq!(vec!(0, 1), r.read_to_end().unwrap());
301 assert_eq!(vec!(2), r.read_to_end().unwrap());
305 fn test_limit_reader_limit() {
306 let r = MemReader::new(vec!(0, 1, 2));
307 let mut r = LimitReader::new(r, 3);
308 assert_eq!(3, r.limit());
309 assert_eq!(0, r.read_byte().unwrap());
310 assert_eq!(2, r.limit());
311 assert_eq!(vec!(1, 2), r.read_to_end().unwrap());
312 assert_eq!(0, r.limit());
316 fn test_limit_reader_overlong_consume() {
317 let mut r = MemReader::new(vec![0, 1, 2, 3, 4, 5]);
318 let mut r = LimitReader::new(r.by_ref(), 1);
320 assert_eq!(vec![], r.read_to_end().unwrap());
324 fn test_null_writer() {
325 let mut s = NullWriter;
326 let buf = vec![0, 0, 0];
327 s.write(buf.as_slice()).unwrap();
332 fn test_zero_reader() {
333 let mut s = ZeroReader;
334 let mut buf = vec![1, 2, 3];
335 assert_eq!(s.read(buf.as_mut_slice()), Ok(3));
336 assert_eq!(vec![0, 0, 0], buf);
340 fn test_null_reader() {
341 let mut r = NullReader;
342 let mut buf = vec![0];
343 assert!(r.read(buf.as_mut_slice()).is_err());
347 fn test_multi_writer() {
348 static mut writes: uint = 0;
349 static mut flushes: uint = 0;
352 impl Writer for TestWriter {
353 fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> {
354 unsafe { writes += 1 }
358 fn flush(&mut self) -> io::IoResult<()> {
359 unsafe { flushes += 1 }
364 let mut multi = MultiWriter::new(vec!(box TestWriter as Box<Writer>,
365 box TestWriter as Box<Writer>));
366 multi.write(&[1, 2, 3]).unwrap();
367 assert_eq!(2, unsafe { writes });
368 assert_eq!(0, unsafe { flushes });
369 multi.flush().unwrap();
370 assert_eq!(2, unsafe { writes });
371 assert_eq!(2, unsafe { flushes });
375 fn test_chained_reader() {
376 let rs = vec!(MemReader::new(vec!(0, 1)), MemReader::new(vec!()),
377 MemReader::new(vec!(2, 3)));
378 let mut r = ChainedReader::new(rs.into_iter());
379 assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap());
383 fn test_tee_reader() {
384 let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)),
386 assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
387 let (_, w) = r.unwrap();
388 assert_eq!(vec!(0, 1, 2), w);
393 let mut r = MemReader::new(vec!(0, 1, 2, 3, 4));
394 let mut w = Vec::new();
395 copy(&mut r, &mut w).unwrap();
396 assert_eq!(vec!(0, 1, 2, 3, 4), w);
400 fn limit_reader_buffer() {
401 let r = &mut b"0123456789\n0123456789\n";
403 let mut r = LimitReader::new(r.by_ref(), 3);
404 assert_eq!(r.read_line(), Ok("012".to_string()));
405 assert_eq!(r.limit(), 0);
406 assert_eq!(r.read_line().err().unwrap().kind, io::EndOfFile);
409 let mut r = LimitReader::new(r.by_ref(), 9);
410 assert_eq!(r.read_line(), Ok("3456789\n".to_string()));
411 assert_eq!(r.limit(), 1);
412 assert_eq!(r.read_line(), Ok("0".to_string()));
415 let mut r = LimitReader::new(r.by_ref(), 100);
416 assert_eq!(r.read_char(), Ok('1'));
417 assert_eq!(r.limit(), 99);
418 assert_eq!(r.read_line(), Ok("23456789\n".to_string()));
423 fn test_iter_reader() {
424 let mut r = IterReader::new(range(0u8, 8));
425 let mut buf = [0, 0, 0];
426 let len = r.read(&mut buf).unwrap();
428 assert!(buf == [0, 1, 2]);
430 let len = r.read(&mut buf).unwrap();
432 assert!(buf == [3, 4, 5]);
434 let len = r.read(&mut buf).unwrap();
436 assert!(buf == [6, 7, 5]);
438 assert_eq!(r.read(&mut buf).unwrap_err().kind, io::EndOfFile);
442 fn iter_reader_zero_length() {
443 let mut r = IterReader::new(range(0u8, 8));
445 assert_eq!(Ok(0), r.read(&mut buf));