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
16 use option::Option::None;
17 use result::Result::{Err, Ok};
19 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
20 use slice::{self, AsSlice, SliceExt};
23 const BUF_CAPACITY: uint = 128;
25 fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
26 // compute offset as signed and clamp to prevent overflow
27 let pos = match seek {
35 kind: io::InvalidInput,
36 desc: "invalid seek to a negative offset",
40 Ok((offset + pos) as u64)
44 impl Writer for Vec<u8> {
46 fn write(&mut self, buf: &[u8]) -> IoResult<()> {
52 /// Writes to an owned, growable byte vector
57 /// # #![allow(unused_must_use)]
58 /// use std::io::MemWriter;
60 /// let mut w = MemWriter::new();
61 /// w.write(&[0, 1, 2]);
63 /// assert_eq!(w.into_inner(), vec!(0, 1, 2));
65 #[deprecated = "use the Vec<u8> Writer implementation directly"]
67 pub struct MemWriter {
73 /// Create a new `MemWriter`.
75 pub fn new() -> MemWriter {
76 MemWriter::with_capacity(BUF_CAPACITY)
78 /// Create a new `MemWriter`, allocating at least `n` bytes for
79 /// the internal buffer.
81 pub fn with_capacity(n: uint) -> MemWriter {
82 MemWriter::from_vec(Vec::with_capacity(n))
84 /// Create a new `MemWriter` that will append to an existing `Vec`.
86 pub fn from_vec(buf: Vec<u8>) -> MemWriter {
87 MemWriter { buf: buf }
90 /// Acquires an immutable reference to the underlying buffer of this
93 pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
95 /// Unwraps this `MemWriter`, returning the underlying buffer
97 pub fn into_inner(self) -> Vec<u8> { self.buf }
100 impl Writer for MemWriter {
102 fn write(&mut self, buf: &[u8]) -> IoResult<()> {
103 self.buf.push_all(buf);
108 /// Reads from an owned byte vector
113 /// # #![allow(unused_must_use)]
114 /// use std::io::MemReader;
116 /// let mut r = MemReader::new(vec!(0, 1, 2));
118 /// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2));
120 pub struct MemReader {
126 /// Creates a new `MemReader` which will read the buffer given. The buffer
127 /// can be re-acquired through `unwrap`
129 pub fn new(buf: Vec<u8>) -> MemReader {
136 /// Tests whether this reader has read all bytes in its buffer.
138 /// If `true`, then this will no longer return bytes from `read`.
140 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
142 /// Acquires an immutable reference to the underlying buffer of this
145 /// No method is exposed for acquiring a mutable reference to the buffer
146 /// because it could corrupt the state of this `MemReader`.
148 pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
150 /// Unwraps this `MemReader`, returning the underlying buffer
152 pub fn into_inner(self) -> Vec<u8> { self.buf }
155 impl Reader for MemReader {
157 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
158 if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
160 let write_len = min(buf.len(), self.buf.len() - self.pos);
162 let input = self.buf[self.pos.. self.pos + write_len];
163 let output = buf.slice_to_mut(write_len);
164 assert_eq!(input.len(), output.len());
165 slice::bytes::copy_memory(output, input);
167 self.pos += write_len;
168 assert!(self.pos <= self.buf.len());
170 return Ok(write_len);
174 impl Seek for MemReader {
176 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
179 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
180 let new = try!(combine(style, self.pos, self.buf.len(), pos));
181 self.pos = new as uint;
186 impl Buffer for MemReader {
188 fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
189 if self.pos < self.buf.len() {
190 Ok(self.buf[self.pos..])
192 Err(io::standard_error(io::EndOfFile))
197 fn consume(&mut self, amt: uint) { self.pos += amt; }
200 impl<'a> Reader for &'a [u8] {
202 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
203 if self.is_empty() { return Err(io::standard_error(io::EndOfFile)); }
205 let write_len = min(buf.len(), self.len());
207 let input = self[..write_len];
208 let output = buf.slice_to_mut(write_len);
209 slice::bytes::copy_memory(output, input);
212 *self = self.slice_from(write_len);
218 impl<'a> Buffer for &'a [u8] {
220 fn fill_buf(&mut self) -> IoResult<&[u8]> {
222 Err(io::standard_error(io::EndOfFile))
229 fn consume(&mut self, amt: uint) {
235 /// Writes to a fixed-size byte slice
237 /// If a write will not fit in the buffer, it returns an error and does not
243 /// # #![allow(unused_must_use)]
244 /// use std::io::BufWriter;
246 /// let mut buf = [0; 4];
248 /// let mut w = BufWriter::new(&mut buf);
249 /// w.write(&[0, 1, 2]);
251 /// assert!(buf == [0, 1, 2, 0]);
253 pub struct BufWriter<'a> {
258 impl<'a> BufWriter<'a> {
259 /// Creates a new `BufWriter` which will wrap the specified buffer. The
260 /// writer initially starts at position 0.
262 pub fn new(buf: &'a mut [u8]) -> BufWriter<'a> {
270 impl<'a> Writer for BufWriter<'a> {
272 fn write(&mut self, src: &[u8]) -> IoResult<()> {
273 let dst = self.buf.slice_from_mut(self.pos);
274 let dst_len = dst.len();
277 return Err(io::standard_error(io::EndOfFile));
280 let src_len = src.len();
282 if dst_len >= src_len {
283 slice::bytes::copy_memory(dst, src);
289 slice::bytes::copy_memory(dst, src[..dst_len]);
293 Err(io::standard_error(io::ShortWrite(dst_len)))
298 impl<'a> Seek for BufWriter<'a> {
300 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
303 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
304 let new = try!(combine(style, self.pos, self.buf.len(), pos));
305 self.pos = min(new as uint, self.buf.len());
310 /// Reads from a fixed-size byte slice
315 /// # #![allow(unused_must_use)]
316 /// use std::io::BufReader;
318 /// let buf = [0, 1, 2, 3];
319 /// let mut r = BufReader::new(&buf);
321 /// assert_eq!(r.read_to_end().unwrap(), vec![0, 1, 2, 3]);
323 pub struct BufReader<'a> {
328 impl<'a> BufReader<'a> {
329 /// Creates a new buffered reader which will read the specified buffer
331 pub fn new(buf: &'a [u8]) -> BufReader<'a> {
338 /// Tests whether this reader has read all bytes in its buffer.
340 /// If `true`, then this will no longer return bytes from `read`.
342 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
345 impl<'a> Reader for BufReader<'a> {
347 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
348 if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
350 let write_len = min(buf.len(), self.buf.len() - self.pos);
352 let input = self.buf[self.pos.. self.pos + write_len];
353 let output = buf.slice_to_mut(write_len);
354 assert_eq!(input.len(), output.len());
355 slice::bytes::copy_memory(output, input);
357 self.pos += write_len;
358 assert!(self.pos <= self.buf.len());
360 return Ok(write_len);
364 impl<'a> Seek for BufReader<'a> {
366 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
369 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
370 let new = try!(combine(style, self.pos, self.buf.len(), pos));
371 self.pos = new as uint;
376 impl<'a> Buffer for BufReader<'a> {
378 fn fill_buf(&mut self) -> IoResult<&[u8]> {
379 if self.pos < self.buf.len() {
380 Ok(self.buf[self.pos..])
382 Err(io::standard_error(io::EndOfFile))
387 fn consume(&mut self, amt: uint) { self.pos += amt; }
392 extern crate "test" as test_crate;
395 use io::{SeekSet, SeekCur, SeekEnd};
398 use self::test_crate::Bencher;
402 fn test_vec_writer() {
403 let mut writer = Vec::new();
404 writer.write(&[0]).unwrap();
405 writer.write(&[1, 2, 3]).unwrap();
406 writer.write(&[4, 5, 6, 7]).unwrap();
407 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
408 assert_eq!(writer.as_slice(), b);
412 fn test_mem_writer() {
413 let mut writer = MemWriter::new();
414 writer.write(&[0]).unwrap();
415 writer.write(&[1, 2, 3]).unwrap();
416 writer.write(&[4, 5, 6, 7]).unwrap();
417 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
418 assert_eq!(writer.get_ref(), b);
422 fn test_buf_writer() {
423 let mut buf = [0 as u8; 9];
425 let mut writer = BufWriter::new(&mut buf);
426 assert_eq!(writer.tell(), Ok(0));
427 writer.write(&[0]).unwrap();
428 assert_eq!(writer.tell(), Ok(1));
429 writer.write(&[1, 2, 3]).unwrap();
430 writer.write(&[4, 5, 6, 7]).unwrap();
431 assert_eq!(writer.tell(), Ok(8));
432 writer.write(&[]).unwrap();
433 assert_eq!(writer.tell(), Ok(8));
435 assert_eq!(writer.write(&[8, 9]).unwrap_err().kind, io::ShortWrite(1));
436 assert_eq!(writer.write(&[10]).unwrap_err().kind, io::EndOfFile);
438 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
443 fn test_buf_writer_seek() {
444 let mut buf = [0 as u8; 8];
446 let mut writer = BufWriter::new(&mut buf);
447 assert_eq!(writer.tell(), Ok(0));
448 writer.write(&[1]).unwrap();
449 assert_eq!(writer.tell(), Ok(1));
451 writer.seek(2, SeekSet).unwrap();
452 assert_eq!(writer.tell(), Ok(2));
453 writer.write(&[2]).unwrap();
454 assert_eq!(writer.tell(), Ok(3));
456 writer.seek(-2, SeekCur).unwrap();
457 assert_eq!(writer.tell(), Ok(1));
458 writer.write(&[3]).unwrap();
459 assert_eq!(writer.tell(), Ok(2));
461 writer.seek(-1, SeekEnd).unwrap();
462 assert_eq!(writer.tell(), Ok(7));
463 writer.write(&[4]).unwrap();
464 assert_eq!(writer.tell(), Ok(8));
467 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
472 fn test_buf_writer_error() {
473 let mut buf = [0 as u8; 2];
474 let mut writer = BufWriter::new(&mut buf);
475 writer.write(&[0]).unwrap();
477 match writer.write(&[0, 0]) {
479 Err(e) => assert_eq!(e.kind, io::ShortWrite(1)),
484 fn test_mem_reader() {
485 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
487 assert_eq!(reader.read(&mut buf), Ok(0));
488 assert_eq!(reader.tell(), Ok(0));
490 assert_eq!(reader.read(&mut buf), Ok(1));
491 assert_eq!(reader.tell(), Ok(1));
494 let mut buf = [0; 4];
495 assert_eq!(reader.read(&mut buf), Ok(4));
496 assert_eq!(reader.tell(), Ok(5));
497 let b: &[_] = &[1, 2, 3, 4];
499 assert_eq!(reader.read(&mut buf), Ok(3));
500 let b: &[_] = &[5, 6, 7];
501 assert_eq!(buf[0..3], b);
502 assert!(reader.read(&mut buf).is_err());
503 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
504 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
505 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
506 assert!(reader.read(&mut buf).is_err());
510 fn test_slice_reader() {
511 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
512 let mut reader = &mut in_buf.as_slice();
514 assert_eq!(reader.read(&mut buf), Ok(0));
516 assert_eq!(reader.read(&mut buf), Ok(1));
517 assert_eq!(reader.len(), 7);
519 assert_eq!(buf.as_slice(), b);
520 let mut buf = [0; 4];
521 assert_eq!(reader.read(&mut buf), Ok(4));
522 assert_eq!(reader.len(), 3);
523 let b: &[_] = &[1, 2, 3, 4];
524 assert_eq!(buf.as_slice(), b);
525 assert_eq!(reader.read(&mut buf), Ok(3));
526 let b: &[_] = &[5, 6, 7];
527 assert_eq!(buf[0..3], b);
528 assert!(reader.read(&mut buf).is_err());
529 let mut reader = &mut in_buf.as_slice();
530 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
531 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
532 assert!(reader.read(&mut buf).is_err());
536 fn test_buf_reader() {
537 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
538 let mut reader = BufReader::new(in_buf.as_slice());
540 assert_eq!(reader.read(&mut buf), Ok(0));
541 assert_eq!(reader.tell(), Ok(0));
543 assert_eq!(reader.read(&mut buf), Ok(1));
544 assert_eq!(reader.tell(), Ok(1));
547 let mut buf = [0; 4];
548 assert_eq!(reader.read(&mut buf), Ok(4));
549 assert_eq!(reader.tell(), Ok(5));
550 let b: &[_] = &[1, 2, 3, 4];
552 assert_eq!(reader.read(&mut buf), Ok(3));
553 let b: &[_] = &[5, 6, 7];
554 assert_eq!(buf[0..3], b);
555 assert!(reader.read(&mut buf).is_err());
556 let mut reader = BufReader::new(in_buf.as_slice());
557 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
558 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
559 assert!(reader.read(&mut buf).is_err());
563 fn test_read_char() {
564 let b = b"Vi\xE1\xBB\x87t";
565 let mut r = BufReader::new(b);
566 assert_eq!(r.read_char(), Ok('V'));
567 assert_eq!(r.read_char(), Ok('i'));
568 assert_eq!(r.read_char(), Ok('ệ'));
569 assert_eq!(r.read_char(), Ok('t'));
570 assert!(r.read_char().is_err());
574 fn test_read_bad_char() {
576 let mut r = BufReader::new(b);
577 assert!(r.read_char().is_err());
581 fn test_write_strings() {
582 let mut writer = MemWriter::new();
583 writer.write_str("testing").unwrap();
584 writer.write_line("testing").unwrap();
585 writer.write_str("testing").unwrap();
586 let mut r = BufReader::new(writer.get_ref());
587 assert_eq!(r.read_to_string().unwrap(), "testingtesting\ntesting");
591 fn test_write_char() {
592 let mut writer = MemWriter::new();
593 writer.write_char('a').unwrap();
594 writer.write_char('\n').unwrap();
595 writer.write_char('ệ').unwrap();
596 let mut r = BufReader::new(writer.get_ref());
597 assert_eq!(r.read_to_string().unwrap(), "a\nệ");
601 fn test_read_whole_string_bad() {
603 let mut r = BufReader::new(&buf);
604 match r.read_to_string() {
613 let mut r = BufReader::new(&buf);
614 r.seek(10, SeekSet).unwrap();
615 assert!(r.read(&mut []).is_err());
617 let mut r = MemReader::new(vec!(10));
618 r.seek(10, SeekSet).unwrap();
619 assert!(r.read(&mut []).is_err());
622 let mut r = BufWriter::new(&mut buf);
623 r.seek(10, SeekSet).unwrap();
624 assert!(r.write(&[3]).is_err());
630 let mut r = BufReader::new(&buf);
631 assert!(r.seek(-1, SeekSet).is_err());
633 let mut r = MemReader::new(vec!(10));
634 assert!(r.seek(-1, SeekSet).is_err());
637 let mut r = BufWriter::new(&mut buf);
638 assert!(r.seek(-1, SeekSet).is_err());
642 fn io_read_at_least() {
643 let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
644 let mut buf = [0; 3];
645 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
646 let b: &[_] = &[1, 2, 3];
648 assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
650 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
651 let b: &[_] = &[4, 5, 6];
653 assert!(r.read_at_least(buf.len(), &mut buf).is_err());
654 let b: &[_] = &[7, 8, 6];
658 fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) {
659 let src: Vec<u8> = repeat(5).take(len).collect();
661 b.bytes = (times * len) as u64;
663 let mut wr = MemWriter::new();
664 for _ in range(0, times) {
665 wr.write(src.as_slice()).unwrap();
668 let v = wr.into_inner();
669 assert_eq!(v.len(), times * len);
670 assert!(v.iter().all(|x| *x == 5));
675 fn bench_mem_writer_001_0000(b: &mut Bencher) {
676 do_bench_mem_writer(b, 1, 0)
680 fn bench_mem_writer_001_0010(b: &mut Bencher) {
681 do_bench_mem_writer(b, 1, 10)
685 fn bench_mem_writer_001_0100(b: &mut Bencher) {
686 do_bench_mem_writer(b, 1, 100)
690 fn bench_mem_writer_001_1000(b: &mut Bencher) {
691 do_bench_mem_writer(b, 1, 1000)
695 fn bench_mem_writer_100_0000(b: &mut Bencher) {
696 do_bench_mem_writer(b, 100, 0)
700 fn bench_mem_writer_100_0010(b: &mut Bencher) {
701 do_bench_mem_writer(b, 100, 10)
705 fn bench_mem_writer_100_0100(b: &mut Bencher) {
706 do_bench_mem_writer(b, 100, 100)
710 fn bench_mem_writer_100_1000(b: &mut Bencher) {
711 do_bench_mem_writer(b, 100, 1000)
715 fn bench_mem_reader(b: &mut Bencher) {
717 let buf = [5 as u8; 100].to_vec();
719 let mut rdr = MemReader::new(buf);
720 for _i in range(0u, 10) {
721 let mut buf = [0 as u8; 10];
722 rdr.read(&mut buf).unwrap();
723 assert_eq!(buf.as_slice(), [5; 10].as_slice());
730 fn bench_buf_writer(b: &mut Bencher) {
732 let mut buf = [0 as u8; 100];
734 let mut wr = BufWriter::new(&mut buf);
735 for _i in range(0u, 10) {
736 wr.write(&[5; 10]).unwrap();
739 assert_eq!(buf.as_slice(), [5; 100].as_slice());
744 fn bench_buf_reader(b: &mut Bencher) {
746 let buf = [5 as u8; 100];
748 let mut rdr = BufReader::new(&buf);
749 for _i in range(0u, 10) {
750 let mut buf = [0 as u8; 10];
751 rdr.read(&mut buf).unwrap();
752 assert_eq!(buf, [5; 10]);