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
17 use option::Option::None;
18 use result::Result::{Err, Ok};
20 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
21 use slice::{self, AsSlice, SliceExt};
24 const BUF_CAPACITY: uint = 128;
26 fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
27 // compute offset as signed and clamp to prevent overflow
28 let pos = match seek {
36 kind: io::InvalidInput,
37 desc: "invalid seek to a negative offset",
41 Ok((offset + pos) as u64)
45 impl Writer for Vec<u8> {
47 fn write(&mut self, buf: &[u8]) -> IoResult<()> {
53 /// Writes to an owned, growable byte vector
58 /// # #![allow(unused_must_use)]
59 /// use std::io::MemWriter;
61 /// let mut w = MemWriter::new();
62 /// w.write(&[0, 1, 2]);
64 /// assert_eq!(w.into_inner(), vec!(0, 1, 2));
66 #[deprecated = "use the Vec<u8> Writer implementation directly"]
68 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 }
101 impl Writer for MemWriter {
103 fn write(&mut self, buf: &[u8]) -> IoResult<()> {
104 self.buf.push_all(buf);
109 /// Reads from an owned byte vector
114 /// # #![allow(unused_must_use)]
115 /// use std::io::MemReader;
117 /// let mut r = MemReader::new(vec!(0, 1, 2));
119 /// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2));
121 pub struct MemReader {
127 /// Creates a new `MemReader` which will read the buffer given. The buffer
128 /// can be re-acquired through `unwrap`
130 pub fn new(buf: Vec<u8>) -> MemReader {
137 /// Tests whether this reader has read all bytes in its buffer.
139 /// If `true`, then this will no longer return bytes from `read`.
141 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
143 /// Acquires an immutable reference to the underlying buffer of this
146 /// No method is exposed for acquiring a mutable reference to the buffer
147 /// because it could corrupt the state of this `MemReader`.
149 pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
151 /// Unwraps this `MemReader`, returning the underlying buffer
153 pub fn into_inner(self) -> Vec<u8> { self.buf }
156 impl Reader for MemReader {
158 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
159 if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
161 let write_len = min(buf.len(), self.buf.len() - self.pos);
163 let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
164 let output = buf.slice_to_mut(write_len);
165 assert_eq!(input.len(), output.len());
166 slice::bytes::copy_memory(output, input);
168 self.pos += write_len;
169 assert!(self.pos <= self.buf.len());
171 return Ok(write_len);
175 impl Seek for MemReader {
177 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
180 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
181 let new = try!(combine(style, self.pos, self.buf.len(), pos));
182 self.pos = new as uint;
187 impl Buffer for MemReader {
189 fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
190 if self.pos < self.buf.len() {
191 Ok(self.buf.index(&(self.pos..)))
193 Err(io::standard_error(io::EndOfFile))
198 fn consume(&mut self, amt: uint) { self.pos += amt; }
201 impl<'a> Reader for &'a [u8] {
203 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
204 if self.is_empty() { return Err(io::standard_error(io::EndOfFile)); }
206 let write_len = min(buf.len(), self.len());
208 let input = self.index(&(0..write_len));
209 let output = buf.slice_to_mut(write_len);
210 slice::bytes::copy_memory(output, input);
213 *self = self.slice_from(write_len);
219 impl<'a> Buffer for &'a [u8] {
221 fn fill_buf(&mut self) -> IoResult<&[u8]> {
223 Err(io::standard_error(io::EndOfFile))
230 fn consume(&mut self, amt: uint) {
231 *self = self.index(&(amt..));
236 /// Writes to a fixed-size byte slice
238 /// If a write will not fit in the buffer, it returns an error and does not
244 /// # #![allow(unused_must_use)]
245 /// use std::io::BufWriter;
247 /// let mut buf = [0; 4];
249 /// let mut w = BufWriter::new(&mut buf);
250 /// w.write(&[0, 1, 2]);
252 /// assert!(buf == [0, 1, 2, 0]);
254 pub struct BufWriter<'a> {
259 impl<'a> BufWriter<'a> {
260 /// Creates a new `BufWriter` which will wrap the specified buffer. The
261 /// writer initially starts at position 0.
263 pub fn new(buf: &'a mut [u8]) -> BufWriter<'a> {
271 impl<'a> Writer for BufWriter<'a> {
273 fn write(&mut self, src: &[u8]) -> IoResult<()> {
274 let dst = self.buf.slice_from_mut(self.pos);
275 let dst_len = dst.len();
278 return Err(io::standard_error(io::EndOfFile));
281 let src_len = src.len();
283 if dst_len >= src_len {
284 slice::bytes::copy_memory(dst, src);
290 slice::bytes::copy_memory(dst, src.index(&(0..dst_len)));
294 Err(io::standard_error(io::ShortWrite(dst_len)))
299 impl<'a> Seek for BufWriter<'a> {
301 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
304 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
305 let new = try!(combine(style, self.pos, self.buf.len(), pos));
306 self.pos = min(new as uint, self.buf.len());
311 /// Reads from a fixed-size byte slice
316 /// # #![allow(unused_must_use)]
317 /// use std::io::BufReader;
319 /// let buf = [0, 1, 2, 3];
320 /// let mut r = BufReader::new(&buf);
322 /// assert_eq!(r.read_to_end().unwrap(), vec![0, 1, 2, 3]);
324 pub struct BufReader<'a> {
329 impl<'a> BufReader<'a> {
330 /// Creates a new buffered reader which will read the specified buffer
332 pub fn new(buf: &'a [u8]) -> BufReader<'a> {
339 /// Tests whether this reader has read all bytes in its buffer.
341 /// If `true`, then this will no longer return bytes from `read`.
343 pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
346 impl<'a> Reader for BufReader<'a> {
348 fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
349 if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
351 let write_len = min(buf.len(), self.buf.len() - self.pos);
353 let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
354 let output = buf.slice_to_mut(write_len);
355 assert_eq!(input.len(), output.len());
356 slice::bytes::copy_memory(output, input);
358 self.pos += write_len;
359 assert!(self.pos <= self.buf.len());
361 return Ok(write_len);
365 impl<'a> Seek for BufReader<'a> {
367 fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
370 fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
371 let new = try!(combine(style, self.pos, self.buf.len(), pos));
372 self.pos = new as uint;
377 impl<'a> Buffer for BufReader<'a> {
379 fn fill_buf(&mut self) -> IoResult<&[u8]> {
380 if self.pos < self.buf.len() {
381 Ok(self.buf.index(&(self.pos..)))
383 Err(io::standard_error(io::EndOfFile))
388 fn consume(&mut self, amt: uint) { self.pos += amt; }
393 extern crate "test" as test_crate;
394 use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
395 use prelude::v1::{Ok, Err, range, Vec, Buffer, AsSlice, SliceExt};
396 use prelude::v1::{IteratorExt, Index};
399 use self::test_crate::Bencher;
403 fn test_vec_writer() {
404 let mut writer = Vec::new();
405 writer.write(&[0]).unwrap();
406 writer.write(&[1, 2, 3]).unwrap();
407 writer.write(&[4, 5, 6, 7]).unwrap();
408 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
409 assert_eq!(writer.as_slice(), b);
413 fn test_mem_writer() {
414 let mut writer = MemWriter::new();
415 writer.write(&[0]).unwrap();
416 writer.write(&[1, 2, 3]).unwrap();
417 writer.write(&[4, 5, 6, 7]).unwrap();
418 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
419 assert_eq!(writer.get_ref(), b);
423 fn test_buf_writer() {
424 let mut buf = [0 as u8; 9];
426 let mut writer = BufWriter::new(&mut buf);
427 assert_eq!(writer.tell(), Ok(0));
428 writer.write(&[0]).unwrap();
429 assert_eq!(writer.tell(), Ok(1));
430 writer.write(&[1, 2, 3]).unwrap();
431 writer.write(&[4, 5, 6, 7]).unwrap();
432 assert_eq!(writer.tell(), Ok(8));
433 writer.write(&[]).unwrap();
434 assert_eq!(writer.tell(), Ok(8));
436 assert_eq!(writer.write(&[8, 9]).unwrap_err().kind, io::ShortWrite(1));
437 assert_eq!(writer.write(&[10]).unwrap_err().kind, io::EndOfFile);
439 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
444 fn test_buf_writer_seek() {
445 let mut buf = [0 as u8; 8];
447 let mut writer = BufWriter::new(&mut buf);
448 assert_eq!(writer.tell(), Ok(0));
449 writer.write(&[1]).unwrap();
450 assert_eq!(writer.tell(), Ok(1));
452 writer.seek(2, SeekSet).unwrap();
453 assert_eq!(writer.tell(), Ok(2));
454 writer.write(&[2]).unwrap();
455 assert_eq!(writer.tell(), Ok(3));
457 writer.seek(-2, SeekCur).unwrap();
458 assert_eq!(writer.tell(), Ok(1));
459 writer.write(&[3]).unwrap();
460 assert_eq!(writer.tell(), Ok(2));
462 writer.seek(-1, SeekEnd).unwrap();
463 assert_eq!(writer.tell(), Ok(7));
464 writer.write(&[4]).unwrap();
465 assert_eq!(writer.tell(), Ok(8));
468 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
473 fn test_buf_writer_error() {
474 let mut buf = [0 as u8; 2];
475 let mut writer = BufWriter::new(&mut buf);
476 writer.write(&[0]).unwrap();
478 match writer.write(&[0, 0]) {
480 Err(e) => assert_eq!(e.kind, io::ShortWrite(1)),
485 fn test_mem_reader() {
486 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
488 assert_eq!(reader.read(&mut buf), Ok(0));
489 assert_eq!(reader.tell(), Ok(0));
491 assert_eq!(reader.read(&mut buf), Ok(1));
492 assert_eq!(reader.tell(), Ok(1));
495 let mut buf = [0; 4];
496 assert_eq!(reader.read(&mut buf), Ok(4));
497 assert_eq!(reader.tell(), Ok(5));
498 let b: &[_] = &[1, 2, 3, 4];
500 assert_eq!(reader.read(&mut buf), Ok(3));
501 let b: &[_] = &[5, 6, 7];
502 assert_eq!(buf.index(&(0..3)), b);
503 assert!(reader.read(&mut buf).is_err());
504 let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
505 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
506 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
507 assert!(reader.read(&mut buf).is_err());
511 fn test_slice_reader() {
512 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
513 let mut reader = &mut in_buf.as_slice();
515 assert_eq!(reader.read(&mut buf), Ok(0));
517 assert_eq!(reader.read(&mut buf), Ok(1));
518 assert_eq!(reader.len(), 7);
520 assert_eq!(buf.as_slice(), b);
521 let mut buf = [0; 4];
522 assert_eq!(reader.read(&mut buf), Ok(4));
523 assert_eq!(reader.len(), 3);
524 let b: &[_] = &[1, 2, 3, 4];
525 assert_eq!(buf.as_slice(), b);
526 assert_eq!(reader.read(&mut buf), Ok(3));
527 let b: &[_] = &[5, 6, 7];
528 assert_eq!(buf.index(&(0..3)), b);
529 assert!(reader.read(&mut buf).is_err());
530 let mut reader = &mut in_buf.as_slice();
531 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
532 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
533 assert!(reader.read(&mut buf).is_err());
537 fn test_buf_reader() {
538 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
539 let mut reader = BufReader::new(in_buf.as_slice());
541 assert_eq!(reader.read(&mut buf), Ok(0));
542 assert_eq!(reader.tell(), Ok(0));
544 assert_eq!(reader.read(&mut buf), Ok(1));
545 assert_eq!(reader.tell(), Ok(1));
548 let mut buf = [0; 4];
549 assert_eq!(reader.read(&mut buf), Ok(4));
550 assert_eq!(reader.tell(), Ok(5));
551 let b: &[_] = &[1, 2, 3, 4];
553 assert_eq!(reader.read(&mut buf), Ok(3));
554 let b: &[_] = &[5, 6, 7];
555 assert_eq!(buf.index(&(0..3)), b);
556 assert!(reader.read(&mut buf).is_err());
557 let mut reader = BufReader::new(in_buf.as_slice());
558 assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
559 assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
560 assert!(reader.read(&mut buf).is_err());
564 fn test_read_char() {
565 let b = b"Vi\xE1\xBB\x87t";
566 let mut r = BufReader::new(b);
567 assert_eq!(r.read_char(), Ok('V'));
568 assert_eq!(r.read_char(), Ok('i'));
569 assert_eq!(r.read_char(), Ok('ệ'));
570 assert_eq!(r.read_char(), Ok('t'));
571 assert!(r.read_char().is_err());
575 fn test_read_bad_char() {
577 let mut r = BufReader::new(b);
578 assert!(r.read_char().is_err());
582 fn test_write_strings() {
583 let mut writer = MemWriter::new();
584 writer.write_str("testing").unwrap();
585 writer.write_line("testing").unwrap();
586 writer.write_str("testing").unwrap();
587 let mut r = BufReader::new(writer.get_ref());
588 assert_eq!(r.read_to_string().unwrap(), "testingtesting\ntesting");
592 fn test_write_char() {
593 let mut writer = MemWriter::new();
594 writer.write_char('a').unwrap();
595 writer.write_char('\n').unwrap();
596 writer.write_char('ệ').unwrap();
597 let mut r = BufReader::new(writer.get_ref());
598 assert_eq!(r.read_to_string().unwrap(), "a\nệ");
602 fn test_read_whole_string_bad() {
604 let mut r = BufReader::new(&buf);
605 match r.read_to_string() {
614 let mut r = BufReader::new(&buf);
615 r.seek(10, SeekSet).unwrap();
616 assert!(r.read(&mut []).is_err());
618 let mut r = MemReader::new(vec!(10));
619 r.seek(10, SeekSet).unwrap();
620 assert!(r.read(&mut []).is_err());
623 let mut r = BufWriter::new(&mut buf);
624 r.seek(10, SeekSet).unwrap();
625 assert!(r.write(&[3]).is_err());
631 let mut r = BufReader::new(&buf);
632 assert!(r.seek(-1, SeekSet).is_err());
634 let mut r = MemReader::new(vec!(10));
635 assert!(r.seek(-1, SeekSet).is_err());
638 let mut r = BufWriter::new(&mut buf);
639 assert!(r.seek(-1, SeekSet).is_err());
643 fn io_read_at_least() {
644 let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
645 let mut buf = [0; 3];
646 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
647 let b: &[_] = &[1, 2, 3];
649 assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
651 assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
652 let b: &[_] = &[4, 5, 6];
654 assert!(r.read_at_least(buf.len(), &mut buf).is_err());
655 let b: &[_] = &[7, 8, 6];
659 fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) {
660 let src: Vec<u8> = repeat(5).take(len).collect();
662 b.bytes = (times * len) as u64;
664 let mut wr = MemWriter::new();
665 for _ in range(0, times) {
666 wr.write(src.as_slice()).unwrap();
669 let v = wr.into_inner();
670 assert_eq!(v.len(), times * len);
671 assert!(v.iter().all(|x| *x == 5));
676 fn bench_mem_writer_001_0000(b: &mut Bencher) {
677 do_bench_mem_writer(b, 1, 0)
681 fn bench_mem_writer_001_0010(b: &mut Bencher) {
682 do_bench_mem_writer(b, 1, 10)
686 fn bench_mem_writer_001_0100(b: &mut Bencher) {
687 do_bench_mem_writer(b, 1, 100)
691 fn bench_mem_writer_001_1000(b: &mut Bencher) {
692 do_bench_mem_writer(b, 1, 1000)
696 fn bench_mem_writer_100_0000(b: &mut Bencher) {
697 do_bench_mem_writer(b, 100, 0)
701 fn bench_mem_writer_100_0010(b: &mut Bencher) {
702 do_bench_mem_writer(b, 100, 10)
706 fn bench_mem_writer_100_0100(b: &mut Bencher) {
707 do_bench_mem_writer(b, 100, 100)
711 fn bench_mem_writer_100_1000(b: &mut Bencher) {
712 do_bench_mem_writer(b, 100, 1000)
716 fn bench_mem_reader(b: &mut Bencher) {
718 let buf = [5 as u8; 100].to_vec();
720 let mut rdr = MemReader::new(buf);
721 for _i in range(0u, 10) {
722 let mut buf = [0 as u8; 10];
723 rdr.read(&mut buf).unwrap();
724 assert_eq!(buf.as_slice(), [5; 10].as_slice());
731 fn bench_buf_writer(b: &mut Bencher) {
733 let mut buf = [0 as u8; 100];
735 let mut wr = BufWriter::new(&mut buf);
736 for _i in range(0u, 10) {
737 wr.write(&[5; 10]).unwrap();
740 assert_eq!(buf.as_slice(), [5; 100].as_slice());
745 fn bench_buf_reader(b: &mut Bencher) {
747 let buf = [5 as u8; 100];
749 let mut rdr = BufReader::new(&buf);
750 for _i in range(0u, 10) {
751 let mut buf = [0 as u8; 10];
752 rdr.read(&mut buf).unwrap();
753 assert_eq!(buf, [5; 10]);