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 old_io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
23 const BUF_CAPACITY: usize = 128;
25 fn combine(seek: SeekStyle, cur: usize, end: usize, offset: i64) -> IoResult<u64> {
26 // compute offset as signed and clamp to prevent overflow
27 let pos = match seek {
29 old_io::SeekEnd => end,
30 old_io::SeekCur => cur,
35 kind: old_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_all(&mut self, buf: &[u8]) -> IoResult<()> {
52 /// Writes to an owned, growable byte vector
57 /// # #![feature(old_io, io)]
58 /// # #![allow(unused_must_use)]
59 /// use std::old_io::*;
61 /// let mut w = MemWriter::new();
62 /// w.write(&[0, 1, 2]);
64 /// assert_eq!(w.into_inner(), [0, 1, 2]);
66 #[unstable(feature = "io")]
67 #[deprecated(since = "1.0.0",
68 reason = "use the Vec<u8> Writer implementation directly")]
71 pub struct MemWriter {
77 /// Create a new `MemWriter`.
79 pub fn new() -> MemWriter {
80 MemWriter::with_capacity(BUF_CAPACITY)
82 /// Create a new `MemWriter`, allocating at least `n` bytes for
83 /// the internal buffer.
85 pub fn with_capacity(n: usize) -> MemWriter {
86 MemWriter::from_vec(Vec::with_capacity(n))
88 /// Create a new `MemWriter` that will append to an existing `Vec`.
90 pub fn from_vec(buf: Vec<u8>) -> MemWriter {
91 MemWriter { buf: buf }
94 /// Acquires an immutable reference to the underlying buffer of this
97 pub fn get_ref<'a>(&'a self) -> &'a [u8] { &self.buf }
99 /// Unwraps this `MemWriter`, returning the underlying buffer
101 pub fn into_inner(self) -> Vec<u8> { self.buf }
104 impl Writer for MemWriter {
107 fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
108 self.buf.push_all(buf);
113 /// Reads from an owned byte vector
118 /// # #![feature(old_io)]
119 /// # #![allow(unused_must_use)]
120 /// use std::old_io::*;
122 /// let mut r = MemReader::new(vec!(0, 1, 2));
124 /// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2]);
126 pub struct MemReader {
132 /// Creates a new `MemReader` which will read the buffer given. The buffer
133 /// can be re-acquired through `unwrap`
135 pub fn new(buf: Vec<u8>) -> MemReader {
142 /// Tests whether this reader has read all bytes in its buffer.
144 /// If `true`, then this will no longer return bytes from `read`.
146 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
148 /// Acquires an immutable reference to the underlying buffer of this
151 /// No method is exposed for acquiring a mutable reference to the buffer
152 /// because it could corrupt the state of this `MemReader`.
154 pub fn get_ref<'a>(&'a self) -> &'a [u8] { &self.buf }
156 /// Unwraps this `MemReader`, returning the underlying buffer
158 pub fn into_inner(self) -> Vec<u8> { self.buf }
161 impl Reader for MemReader {
163 fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
164 if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
166 let write_len = min(buf.len(), self.buf.len() - self.pos);
168 let input = &self.buf[self.pos.. self.pos + write_len];
169 let output = &mut buf[..write_len];
170 assert_eq!(input.len(), output.len());
171 slice::bytes::copy_memory(output, input);
173 self.pos += write_len;
174 assert!(self.pos <= self.buf.len());
176 return Ok(write_len);
180 impl Seek for MemReader {
182 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
185 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
186 let new = try!(combine(style, self.pos, self.buf.len(), pos));
187 self.pos = new as usize;
192 impl Buffer for MemReader {
194 fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
195 if self.pos < self.buf.len() {
196 Ok(&self.buf[self.pos..])
198 Err(old_io::standard_error(old_io::EndOfFile))
203 fn consume(&mut self, amt: usize) { self.pos += amt; }
206 impl<'a> Reader for &'a [u8] {
208 fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
209 if self.is_empty() { return Err(old_io::standard_error(old_io::EndOfFile)); }
211 let write_len = min(buf.len(), self.len());
213 let input = &self[..write_len];
214 let output = &mut buf[.. write_len];
215 slice::bytes::copy_memory(output, input);
218 *self = &self[write_len..];
224 impl<'a> Buffer for &'a [u8] {
226 fn fill_buf(&mut self) -> IoResult<&[u8]> {
228 Err(old_io::standard_error(old_io::EndOfFile))
235 fn consume(&mut self, amt: usize) {
236 *self = &self[amt..];
241 /// Writes to a fixed-size byte slice
243 /// If a write will not fit in the buffer, it returns an error and does not
249 /// # #![feature(old_io, io)]
250 /// # #![allow(unused_must_use)]
251 /// use std::old_io::*;
253 /// let mut buf = [0; 4];
255 /// let mut w = BufWriter::new(&mut buf);
256 /// w.write(&[0, 1, 2]);
258 /// assert!(buf == [0, 1, 2, 0]);
260 pub struct BufWriter<'a> {
265 impl<'a> BufWriter<'a> {
266 /// Creates a new `BufWriter` which will wrap the specified buffer. The
267 /// writer initially starts at position 0.
269 pub fn new(buf: &'a mut [u8]) -> BufWriter<'a> {
277 impl<'a> Writer for BufWriter<'a> {
279 fn write_all(&mut self, src: &[u8]) -> IoResult<()> {
280 let dst = &mut self.buf[self.pos..];
281 let dst_len = dst.len();
284 return Err(old_io::standard_error(old_io::EndOfFile));
287 let src_len = src.len();
289 if dst_len >= src_len {
290 slice::bytes::copy_memory(dst, src);
296 slice::bytes::copy_memory(dst, &src[..dst_len]);
300 Err(old_io::standard_error(old_io::ShortWrite(dst_len)))
305 impl<'a> Seek for BufWriter<'a> {
307 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
310 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
311 let new = try!(combine(style, self.pos, self.buf.len(), pos));
312 self.pos = min(new as usize, self.buf.len());
317 /// Reads from a fixed-size byte slice
322 /// # #![feature(old_io)]
323 /// # #![allow(unused_must_use)]
324 /// use std::old_io::*;
326 /// let buf = [0, 1, 2, 3];
327 /// let mut r = BufReader::new(&buf);
329 /// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2, 3]);
331 pub struct BufReader<'a> {
336 impl<'a> BufReader<'a> {
337 /// Creates a new buffered reader which will read the specified buffer
339 pub fn new(buf: &'a [u8]) -> BufReader<'a> {
346 /// Tests whether this reader has read all bytes in its buffer.
348 /// If `true`, then this will no longer return bytes from `read`.
350 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
353 impl<'a> Reader for BufReader<'a> {
355 fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
356 if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
358 let write_len = min(buf.len(), self.buf.len() - self.pos);
360 let input = &self.buf[self.pos.. self.pos + write_len];
361 let output = &mut buf[..write_len];
362 assert_eq!(input.len(), output.len());
363 slice::bytes::copy_memory(output, input);
365 self.pos += write_len;
366 assert!(self.pos <= self.buf.len());
368 return Ok(write_len);
372 impl<'a> Seek for BufReader<'a> {
374 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
377 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
378 let new = try!(combine(style, self.pos, self.buf.len(), pos));
379 self.pos = new as usize;
384 impl<'a> Buffer for BufReader<'a> {
386 fn fill_buf(&mut self) -> IoResult<&[u8]> {
387 if self.pos < self.buf.len() {
388 Ok(&self.buf[self.pos..])
390 Err(old_io::standard_error(old_io::EndOfFile))
395 fn consume(&mut self, amt: usize) { self.pos += amt; }
400 extern crate test as test_crate;
401 use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek, Buffer};
402 use prelude::v1::{Ok, Err, Vec, AsSlice};
403 use prelude::v1::IteratorExt;
406 use self::test_crate::Bencher;
410 fn test_vec_writer() {
411 let mut writer = Vec::new();
412 writer.write(&[0]).unwrap();
413 writer.write(&[1, 2, 3]).unwrap();
414 writer.write(&[4, 5, 6, 7]).unwrap();
415 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
416 assert_eq!(writer, b);
420 fn test_mem_writer() {
421 let mut writer = MemWriter::new();
422 writer.write(&[0]).unwrap();
423 writer.write(&[1, 2, 3]).unwrap();
424 writer.write(&[4, 5, 6, 7]).unwrap();
425 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
426 assert_eq!(writer.get_ref(), b);
430 fn test_buf_writer() {
431 let mut buf = [0 as u8; 9];
433 let mut writer = BufWriter::new(&mut buf);
434 assert_eq!(writer.tell(), Ok(0));
435 writer.write(&[0]).unwrap();
436 assert_eq!(writer.tell(), Ok(1));
437 writer.write(&[1, 2, 3]).unwrap();
438 writer.write(&[4, 5, 6, 7]).unwrap();
439 assert_eq!(writer.tell(), Ok(8));
440 writer.write(&[]).unwrap();
441 assert_eq!(writer.tell(), Ok(8));
443 assert_eq!(writer.write(&[8, 9]).err().unwrap().kind, old_io::ShortWrite(1));
444 assert_eq!(writer.write(&[10]).err().unwrap().kind, old_io::EndOfFile);
446 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
451 fn test_buf_writer_seek() {
452 let mut buf = [0 as u8; 8];
454 let mut writer = BufWriter::new(&mut buf);
455 assert_eq!(writer.tell(), Ok(0));
456 writer.write(&[1]).unwrap();
457 assert_eq!(writer.tell(), Ok(1));
459 writer.seek(2, SeekSet).unwrap();
460 assert_eq!(writer.tell(), Ok(2));
461 writer.write(&[2]).unwrap();
462 assert_eq!(writer.tell(), Ok(3));
464 writer.seek(-2, SeekCur).unwrap();
465 assert_eq!(writer.tell(), Ok(1));
466 writer.write(&[3]).unwrap();
467 assert_eq!(writer.tell(), Ok(2));
469 writer.seek(-1, SeekEnd).unwrap();
470 assert_eq!(writer.tell(), Ok(7));
471 writer.write(&[4]).unwrap();
472 assert_eq!(writer.tell(), Ok(8));
475 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
480 fn test_buf_writer_error() {
481 let mut buf = [0 as u8; 2];
482 let mut writer = BufWriter::new(&mut buf);
483 writer.write(&[0]).unwrap();
485 match writer.write(&[0, 0]) {
487 Err(e) => assert_eq!(e.kind, old_io::ShortWrite(1)),
492 fn test_mem_reader() {
493 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
495 assert_eq!(reader.read(&mut buf), Ok(0));
496 assert_eq!(reader.tell(), Ok(0));
498 assert_eq!(reader.read(&mut buf), Ok(1));
499 assert_eq!(reader.tell(), Ok(1));
502 let mut buf = [0; 4];
503 assert_eq!(reader.read(&mut buf), Ok(4));
504 assert_eq!(reader.tell(), Ok(5));
505 let b: &[_] = &[1, 2, 3, 4];
507 assert_eq!(reader.read(&mut buf), Ok(3));
508 let b: &[_] = &[5, 6, 7];
509 assert_eq!(&buf[..3], b);
510 assert!(reader.read(&mut buf).is_err());
511 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
512 assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]);
513 assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]);
514 assert!(reader.read(&mut buf).is_err());
518 fn test_slice_reader() {
519 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
520 let mut reader = &mut &*in_buf;
522 assert_eq!(reader.read(&mut buf), Ok(0));
524 assert_eq!(reader.read(&mut buf), Ok(1));
525 assert_eq!(reader.len(), 7);
528 let mut buf = [0; 4];
529 assert_eq!(reader.read(&mut buf), Ok(4));
530 assert_eq!(reader.len(), 3);
531 let b: &[_] = &[1, 2, 3, 4];
533 assert_eq!(reader.read(&mut buf), Ok(3));
534 let b: &[_] = &[5, 6, 7];
535 assert_eq!(&buf[..3], b);
536 assert!(reader.read(&mut buf).is_err());
537 let mut reader = &mut &*in_buf;
538 assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]);
539 assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]);
540 assert!(reader.read(&mut buf).is_err());
544 fn test_buf_reader() {
545 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
546 let mut reader = BufReader::new(&in_buf);
548 assert_eq!(reader.read(&mut buf), Ok(0));
549 assert_eq!(reader.tell(), Ok(0));
551 assert_eq!(reader.read(&mut buf), Ok(1));
552 assert_eq!(reader.tell(), Ok(1));
555 let mut buf = [0; 4];
556 assert_eq!(reader.read(&mut buf), Ok(4));
557 assert_eq!(reader.tell(), Ok(5));
558 let b: &[_] = &[1, 2, 3, 4];
560 assert_eq!(reader.read(&mut buf), Ok(3));
561 let b: &[_] = &[5, 6, 7];
562 assert_eq!(&buf[..3], b);
563 assert!(reader.read(&mut buf).is_err());
564 let mut reader = BufReader::new(&in_buf);
565 assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]);
566 assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]);
567 assert!(reader.read(&mut buf).is_err());
571 fn test_read_char() {
572 let b = b"Vi\xE1\xBB\x87t";
573 let mut r = BufReader::new(b);
574 assert_eq!(r.read_char(), Ok('V'));
575 assert_eq!(r.read_char(), Ok('i'));
576 assert_eq!(r.read_char(), Ok('ệ'));
577 assert_eq!(r.read_char(), Ok('t'));
578 assert!(r.read_char().is_err());
582 fn test_read_bad_char() {
584 let mut r = BufReader::new(b);
585 assert!(r.read_char().is_err());
589 fn test_write_strings() {
590 let mut writer = MemWriter::new();
591 writer.write_str("testing").unwrap();
592 writer.write_line("testing").unwrap();
593 writer.write_str("testing").unwrap();
594 let mut r = BufReader::new(writer.get_ref());
595 assert_eq!(r.read_to_string().unwrap(), "testingtesting\ntesting");
599 fn test_write_char() {
600 let mut writer = MemWriter::new();
601 writer.write_char('a').unwrap();
602 writer.write_char('\n').unwrap();
603 writer.write_char('ệ').unwrap();
604 let mut r = BufReader::new(writer.get_ref());
605 assert_eq!(r.read_to_string().unwrap(), "a\nệ");
609 fn test_read_whole_string_bad() {
611 let mut r = BufReader::new(&buf);
612 match r.read_to_string() {
621 let mut r = BufReader::new(&buf);
622 r.seek(10, SeekSet).unwrap();
623 assert!(r.read(&mut []).is_err());
625 let mut r = MemReader::new(vec!(10));
626 r.seek(10, SeekSet).unwrap();
627 assert!(r.read(&mut []).is_err());
630 let mut r = BufWriter::new(&mut buf);
631 r.seek(10, SeekSet).unwrap();
632 assert!(r.write(&[3]).is_err());
638 let mut r = BufReader::new(&buf);
639 assert!(r.seek(-1, SeekSet).is_err());
641 let mut r = MemReader::new(vec!(10));
642 assert!(r.seek(-1, SeekSet).is_err());
645 let mut r = BufWriter::new(&mut buf);
646 assert!(r.seek(-1, SeekSet).is_err());
650 fn io_read_at_least() {
651 let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
652 let mut buf = [0; 3];
653 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
654 let b: &[_] = &[1, 2, 3];
656 assert!(r.read_at_least(0, &mut buf[..0]).is_ok());
658 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
659 let b: &[_] = &[4, 5, 6];
661 assert!(r.read_at_least(buf.len(), &mut buf).is_err());
662 let b: &[_] = &[7, 8, 6];
666 fn do_bench_mem_writer(b: &mut Bencher, times: usize, len: usize) {
667 let src: Vec<u8> = repeat(5).take(len).collect();
669 b.bytes = (times * len) as u64;
671 let mut wr = MemWriter::new();
673 wr.write(&src).unwrap();
676 let v = wr.into_inner();
677 assert_eq!(v.len(), times * len);
678 assert!(v.iter().all(|x| *x == 5));
683 fn bench_mem_writer_001_0000(b: &mut Bencher) {
684 do_bench_mem_writer(b, 1, 0)
688 fn bench_mem_writer_001_0010(b: &mut Bencher) {
689 do_bench_mem_writer(b, 1, 10)
693 fn bench_mem_writer_001_0100(b: &mut Bencher) {
694 do_bench_mem_writer(b, 1, 100)
698 fn bench_mem_writer_001_1000(b: &mut Bencher) {
699 do_bench_mem_writer(b, 1, 1000)
703 fn bench_mem_writer_100_0000(b: &mut Bencher) {
704 do_bench_mem_writer(b, 100, 0)
708 fn bench_mem_writer_100_0010(b: &mut Bencher) {
709 do_bench_mem_writer(b, 100, 10)
713 fn bench_mem_writer_100_0100(b: &mut Bencher) {
714 do_bench_mem_writer(b, 100, 100)
718 fn bench_mem_writer_100_1000(b: &mut Bencher) {
719 do_bench_mem_writer(b, 100, 1000)
723 fn bench_mem_reader(b: &mut Bencher) {
725 let buf = [5 as u8; 100].to_vec();
727 let mut rdr = MemReader::new(buf);
729 let mut buf = [0 as u8; 10];
730 rdr.read(&mut buf).unwrap();
731 assert_eq!(buf, [5; 10]);
738 fn bench_buf_writer(b: &mut Bencher) {
740 let mut buf = [0 as u8; 100];
742 let mut wr = BufWriter::new(&mut buf);
744 wr.write(&[5; 10]).unwrap();
747 assert_eq!(buf.as_slice(), [5; 100].as_slice());
752 fn bench_buf_reader(b: &mut Bencher) {
754 let buf = [5 as u8; 100];
756 let mut rdr = BufReader::new(&buf);
758 let mut buf = [0 as u8; 10];
759 rdr.read(&mut buf).unwrap();
760 assert_eq!(buf, [5; 10]);