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 #15679
13 //! Readers and Writers for in-memory buffers
18 use option::Option::None;
19 use result::Result::{Err, Ok};
21 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
22 use slice::{mod, AsSlice, SliceExt};
25 const BUF_CAPACITY: uint = 128;
27 fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
28 // compute offset as signed and clamp to prevent overflow
29 let pos = match seek {
37 kind: io::InvalidInput,
38 desc: "invalid seek to a negative offset",
42 Ok((offset + pos) as u64)
46 impl Writer for Vec<u8> {
48 fn write(&mut self, buf: &[u8]) -> IoResult<()> {
54 /// Writes to an owned, growable byte vector
59 /// # #![allow(unused_must_use)]
60 /// use std::io::MemWriter;
62 /// let mut w = MemWriter::new();
63 /// w.write(&[0, 1, 2]);
65 /// assert_eq!(w.into_inner(), vec!(0, 1, 2));
67 #[deprecated = "use the Vec<u8> Writer implementation directly"]
69 pub struct MemWriter {
74 /// Create a new `MemWriter`.
76 pub fn new() -> MemWriter {
77 MemWriter::with_capacity(BUF_CAPACITY)
79 /// Create a new `MemWriter`, allocating at least `n` bytes for
80 /// the internal buffer.
82 pub fn with_capacity(n: uint) -> MemWriter {
83 MemWriter::from_vec(Vec::with_capacity(n))
85 /// Create a new `MemWriter` that will append to an existing `Vec`.
87 pub fn from_vec(buf: Vec<u8>) -> MemWriter {
88 MemWriter { buf: buf }
91 /// Acquires an immutable reference to the underlying buffer of this
94 pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
96 /// Unwraps this `MemWriter`, returning the underlying buffer
98 pub fn into_inner(self) -> Vec<u8> { self.buf }
100 /// Deprecated, use into_inner() instead
101 #[deprecated = "renamed to into_inner()"]
102 pub fn unwrap(self) -> Vec<u8> { self.into_inner() }
105 impl Writer for MemWriter {
107 fn write(&mut self, buf: &[u8]) -> IoResult<()> {
108 self.buf.push_all(buf);
113 /// Reads from an owned byte vector
118 /// # #![allow(unused_must_use)]
119 /// use std::io::MemReader;
121 /// let mut r = MemReader::new(vec!(0, 1, 2));
123 /// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2));
125 pub struct MemReader {
131 /// Creates a new `MemReader` which will read the buffer given. The buffer
132 /// can be re-acquired through `unwrap`
134 pub fn new(buf: Vec<u8>) -> MemReader {
141 /// Tests whether this reader has read all bytes in its buffer.
143 /// If `true`, then this will no longer return bytes from `read`.
145 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
147 /// Acquires an immutable reference to the underlying buffer of this
150 /// No method is exposed for acquiring a mutable reference to the buffer
151 /// because it could corrupt the state of this `MemReader`.
153 pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
155 /// Unwraps this `MemReader`, returning the underlying buffer
157 pub fn into_inner(self) -> Vec<u8> { self.buf }
159 /// Deprecated, use into_inner() instead
160 #[deprecated = "renamed to into_inner()"]
161 pub fn unwrap(self) -> Vec<u8> { self.into_inner() }
164 impl Reader for MemReader {
166 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
167 if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
169 let write_len = min(buf.len(), self.buf.len() - self.pos);
171 let input = self.buf[self.pos.. self.pos + write_len];
172 let output = buf.slice_to_mut(write_len);
173 assert_eq!(input.len(), output.len());
174 slice::bytes::copy_memory(output, input);
176 self.pos += write_len;
177 assert!(self.pos <= self.buf.len());
179 return Ok(write_len);
183 impl Seek for MemReader {
185 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
188 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
189 let new = try!(combine(style, self.pos, self.buf.len(), pos));
190 self.pos = new as uint;
195 impl Buffer for MemReader {
197 fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
198 if self.pos < self.buf.len() {
199 Ok(self.buf[self.pos..])
201 Err(io::standard_error(io::EndOfFile))
206 fn consume(&mut self, amt: uint) { self.pos += amt; }
209 impl<'a> Reader for &'a [u8] {
211 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
212 if self.is_empty() { return Err(io::standard_error(io::EndOfFile)); }
214 let write_len = min(buf.len(), self.len());
216 let input = self[..write_len];
217 let output = buf.slice_to_mut(write_len);
218 slice::bytes::copy_memory(output, input);
221 *self = self.slice_from(write_len);
227 impl<'a> Buffer for &'a [u8] {
229 fn fill_buf(&mut self) -> IoResult<&[u8]> {
231 Err(io::standard_error(io::EndOfFile))
238 fn consume(&mut self, amt: uint) {
244 /// Writes to a fixed-size byte slice
246 /// If a write will not fit in the buffer, it returns an error and does not
252 /// # #![allow(unused_must_use)]
253 /// use std::io::BufWriter;
255 /// let mut buf = [0; 4];
257 /// let mut w = BufWriter::new(&mut buf);
258 /// w.write(&[0, 1, 2]);
260 /// assert!(buf == [0, 1, 2, 0]);
262 pub struct BufWriter<'a> {
267 impl<'a> BufWriter<'a> {
268 /// Creates a new `BufWriter` which will wrap the specified buffer. The
269 /// writer initially starts at position 0.
271 pub fn new(buf: &'a mut [u8]) -> BufWriter<'a> {
279 impl<'a> Writer for BufWriter<'a> {
281 fn write(&mut self, src: &[u8]) -> IoResult<()> {
282 let dst = self.buf.slice_from_mut(self.pos);
283 let dst_len = dst.len();
286 return Err(io::standard_error(io::EndOfFile));
289 let src_len = src.len();
291 if dst_len >= src_len {
292 slice::bytes::copy_memory(dst, src);
298 slice::bytes::copy_memory(dst, src[..dst_len]);
302 Err(io::standard_error(io::ShortWrite(dst_len)))
307 impl<'a> Seek for BufWriter<'a> {
309 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
312 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
313 let new = try!(combine(style, self.pos, self.buf.len(), pos));
314 self.pos = min(new as uint, self.buf.len());
319 /// Reads from a fixed-size byte slice
324 /// # #![allow(unused_must_use)]
325 /// use std::io::BufReader;
327 /// let buf = [0, 1, 2, 3];
328 /// let mut r = BufReader::new(&buf);
330 /// assert_eq!(r.read_to_end().unwrap(), vec![0, 1, 2, 3]);
332 pub struct BufReader<'a> {
337 impl<'a> BufReader<'a> {
338 /// Creates a new buffered reader which will read the specified buffer
340 pub fn new(buf: &'a [u8]) -> BufReader<'a> {
347 /// Tests whether this reader has read all bytes in its buffer.
349 /// If `true`, then this will no longer return bytes from `read`.
351 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
354 impl<'a> Reader for BufReader<'a> {
356 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
357 if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
359 let write_len = min(buf.len(), self.buf.len() - self.pos);
361 let input = self.buf[self.pos.. self.pos + write_len];
362 let output = buf.slice_to_mut(write_len);
363 assert_eq!(input.len(), output.len());
364 slice::bytes::copy_memory(output, input);
366 self.pos += write_len;
367 assert!(self.pos <= self.buf.len());
369 return Ok(write_len);
373 impl<'a> Seek for BufReader<'a> {
375 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
378 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
379 let new = try!(combine(style, self.pos, self.buf.len(), pos));
380 self.pos = new as uint;
385 impl<'a> Buffer for BufReader<'a> {
387 fn fill_buf(&mut self) -> IoResult<&[u8]> {
388 if self.pos < self.buf.len() {
389 Ok(self.buf[self.pos..])
391 Err(io::standard_error(io::EndOfFile))
396 fn consume(&mut self, amt: uint) { self.pos += amt; }
401 extern crate "test" as test_crate;
403 use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
404 use prelude::{Ok, Err, range, Vec, Buffer, AsSlice, SliceExt, IteratorExt};
406 use self::test_crate::Bencher;
409 fn test_vec_writer() {
410 let mut writer = Vec::new();
411 writer.write(&[0]).unwrap();
412 writer.write(&[1, 2, 3]).unwrap();
413 writer.write(&[4, 5, 6, 7]).unwrap();
414 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
415 assert_eq!(writer.as_slice(), b);
419 fn test_mem_writer() {
420 let mut writer = MemWriter::new();
421 writer.write(&[0]).unwrap();
422 writer.write(&[1, 2, 3]).unwrap();
423 writer.write(&[4, 5, 6, 7]).unwrap();
424 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
425 assert_eq!(writer.get_ref(), b);
429 fn test_buf_writer() {
430 let mut buf = [0 as u8; 9];
432 let mut writer = BufWriter::new(&mut buf);
433 assert_eq!(writer.tell(), Ok(0));
434 writer.write(&[0]).unwrap();
435 assert_eq!(writer.tell(), Ok(1));
436 writer.write(&[1, 2, 3]).unwrap();
437 writer.write(&[4, 5, 6, 7]).unwrap();
438 assert_eq!(writer.tell(), Ok(8));
439 writer.write(&[]).unwrap();
440 assert_eq!(writer.tell(), Ok(8));
442 assert_eq!(writer.write(&[8, 9]).unwrap_err().kind, io::ShortWrite(1));
443 assert_eq!(writer.write(&[10]).unwrap_err().kind, io::EndOfFile);
445 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
450 fn test_buf_writer_seek() {
451 let mut buf = [0 as u8; 8];
453 let mut writer = BufWriter::new(&mut buf);
454 assert_eq!(writer.tell(), Ok(0));
455 writer.write(&[1]).unwrap();
456 assert_eq!(writer.tell(), Ok(1));
458 writer.seek(2, SeekSet).unwrap();
459 assert_eq!(writer.tell(), Ok(2));
460 writer.write(&[2]).unwrap();
461 assert_eq!(writer.tell(), Ok(3));
463 writer.seek(-2, SeekCur).unwrap();
464 assert_eq!(writer.tell(), Ok(1));
465 writer.write(&[3]).unwrap();
466 assert_eq!(writer.tell(), Ok(2));
468 writer.seek(-1, SeekEnd).unwrap();
469 assert_eq!(writer.tell(), Ok(7));
470 writer.write(&[4]).unwrap();
471 assert_eq!(writer.tell(), Ok(8));
474 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
479 fn test_buf_writer_error() {
480 let mut buf = [0 as u8; 2];
481 let mut writer = BufWriter::new(&mut buf);
482 writer.write(&[0]).unwrap();
484 match writer.write(&[0, 0]) {
486 Err(e) => assert_eq!(e.kind, io::ShortWrite(1)),
491 fn test_mem_reader() {
492 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
494 assert_eq!(reader.read(&mut buf), Ok(0));
495 assert_eq!(reader.tell(), Ok(0));
497 assert_eq!(reader.read(&mut buf), Ok(1));
498 assert_eq!(reader.tell(), Ok(1));
501 let mut buf = [0; 4];
502 assert_eq!(reader.read(&mut buf), Ok(4));
503 assert_eq!(reader.tell(), Ok(5));
504 let b: &[_] = &[1, 2, 3, 4];
506 assert_eq!(reader.read(&mut buf), Ok(3));
507 let b: &[_] = &[5, 6, 7];
508 assert_eq!(buf[0..3], b);
509 assert!(reader.read(&mut buf).is_err());
510 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
511 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
512 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
513 assert!(reader.read(&mut buf).is_err());
517 fn test_slice_reader() {
518 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
519 let mut reader = &mut in_buf.as_slice();
521 assert_eq!(reader.read(&mut buf), Ok(0));
523 assert_eq!(reader.read(&mut buf), Ok(1));
524 assert_eq!(reader.len(), 7);
526 assert_eq!(buf.as_slice(), b);
527 let mut buf = [0; 4];
528 assert_eq!(reader.read(&mut buf), Ok(4));
529 assert_eq!(reader.len(), 3);
530 let b: &[_] = &[1, 2, 3, 4];
531 assert_eq!(buf.as_slice(), b);
532 assert_eq!(reader.read(&mut buf), Ok(3));
533 let b: &[_] = &[5, 6, 7];
534 assert_eq!(buf[0..3], b);
535 assert!(reader.read(&mut buf).is_err());
536 let mut reader = &mut in_buf.as_slice();
537 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
538 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
539 assert!(reader.read(&mut buf).is_err());
543 fn test_buf_reader() {
544 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
545 let mut reader = BufReader::new(in_buf.as_slice());
547 assert_eq!(reader.read(&mut buf), Ok(0));
548 assert_eq!(reader.tell(), Ok(0));
550 assert_eq!(reader.read(&mut buf), Ok(1));
551 assert_eq!(reader.tell(), Ok(1));
554 let mut buf = [0; 4];
555 assert_eq!(reader.read(&mut buf), Ok(4));
556 assert_eq!(reader.tell(), Ok(5));
557 let b: &[_] = &[1, 2, 3, 4];
559 assert_eq!(reader.read(&mut buf), Ok(3));
560 let b: &[_] = &[5, 6, 7];
561 assert_eq!(buf[0..3], b);
562 assert!(reader.read(&mut buf).is_err());
563 let mut reader = BufReader::new(in_buf.as_slice());
564 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
565 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
566 assert!(reader.read(&mut buf).is_err());
570 fn test_read_char() {
571 let b = b"Vi\xE1\xBB\x87t";
572 let mut r = BufReader::new(b);
573 assert_eq!(r.read_char(), Ok('V'));
574 assert_eq!(r.read_char(), Ok('i'));
575 assert_eq!(r.read_char(), Ok('ệ'));
576 assert_eq!(r.read_char(), Ok('t'));
577 assert!(r.read_char().is_err());
581 fn test_read_bad_char() {
583 let mut r = BufReader::new(b);
584 assert!(r.read_char().is_err());
588 fn test_write_strings() {
589 let mut writer = MemWriter::new();
590 writer.write_str("testing").unwrap();
591 writer.write_line("testing").unwrap();
592 writer.write_str("testing").unwrap();
593 let mut r = BufReader::new(writer.get_ref());
594 assert_eq!(r.read_to_string().unwrap(), "testingtesting\ntesting");
598 fn test_write_char() {
599 let mut writer = MemWriter::new();
600 writer.write_char('a').unwrap();
601 writer.write_char('\n').unwrap();
602 writer.write_char('ệ').unwrap();
603 let mut r = BufReader::new(writer.get_ref());
604 assert_eq!(r.read_to_string().unwrap(), "a\nệ");
608 fn test_read_whole_string_bad() {
610 let mut r = BufReader::new(&buf);
611 match r.read_to_string() {
620 let mut r = BufReader::new(&buf);
621 r.seek(10, SeekSet).unwrap();
622 assert!(r.read(&mut []).is_err());
624 let mut r = MemReader::new(vec!(10));
625 r.seek(10, SeekSet).unwrap();
626 assert!(r.read(&mut []).is_err());
629 let mut r = BufWriter::new(&mut buf);
630 r.seek(10, SeekSet).unwrap();
631 assert!(r.write(&[3]).is_err());
637 let mut r = BufReader::new(&buf);
638 assert!(r.seek(-1, SeekSet).is_err());
640 let mut r = MemReader::new(vec!(10));
641 assert!(r.seek(-1, SeekSet).is_err());
644 let mut r = BufWriter::new(&mut buf);
645 assert!(r.seek(-1, SeekSet).is_err());
649 fn io_read_at_least() {
650 let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
651 let mut buf = [0; 3];
652 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
653 let b: &[_] = &[1, 2, 3];
655 assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
657 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
658 let b: &[_] = &[4, 5, 6];
660 assert!(r.read_at_least(buf.len(), &mut buf).is_err());
661 let b: &[_] = &[7, 8, 6];
665 fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) {
666 let src: Vec<u8> = Vec::from_elem(len, 5);
668 b.bytes = (times * len) as u64;
670 let mut wr = MemWriter::new();
671 for _ in range(0, times) {
672 wr.write(src.as_slice()).unwrap();
676 assert_eq!(v.len(), times * len);
677 assert!(v.iter().all(|x| *x == 5));
682 fn bench_mem_writer_001_0000(b: &mut Bencher) {
683 do_bench_mem_writer(b, 1, 0)
687 fn bench_mem_writer_001_0010(b: &mut Bencher) {
688 do_bench_mem_writer(b, 1, 10)
692 fn bench_mem_writer_001_0100(b: &mut Bencher) {
693 do_bench_mem_writer(b, 1, 100)
697 fn bench_mem_writer_001_1000(b: &mut Bencher) {
698 do_bench_mem_writer(b, 1, 1000)
702 fn bench_mem_writer_100_0000(b: &mut Bencher) {
703 do_bench_mem_writer(b, 100, 0)
707 fn bench_mem_writer_100_0010(b: &mut Bencher) {
708 do_bench_mem_writer(b, 100, 10)
712 fn bench_mem_writer_100_0100(b: &mut Bencher) {
713 do_bench_mem_writer(b, 100, 100)
717 fn bench_mem_writer_100_1000(b: &mut Bencher) {
718 do_bench_mem_writer(b, 100, 1000)
722 fn bench_mem_reader(b: &mut Bencher) {
724 let buf = [5 as u8; 100].to_vec();
726 let mut rdr = MemReader::new(buf);
727 for _i in range(0u, 10) {
728 let mut buf = [0 as u8; 10];
729 rdr.read(&mut buf).unwrap();
730 assert_eq!(buf.as_slice(), [5; 10].as_slice());
737 fn bench_buf_writer(b: &mut Bencher) {
739 let mut buf = [0 as u8; 100];
741 let mut wr = BufWriter::new(&mut buf);
742 for _i in range(0u, 10) {
743 wr.write(&[5; 10]).unwrap();
746 assert_eq!(buf.as_slice(), [5; 100].as_slice());
751 fn bench_buf_reader(b: &mut Bencher) {
753 let buf = [5 as u8; 100];
755 let mut rdr = BufReader::new(&buf);
756 for _i in range(0u, 10) {
757 let mut buf = [0 as u8; 10];
758 rdr.read(&mut buf).unwrap();
759 assert_eq!(buf, [5; 10]);