forked from M-Labs/artiq
Rust: import core_io crate into libstd_artiq.
Unfortunately the crate does not work out of the box with custom Rust builds, and forking it makes little sense over just embedding it here. See https://github.com/jethrogb/rust-core_io/issues/2.
This commit is contained in:
whitequark
parent
52f935dcfb
commit
1c7e1dd645
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,572 @@
|
||||||
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
||||||
|
// file at the top-level directory of this distribution and at
|
||||||
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||||
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||||
|
// option. This file may not be copied, modified, or distributed
|
||||||
|
// except according to those terms.
|
||||||
|
|
||||||
|
use core::prelude::v1::*;
|
||||||
|
use io::prelude::*;
|
||||||
|
|
||||||
|
use core::cmp;
|
||||||
|
use io::{self, SeekFrom, Error, ErrorKind};
|
||||||
|
|
||||||
|
/// A `Cursor` wraps another type and provides it with a
|
||||||
|
/// [`Seek`](trait.Seek.html) implementation.
|
||||||
|
///
|
||||||
|
/// Cursors are typically used with in-memory buffers to allow them to
|
||||||
|
/// implement `Read` and/or `Write`, allowing these buffers to be used
|
||||||
|
/// anywhere you might use a reader or writer that does actual I/O.
|
||||||
|
///
|
||||||
|
/// The standard library implements some I/O traits on various types which
|
||||||
|
/// are commonly used as a buffer, like `Cursor<Vec<u8>>` and `Cursor<&[u8]>`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// We may want to write bytes to a [`File`][file] in our production
|
||||||
|
/// code, but use an in-memory buffer in our tests. We can do this with
|
||||||
|
/// `Cursor`:
|
||||||
|
///
|
||||||
|
/// [file]: ../fs/struct.File.html
|
||||||
|
///
|
||||||
|
/// ```no_run
|
||||||
|
/// use std::io::prelude::*;
|
||||||
|
/// use std::io::{self, SeekFrom};
|
||||||
|
/// use std::fs::File;
|
||||||
|
///
|
||||||
|
/// // a library function we've written
|
||||||
|
/// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
|
||||||
|
/// try!(writer.seek(SeekFrom::End(-10)));
|
||||||
|
///
|
||||||
|
/// for i in 0..10 {
|
||||||
|
/// try!(writer.write(&[i]));
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// // all went well
|
||||||
|
/// Ok(())
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// # fn foo() -> io::Result<()> {
|
||||||
|
/// // Here's some code that uses this library function.
|
||||||
|
/// //
|
||||||
|
/// // We might want to use a BufReader here for efficiency, but let's
|
||||||
|
/// // keep this example focused.
|
||||||
|
/// let mut file = try!(File::create("foo.txt"));
|
||||||
|
///
|
||||||
|
/// try!(write_ten_bytes_at_end(&mut file));
|
||||||
|
/// # Ok(())
|
||||||
|
/// # }
|
||||||
|
///
|
||||||
|
/// // now let's write a test
|
||||||
|
/// #[test]
|
||||||
|
/// fn test_writes_bytes() {
|
||||||
|
/// // setting up a real File is much more slow than an in-memory buffer,
|
||||||
|
/// // let's use a cursor instead
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
/// let mut buff = Cursor::new(vec![0; 15]);
|
||||||
|
///
|
||||||
|
/// write_ten_bytes_at_end(&mut buff).unwrap();
|
||||||
|
///
|
||||||
|
/// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub struct Cursor<T> {
|
||||||
|
inner: T,
|
||||||
|
pos: u64,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> Cursor<T> {
|
||||||
|
/// Creates a new cursor wrapping the provided underlying I/O object.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
/// ```
|
||||||
|
pub fn new(inner: T) -> Cursor<T> {
|
||||||
|
Cursor { pos: 0, inner: inner }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Consumes this cursor, returning the underlying value.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
///
|
||||||
|
/// let vec = buff.into_inner();
|
||||||
|
/// ```
|
||||||
|
pub fn into_inner(self) -> T { self.inner }
|
||||||
|
|
||||||
|
/// Gets a reference to the underlying value in this cursor.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
///
|
||||||
|
/// let reference = buff.get_ref();
|
||||||
|
/// ```
|
||||||
|
pub fn get_ref(&self) -> &T { &self.inner }
|
||||||
|
|
||||||
|
/// Gets a mutable reference to the underlying value in this cursor.
|
||||||
|
///
|
||||||
|
/// Care should be taken to avoid modifying the internal I/O state of the
|
||||||
|
/// underlying value as it may corrupt this cursor's position.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let mut buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
///
|
||||||
|
/// let reference = buff.get_mut();
|
||||||
|
/// ```
|
||||||
|
pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
|
||||||
|
|
||||||
|
/// Returns the current position of this cursor.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
/// use std::io::prelude::*;
|
||||||
|
/// use std::io::SeekFrom;
|
||||||
|
///
|
||||||
|
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
|
||||||
|
///
|
||||||
|
/// assert_eq!(buff.position(), 0);
|
||||||
|
///
|
||||||
|
/// buff.seek(SeekFrom::Current(2)).unwrap();
|
||||||
|
/// assert_eq!(buff.position(), 2);
|
||||||
|
///
|
||||||
|
/// buff.seek(SeekFrom::Current(-1)).unwrap();
|
||||||
|
/// assert_eq!(buff.position(), 1);
|
||||||
|
/// ```
|
||||||
|
pub fn position(&self) -> u64 { self.pos }
|
||||||
|
|
||||||
|
/// Sets the position of this cursor.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
|
||||||
|
///
|
||||||
|
/// assert_eq!(buff.position(), 0);
|
||||||
|
///
|
||||||
|
/// buff.set_position(2);
|
||||||
|
/// assert_eq!(buff.position(), 2);
|
||||||
|
///
|
||||||
|
/// buff.set_position(4);
|
||||||
|
/// assert_eq!(buff.position(), 4);
|
||||||
|
/// ```
|
||||||
|
pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
|
||||||
|
fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
|
||||||
|
let pos = match style {
|
||||||
|
SeekFrom::Start(n) => { self.pos = n; return Ok(n) }
|
||||||
|
SeekFrom::End(n) => self.inner.as_ref().len() as i64 + n,
|
||||||
|
SeekFrom::Current(n) => self.pos as i64 + n,
|
||||||
|
};
|
||||||
|
|
||||||
|
if pos < 0 {
|
||||||
|
Err(Error::new(ErrorKind::InvalidInput,
|
||||||
|
"invalid seek to a negative position"))
|
||||||
|
} else {
|
||||||
|
self.pos = pos as u64;
|
||||||
|
Ok(self.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
let n = Read::read(&mut self.fill_buf()?, buf)?;
|
||||||
|
self.pos += n as u64;
|
||||||
|
Ok(n)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||||||
|
let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
|
||||||
|
Ok(&self.inner.as_ref()[(amt as usize)..])
|
||||||
|
}
|
||||||
|
fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Write for Cursor<&'a mut [u8]> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
|
||||||
|
let pos = cmp::min(self.pos, self.inner.len() as u64);
|
||||||
|
let amt = (&mut self.inner[(pos as usize)..]).write(data)?;
|
||||||
|
self.pos += amt as u64;
|
||||||
|
Ok(amt)
|
||||||
|
}
|
||||||
|
fn flush(&mut self) -> io::Result<()> { Ok(()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Write for Cursor<Vec<u8>> {
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
// Make sure the internal buffer is as least as big as where we
|
||||||
|
// currently are
|
||||||
|
let pos = self.position();
|
||||||
|
let amt = pos.saturating_sub(self.inner.len() as u64);
|
||||||
|
// use `resize` so that the zero filling is as efficient as possible
|
||||||
|
let len = self.inner.len();
|
||||||
|
self.inner.resize(len + amt as usize, 0);
|
||||||
|
|
||||||
|
// Figure out what bytes will be used to overwrite what's currently
|
||||||
|
// there (left), and what will be appended on the end (right)
|
||||||
|
{
|
||||||
|
let pos = pos as usize;
|
||||||
|
let space = self.inner.len() - pos;
|
||||||
|
let (left, right) = buf.split_at(cmp::min(space, buf.len()));
|
||||||
|
self.inner[pos..pos + left.len()].copy_from_slice(left);
|
||||||
|
self.inner.extend_from_slice(right);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Bump us forward
|
||||||
|
self.set_position(pos + buf.len() as u64);
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
fn flush(&mut self) -> io::Result<()> { Ok(()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Write for Cursor<Box<[u8]>> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
let pos = cmp::min(self.pos, self.inner.len() as u64);
|
||||||
|
let amt = (&mut self.inner[(pos as usize)..]).write(buf)?;
|
||||||
|
self.pos += amt as u64;
|
||||||
|
Ok(amt)
|
||||||
|
}
|
||||||
|
fn flush(&mut self) -> io::Result<()> { Ok(()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use io::prelude::*;
|
||||||
|
use io::{Cursor, SeekFrom};
|
||||||
|
use vec::Vec;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_vec_writer() {
|
||||||
|
let mut writer = Vec::new();
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
assert_eq!(writer, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_mem_writer() {
|
||||||
|
let mut writer = Cursor::new(Vec::new());
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_box_slice_writer() {
|
||||||
|
let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
assert_eq!(writer.write(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
|
||||||
|
assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[10]).unwrap(), 0);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||||||
|
assert_eq!(&**writer.get_ref(), b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_writer() {
|
||||||
|
let mut buf = [0 as u8; 9];
|
||||||
|
{
|
||||||
|
let mut writer = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
assert_eq!(writer.write(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
|
||||||
|
assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[10]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_writer_seek() {
|
||||||
|
let mut buf = [0 as u8; 8];
|
||||||
|
{
|
||||||
|
let mut writer = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[1]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
|
||||||
|
assert_eq!(writer.position(), 2);
|
||||||
|
assert_eq!(writer.write(&[2]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 3);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[3]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 2);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
|
||||||
|
assert_eq!(writer.position(), 7);
|
||||||
|
assert_eq!(writer.write(&[4]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
|
||||||
|
}
|
||||||
|
let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_writer_error() {
|
||||||
|
let mut buf = [0 as u8; 2];
|
||||||
|
let mut writer = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_mem_reader() {
|
||||||
|
let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.position(), 5);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_boxed_slice_reader() {
|
||||||
|
let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7).into_boxed_slice());
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.position(), 5);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn read_to_end() {
|
||||||
|
let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
|
||||||
|
let mut v = Vec::new();
|
||||||
|
reader.read_to_end(&mut v).unwrap();
|
||||||
|
assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_slice_reader() {
|
||||||
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
let mut reader = &mut &in_buf[..];
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.len(), 7);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(&buf[..], b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.len(), 3);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(&buf[..], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_reader() {
|
||||||
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
let mut reader = Cursor::new(&in_buf[..]);
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.position(), 5);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_read_char() {
|
||||||
|
let b = &b"Vi\xE1\xBB\x87t"[..];
|
||||||
|
let mut c = Cursor::new(b).chars();
|
||||||
|
assert_eq!(c.next().unwrap().unwrap(), 'V');
|
||||||
|
assert_eq!(c.next().unwrap().unwrap(), 'i');
|
||||||
|
assert_eq!(c.next().unwrap().unwrap(), 'ệ');
|
||||||
|
assert_eq!(c.next().unwrap().unwrap(), 't');
|
||||||
|
assert!(c.next().is_none());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_read_bad_char() {
|
||||||
|
let b = &b"\x80"[..];
|
||||||
|
let mut c = Cursor::new(b).chars();
|
||||||
|
assert!(c.next().unwrap().is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn seek_past_end() {
|
||||||
|
let buf = [0xff];
|
||||||
|
let mut r = Cursor::new(&buf[..]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.read(&mut [0]).unwrap(), 0);
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec!(10));
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.read(&mut [0]).unwrap(), 0);
|
||||||
|
|
||||||
|
let mut buf = [0];
|
||||||
|
let mut r = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.write(&[3]).unwrap(), 0);
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec![10].into_boxed_slice());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.write(&[3]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn seek_before_0() {
|
||||||
|
let buf = [0xff];
|
||||||
|
let mut r = Cursor::new(&buf[..]);
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec!(10));
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
|
||||||
|
let mut buf = [0];
|
||||||
|
let mut r = Cursor::new(&mut buf[..]);
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec!(10).into_boxed_slice());
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_seekable_mem_writer() {
|
||||||
|
let mut writer = Cursor::new(Vec::<u8>::new());
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
|
||||||
|
let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
|
||||||
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
|
||||||
|
assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
|
||||||
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
|
||||||
|
assert_eq!(writer.write(&[1]).unwrap(), 1);
|
||||||
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn vec_seek_past_end() {
|
||||||
|
let mut r = Cursor::new(Vec::new());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.write(&[3]).unwrap(), 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn vec_seek_before_0() {
|
||||||
|
let mut r = Cursor::new(Vec::new());
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,309 @@
|
||||||
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
||||||
|
// file at the top-level directory of this distribution and at
|
||||||
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||||
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||||
|
// option. This file may not be copied, modified, or distributed
|
||||||
|
// except according to those terms.
|
||||||
|
|
||||||
|
use alloc::boxed::Box;
|
||||||
|
use core::convert::Into;
|
||||||
|
use core::fmt;
|
||||||
|
use core::marker::{Send, Sync};
|
||||||
|
use core::option::Option::{self, Some, None};
|
||||||
|
use core::result;
|
||||||
|
use collections::string::String;
|
||||||
|
|
||||||
|
/// A specialized [`Result`](../result/enum.Result.html) type for I/O
|
||||||
|
/// operations.
|
||||||
|
///
|
||||||
|
/// This type is broadly used across `std::io` for any operation which may
|
||||||
|
/// produce an error.
|
||||||
|
///
|
||||||
|
/// This typedef is generally used to avoid writing out `io::Error` directly and
|
||||||
|
/// is otherwise a direct mapping to `Result`.
|
||||||
|
///
|
||||||
|
/// While usual Rust style is to import types directly, aliases of `Result`
|
||||||
|
/// often are not, to make it easier to distinguish between them. `Result` is
|
||||||
|
/// generally assumed to be `std::result::Result`, and so users of this alias
|
||||||
|
/// will generally use `io::Result` instead of shadowing the prelude's import
|
||||||
|
/// of `std::result::Result`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// A convenience function that bubbles an `io::Result` to its caller:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io;
|
||||||
|
///
|
||||||
|
/// fn get_string() -> io::Result<String> {
|
||||||
|
/// let mut buffer = String::new();
|
||||||
|
///
|
||||||
|
/// try!(io::stdin().read_line(&mut buffer));
|
||||||
|
///
|
||||||
|
/// Ok(buffer)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub type Result<T> = result::Result<T, Error>;
|
||||||
|
|
||||||
|
/// The error type for I/O operations of the `Read`, `Write`, `Seek`, and
|
||||||
|
/// associated traits.
|
||||||
|
///
|
||||||
|
/// Errors mostly originate from the underlying OS, but custom instances of
|
||||||
|
/// `Error` can be created with crafted error messages and a particular value of
|
||||||
|
/// `ErrorKind`.
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Error {
|
||||||
|
repr: Repr,
|
||||||
|
}
|
||||||
|
|
||||||
|
enum Repr {
|
||||||
|
Os(i32),
|
||||||
|
|
||||||
|
Custom(Box<Custom>),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct Custom {
|
||||||
|
kind: ErrorKind,
|
||||||
|
error: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A list specifying general categories of I/O error.
|
||||||
|
///
|
||||||
|
/// This list is intended to grow over time and it is not recommended to
|
||||||
|
/// exhaustively match against it.
|
||||||
|
#[derive(Copy, PartialEq, Eq, Clone, Debug)]
|
||||||
|
#[allow(deprecated)]
|
||||||
|
pub enum ErrorKind {
|
||||||
|
/// An entity was not found, often a file.
|
||||||
|
NotFound,
|
||||||
|
/// The operation lacked the necessary privileges to complete.
|
||||||
|
PermissionDenied,
|
||||||
|
/// The connection was refused by the remote server.
|
||||||
|
ConnectionRefused,
|
||||||
|
/// The connection was reset by the remote server.
|
||||||
|
ConnectionReset,
|
||||||
|
/// The connection was aborted (terminated) by the remote server.
|
||||||
|
ConnectionAborted,
|
||||||
|
/// The network operation failed because it was not connected yet.
|
||||||
|
NotConnected,
|
||||||
|
/// A socket address could not be bound because the address is already in
|
||||||
|
/// use elsewhere.
|
||||||
|
AddrInUse,
|
||||||
|
/// A nonexistent interface was requested or the requested address was not
|
||||||
|
/// local.
|
||||||
|
AddrNotAvailable,
|
||||||
|
/// The operation failed because a pipe was closed.
|
||||||
|
BrokenPipe,
|
||||||
|
/// An entity already exists, often a file.
|
||||||
|
AlreadyExists,
|
||||||
|
/// The operation needs to block to complete, but the blocking operation was
|
||||||
|
/// requested to not occur.
|
||||||
|
WouldBlock,
|
||||||
|
/// A parameter was incorrect.
|
||||||
|
InvalidInput,
|
||||||
|
/// Data not valid for the operation were encountered.
|
||||||
|
///
|
||||||
|
/// Unlike `InvalidInput`, this typically means that the operation
|
||||||
|
/// parameters were valid, however the error was caused by malformed
|
||||||
|
/// input data.
|
||||||
|
///
|
||||||
|
/// For example, a function that reads a file into a string will error with
|
||||||
|
/// `InvalidData` if the file's contents are not valid UTF-8.
|
||||||
|
InvalidData,
|
||||||
|
/// The I/O operation's timeout expired, causing it to be canceled.
|
||||||
|
TimedOut,
|
||||||
|
/// An error returned when an operation could not be completed because a
|
||||||
|
/// call to `write` returned `Ok(0)`.
|
||||||
|
///
|
||||||
|
/// This typically means that an operation could only succeed if it wrote a
|
||||||
|
/// particular number of bytes but only a smaller number of bytes could be
|
||||||
|
/// written.
|
||||||
|
WriteZero,
|
||||||
|
/// This operation was interrupted.
|
||||||
|
///
|
||||||
|
/// Interrupted operations can typically be retried.
|
||||||
|
Interrupted,
|
||||||
|
/// Any I/O error not part of this list.
|
||||||
|
Other,
|
||||||
|
|
||||||
|
/// An error returned when an operation could not be completed because an
|
||||||
|
/// "end of file" was reached prematurely.
|
||||||
|
///
|
||||||
|
/// This typically means that an operation could only succeed if it read a
|
||||||
|
/// particular number of bytes but only a smaller number of bytes could be
|
||||||
|
/// read.
|
||||||
|
UnexpectedEof,
|
||||||
|
|
||||||
|
/// Any I/O error not part of this list.
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Error {
|
||||||
|
/// Creates a new I/O error from a known kind of error as well as an
|
||||||
|
/// arbitrary error payload.
|
||||||
|
///
|
||||||
|
/// This function is used to generically create I/O errors which do not
|
||||||
|
/// originate from the OS itself. The `error` argument is an arbitrary
|
||||||
|
/// payload which will be contained in this `Error`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
///
|
||||||
|
/// // errors can be created from strings
|
||||||
|
/// let custom_error = Error::new(ErrorKind::Other, "oh no!");
|
||||||
|
///
|
||||||
|
/// // errors can also be created from other errors
|
||||||
|
/// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
|
||||||
|
/// ```
|
||||||
|
pub fn new<E>(kind: ErrorKind, error: E) -> Error
|
||||||
|
where E: Into<String>
|
||||||
|
{
|
||||||
|
Self::_new(kind, error.into())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn _new(kind: ErrorKind, error: String) -> Error {
|
||||||
|
Error {
|
||||||
|
repr: Repr::Custom(Box::new(Custom {
|
||||||
|
kind: kind,
|
||||||
|
error: error,
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates a new instance of an `Error` from a particular OS error code.
|
||||||
|
pub fn from_raw_os_error(code: i32) -> Error {
|
||||||
|
Error { repr: Repr::Os(code) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the OS error that this error represents (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `last_os_error` or
|
||||||
|
/// `from_raw_os_error`, then this function will return `Some`, otherwise
|
||||||
|
/// it will return `None`.
|
||||||
|
pub fn raw_os_error(&self) -> Option<i32> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(i) => Some(i),
|
||||||
|
Repr::Custom(..) => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a reference to the inner error wrapped by this error (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `new` then this function will
|
||||||
|
/// return `Some`, otherwise it will return `None`.
|
||||||
|
pub fn get_ref(&self) -> Option<&String> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(..) => None,
|
||||||
|
Repr::Custom(ref c) => Some(&c.error),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a mutable reference to the inner error wrapped by this error
|
||||||
|
/// (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `new` then this function will
|
||||||
|
/// return `Some`, otherwise it will return `None`.
|
||||||
|
pub fn get_mut(&mut self) -> Option<&mut String> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(..) => None,
|
||||||
|
Repr::Custom(ref mut c) => Some(&mut c.error),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Consumes the `Error`, returning its inner error (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `new` then this function will
|
||||||
|
/// return `Some`, otherwise it will return `None`.
|
||||||
|
pub fn into_inner(self) -> Option<String> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(..) => None,
|
||||||
|
Repr::Custom(c) => Some(c.error)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the corresponding `ErrorKind` for this error.
|
||||||
|
pub fn kind(&self) -> ErrorKind {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(_code) => ErrorKind::Other,
|
||||||
|
Repr::Custom(ref c) => c.kind,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Debug for Repr {
|
||||||
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
match *self {
|
||||||
|
Repr::Os(ref code) =>
|
||||||
|
fmt.debug_struct("Os").field("code", code).finish(),
|
||||||
|
Repr::Custom(ref c) => fmt.debug_tuple("Custom").field(c).finish(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for Error {
|
||||||
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(code) => {
|
||||||
|
write!(fmt, "os error {}", code)
|
||||||
|
}
|
||||||
|
Repr::Custom(ref c) => c.error.fmt(fmt),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn _assert_error_is_sync_send() {
|
||||||
|
fn _is_sync_send<T: Sync+Send>() {}
|
||||||
|
_is_sync_send::<Error>();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test {
|
||||||
|
use prelude::v1::*;
|
||||||
|
use super::{Error, ErrorKind};
|
||||||
|
use error;
|
||||||
|
use fmt;
|
||||||
|
use sys::os::error_string;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_debug_error() {
|
||||||
|
let code = 6;
|
||||||
|
let msg = error_string(code);
|
||||||
|
let err = Error { repr: super::Repr::Os(code) };
|
||||||
|
let expected = format!("Error {{ repr: Os {{ code: {:?}, message: {:?} }} }}", code, msg);
|
||||||
|
assert_eq!(format!("{:?}", err), expected);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_downcasting() {
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct TestError;
|
||||||
|
|
||||||
|
impl fmt::Display for TestError {
|
||||||
|
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl error::Error for TestError {
|
||||||
|
fn description(&self) -> &str {
|
||||||
|
"asdf"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// we have to call all of these UFCS style right now since method
|
||||||
|
// resolution won't implicitly drop the Send+Sync bounds
|
||||||
|
let mut err = Error::new(ErrorKind::Other, TestError);
|
||||||
|
assert!(err.get_ref().unwrap().is::<TestError>());
|
||||||
|
assert_eq!("asdf", err.get_ref().unwrap().description());
|
||||||
|
assert!(err.get_mut().unwrap().is::<TestError>());
|
||||||
|
let extracted = err.into_inner().unwrap();
|
||||||
|
extracted.downcast::<TestError>().unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,289 @@
|
||||||
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
||||||
|
// file at the top-level directory of this distribution and at
|
||||||
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||||
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||||
|
// option. This file may not be copied, modified, or distributed
|
||||||
|
// except according to those terms.
|
||||||
|
|
||||||
|
use alloc::boxed::Box;
|
||||||
|
use core::cmp;
|
||||||
|
use io::{self, SeekFrom, Read, Write, Seek, Error, ErrorKind};
|
||||||
|
use io::BufRead;
|
||||||
|
use core::fmt;
|
||||||
|
use core::mem;
|
||||||
|
use collections::string::String;
|
||||||
|
use collections::vec::Vec;
|
||||||
|
|
||||||
|
// =============================================================================
|
||||||
|
// Forwarding implementations
|
||||||
|
|
||||||
|
impl<'a, R: Read + ?Sized> Read for &'a mut R {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
(**self).read(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_to_end(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_to_string(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||||||
|
(**self).read_exact(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'a, W: Write + ?Sized> Write for &'a mut W {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> { (**self).flush() }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
|
||||||
|
(**self).write_all(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
|
||||||
|
(**self).write_fmt(fmt)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<'a, S: Seek + ?Sized> Seek for &'a mut S {
|
||||||
|
#[inline]
|
||||||
|
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {
|
||||||
|
#[inline]
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn consume(&mut self, amt: usize) { (**self).consume(amt) }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_until(byte, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_line(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl<R: Read + ?Sized> Read for Box<R> {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
(**self).read(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_to_end(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_to_string(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||||||
|
(**self).read_exact(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<W: Write + ?Sized> Write for Box<W> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> { (**self).flush() }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
|
||||||
|
(**self).write_all(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
|
||||||
|
(**self).write_fmt(fmt)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<S: Seek + ?Sized> Seek for Box<S> {
|
||||||
|
#[inline]
|
||||||
|
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<B: BufRead + ?Sized> BufRead for Box<B> {
|
||||||
|
#[inline]
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn consume(&mut self, amt: usize) { (**self).consume(amt) }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_until(byte, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_line(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// =============================================================================
|
||||||
|
// In-memory buffer implementations
|
||||||
|
|
||||||
|
impl<'a> Read for &'a [u8] {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
let amt = cmp::min(buf.len(), self.len());
|
||||||
|
let (a, b) = self.split_at(amt);
|
||||||
|
buf[..amt].copy_from_slice(a);
|
||||||
|
*self = b;
|
||||||
|
Ok(amt)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||||||
|
if buf.len() > self.len() {
|
||||||
|
return Err(Error::new(ErrorKind::UnexpectedEof,
|
||||||
|
"failed to fill whole buffer"));
|
||||||
|
}
|
||||||
|
let (a, b) = self.split_at(buf.len());
|
||||||
|
buf.copy_from_slice(a);
|
||||||
|
*self = b;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl<'a> BufRead for &'a [u8] {
|
||||||
|
#[inline]
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn consume(&mut self, amt: usize) { *self = &self[amt..]; }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Write for &'a mut [u8] {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
|
||||||
|
let amt = cmp::min(data.len(), self.len());
|
||||||
|
let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
|
||||||
|
a.copy_from_slice(&data[..amt]);
|
||||||
|
*self = b;
|
||||||
|
Ok(amt)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
|
||||||
|
if self.write(data)? == data.len() {
|
||||||
|
Ok(())
|
||||||
|
} else {
|
||||||
|
Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> { Ok(()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl Write for Vec<u8> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
self.extend_from_slice(buf);
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
|
||||||
|
self.extend_from_slice(buf);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> { Ok(()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use io::prelude::*;
|
||||||
|
use vec::Vec;
|
||||||
|
use test;
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_read_slice(b: &mut test::Bencher) {
|
||||||
|
let buf = [5; 1024];
|
||||||
|
let mut dst = [0; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut rd = &buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = rd.read(&mut dst);
|
||||||
|
test::black_box(&dst);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_write_slice(b: &mut test::Bencher) {
|
||||||
|
let mut buf = [0; 1024];
|
||||||
|
let src = [5; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut wr = &mut buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = wr.write_all(&src);
|
||||||
|
test::black_box(&wr);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_read_vec(b: &mut test::Bencher) {
|
||||||
|
let buf = vec![5; 1024];
|
||||||
|
let mut dst = [0; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut rd = &buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = rd.read(&mut dst);
|
||||||
|
test::black_box(&dst);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_write_vec(b: &mut test::Bencher) {
|
||||||
|
let mut buf = Vec::with_capacity(1024);
|
||||||
|
let src = [5; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut wr = &mut buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = wr.write_all(&src);
|
||||||
|
test::black_box(&wr);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,297 @@
|
||||||
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
||||||
|
// file at the top-level directory of this distribution and at
|
||||||
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||||
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||||
|
// option. This file may not be copied, modified, or distributed
|
||||||
|
// except according to those terms.
|
||||||
|
//
|
||||||
|
// Original implementation taken from rust-memchr
|
||||||
|
// Copyright 2015 Andrew Gallant, bluss and Nicolas Koch
|
||||||
|
|
||||||
|
pub use self::fallback::{memchr,memrchr};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
mod fallback {
|
||||||
|
use core::cmp;
|
||||||
|
use core::mem;
|
||||||
|
|
||||||
|
const LO_U64: u64 = 0x0101010101010101;
|
||||||
|
const HI_U64: u64 = 0x8080808080808080;
|
||||||
|
|
||||||
|
// use truncation
|
||||||
|
const LO_USIZE: usize = LO_U64 as usize;
|
||||||
|
const HI_USIZE: usize = HI_U64 as usize;
|
||||||
|
|
||||||
|
/// Return `true` if `x` contains any zero byte.
|
||||||
|
///
|
||||||
|
/// From *Matters Computational*, J. Arndt
|
||||||
|
///
|
||||||
|
/// "The idea is to subtract one from each of the bytes and then look for
|
||||||
|
/// bytes where the borrow propagated all the way to the most significant
|
||||||
|
/// bit."
|
||||||
|
#[inline]
|
||||||
|
fn contains_zero_byte(x: usize) -> bool {
|
||||||
|
x.wrapping_sub(LO_USIZE) & !x & HI_USIZE != 0
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_pointer_width = "32")]
|
||||||
|
#[inline]
|
||||||
|
fn repeat_byte(b: u8) -> usize {
|
||||||
|
let mut rep = (b as usize) << 8 | b as usize;
|
||||||
|
rep = rep << 16 | rep;
|
||||||
|
rep
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_pointer_width = "64")]
|
||||||
|
#[inline]
|
||||||
|
fn repeat_byte(b: u8) -> usize {
|
||||||
|
let mut rep = (b as usize) << 8 | b as usize;
|
||||||
|
rep = rep << 16 | rep;
|
||||||
|
rep = rep << 32 | rep;
|
||||||
|
rep
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return the first index matching the byte `a` in `text`.
|
||||||
|
pub fn memchr(x: u8, text: &[u8]) -> Option<usize> {
|
||||||
|
// Scan for a single byte value by reading two `usize` words at a time.
|
||||||
|
//
|
||||||
|
// Split `text` in three parts
|
||||||
|
// - unaligned initial part, before the first word aligned address in text
|
||||||
|
// - body, scan by 2 words at a time
|
||||||
|
// - the last remaining part, < 2 word size
|
||||||
|
let len = text.len();
|
||||||
|
let ptr = text.as_ptr();
|
||||||
|
let usize_bytes = mem::size_of::<usize>();
|
||||||
|
|
||||||
|
// search up to an aligned boundary
|
||||||
|
let align = (ptr as usize) & (usize_bytes- 1);
|
||||||
|
let mut offset;
|
||||||
|
if align > 0 {
|
||||||
|
offset = cmp::min(usize_bytes - align, len);
|
||||||
|
if let Some(index) = text[..offset].iter().position(|elt| *elt == x) {
|
||||||
|
return Some(index);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
offset = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// search the body of the text
|
||||||
|
let repeated_x = repeat_byte(x);
|
||||||
|
|
||||||
|
if len >= 2 * usize_bytes {
|
||||||
|
while offset <= len - 2 * usize_bytes {
|
||||||
|
unsafe {
|
||||||
|
let u = *(ptr.offset(offset as isize) as *const usize);
|
||||||
|
let v = *(ptr.offset((offset + usize_bytes) as isize) as *const usize);
|
||||||
|
|
||||||
|
// break if there is a matching byte
|
||||||
|
let zu = contains_zero_byte(u ^ repeated_x);
|
||||||
|
let zv = contains_zero_byte(v ^ repeated_x);
|
||||||
|
if zu || zv {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
offset += usize_bytes * 2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// find the byte after the point the body loop stopped
|
||||||
|
text[offset..].iter().position(|elt| *elt == x).map(|i| offset + i)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return the last index matching the byte `a` in `text`.
|
||||||
|
pub fn memrchr(x: u8, text: &[u8]) -> Option<usize> {
|
||||||
|
// Scan for a single byte value by reading two `usize` words at a time.
|
||||||
|
//
|
||||||
|
// Split `text` in three parts
|
||||||
|
// - unaligned tail, after the last word aligned address in text
|
||||||
|
// - body, scan by 2 words at a time
|
||||||
|
// - the first remaining bytes, < 2 word size
|
||||||
|
let len = text.len();
|
||||||
|
let ptr = text.as_ptr();
|
||||||
|
let usize_bytes = mem::size_of::<usize>();
|
||||||
|
|
||||||
|
// search to an aligned boundary
|
||||||
|
let end_align = (ptr as usize + len) & (usize_bytes - 1);
|
||||||
|
let mut offset;
|
||||||
|
if end_align > 0 {
|
||||||
|
offset = len - cmp::min(usize_bytes - end_align, len);
|
||||||
|
if let Some(index) = text[offset..].iter().rposition(|elt| *elt == x) {
|
||||||
|
return Some(offset + index);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
offset = len;
|
||||||
|
}
|
||||||
|
|
||||||
|
// search the body of the text
|
||||||
|
let repeated_x = repeat_byte(x);
|
||||||
|
|
||||||
|
while offset >= 2 * usize_bytes {
|
||||||
|
unsafe {
|
||||||
|
let u = *(ptr.offset(offset as isize - 2 * usize_bytes as isize) as *const usize);
|
||||||
|
let v = *(ptr.offset(offset as isize - usize_bytes as isize) as *const usize);
|
||||||
|
|
||||||
|
// break if there is a matching byte
|
||||||
|
let zu = contains_zero_byte(u ^ repeated_x);
|
||||||
|
let zv = contains_zero_byte(v ^ repeated_x);
|
||||||
|
if zu || zv {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
offset -= 2 * usize_bytes;
|
||||||
|
}
|
||||||
|
|
||||||
|
// find the byte before the point the body loop stopped
|
||||||
|
text[..offset].iter().rposition(|elt| *elt == x)
|
||||||
|
}
|
||||||
|
|
||||||
|
// test fallback implementations on all plattforms
|
||||||
|
#[test]
|
||||||
|
fn matches_one() {
|
||||||
|
assert_eq!(Some(0), memchr(b'a', b"a"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_begin() {
|
||||||
|
assert_eq!(Some(0), memchr(b'a', b"aaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_end() {
|
||||||
|
assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_nul() {
|
||||||
|
assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_past_nul() {
|
||||||
|
assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match_empty() {
|
||||||
|
assert_eq!(None, memchr(b'a', b""));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match() {
|
||||||
|
assert_eq!(None, memchr(b'a', b"xyz"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_one_reversed() {
|
||||||
|
assert_eq!(Some(0), memrchr(b'a', b"a"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_begin_reversed() {
|
||||||
|
assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_end_reversed() {
|
||||||
|
assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_nul_reversed() {
|
||||||
|
assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_past_nul_reversed() {
|
||||||
|
assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match_empty_reversed() {
|
||||||
|
assert_eq!(None, memrchr(b'a', b""));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match_reversed() {
|
||||||
|
assert_eq!(None, memrchr(b'a', b"xyz"));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
// test the implementations for the current plattform
|
||||||
|
use super::{memchr, memrchr};
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_one() {
|
||||||
|
assert_eq!(Some(0), memchr(b'a', b"a"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_begin() {
|
||||||
|
assert_eq!(Some(0), memchr(b'a', b"aaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_end() {
|
||||||
|
assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_nul() {
|
||||||
|
assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_past_nul() {
|
||||||
|
assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match_empty() {
|
||||||
|
assert_eq!(None, memchr(b'a', b""));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match() {
|
||||||
|
assert_eq!(None, memchr(b'a', b"xyz"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_one_reversed() {
|
||||||
|
assert_eq!(Some(0), memrchr(b'a', b"a"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_begin_reversed() {
|
||||||
|
assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_end_reversed() {
|
||||||
|
assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_nul_reversed() {
|
||||||
|
assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn matches_past_nul_reversed() {
|
||||||
|
assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match_empty_reversed() {
|
||||||
|
assert_eq!(None, memrchr(b'a', b""));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn no_match_reversed() {
|
||||||
|
assert_eq!(None, memrchr(b'a', b"xyz"));
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,25 @@
|
||||||
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
||||||
|
// file at the top-level directory of this distribution and at
|
||||||
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||||
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||||
|
// option. This file may not be copied, modified, or distributed
|
||||||
|
// except according to those terms.
|
||||||
|
|
||||||
|
//! The I/O Prelude
|
||||||
|
//!
|
||||||
|
//! The purpose of this module is to alleviate imports of many common I/O traits
|
||||||
|
//! by adding a glob import to the top of I/O heavy modules:
|
||||||
|
//!
|
||||||
|
//! ```
|
||||||
|
//! # #![allow(unused_imports)]
|
||||||
|
//! use std::io::prelude::*;
|
||||||
|
//! ```
|
||||||
|
|
||||||
|
pub use super::{Read, Write, Seek};
|
||||||
|
pub use super::BufRead;
|
||||||
|
|
||||||
|
pub use alloc::boxed::Box;
|
||||||
|
pub use collections::vec::Vec;
|
||||||
|
|
@ -0,0 +1,208 @@
|
||||||
|
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||||
|
// file at the top-level directory of this distribution and at
|
||||||
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||||
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||||
|
// option. This file may not be copied, modified, or distributed
|
||||||
|
// except according to those terms.
|
||||||
|
|
||||||
|
#![allow(missing_copy_implementations)]
|
||||||
|
|
||||||
|
use io::{self, Read, Write, ErrorKind};
|
||||||
|
use io::BufRead;
|
||||||
|
|
||||||
|
/// Copies the entire contents of a reader into a writer.
|
||||||
|
///
|
||||||
|
/// This function will continuously read data from `reader` and then
|
||||||
|
/// write it into `writer` in a streaming fashion until `reader`
|
||||||
|
/// returns EOF.
|
||||||
|
///
|
||||||
|
/// On success, the total number of bytes that were copied from
|
||||||
|
/// `reader` to `writer` is returned.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
///
|
||||||
|
/// This function will return an error immediately if any call to `read` or
|
||||||
|
/// `write` returns an error. All instances of `ErrorKind::Interrupted` are
|
||||||
|
/// handled by this function and the underlying operation is retried.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io;
|
||||||
|
///
|
||||||
|
/// # fn foo() -> io::Result<()> {
|
||||||
|
/// let mut reader: &[u8] = b"hello";
|
||||||
|
/// let mut writer: Vec<u8> = vec![];
|
||||||
|
///
|
||||||
|
/// try!(io::copy(&mut reader, &mut writer));
|
||||||
|
///
|
||||||
|
/// assert_eq!(reader, &writer[..]);
|
||||||
|
/// # Ok(())
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
|
||||||
|
where R: Read, W: Write
|
||||||
|
{
|
||||||
|
let mut buf = [0; super::DEFAULT_BUF_SIZE];
|
||||||
|
let mut written = 0;
|
||||||
|
loop {
|
||||||
|
let len = match reader.read(&mut buf) {
|
||||||
|
Ok(0) => return Ok(written),
|
||||||
|
Ok(len) => len,
|
||||||
|
Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
|
||||||
|
Err(e) => return Err(e),
|
||||||
|
};
|
||||||
|
writer.write_all(&buf[..len])?;
|
||||||
|
written += len as u64;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A reader which is always at EOF.
|
||||||
|
///
|
||||||
|
/// This struct is generally created by calling [`empty()`][empty]. Please see
|
||||||
|
/// the documentation of `empty()` for more details.
|
||||||
|
///
|
||||||
|
/// [empty]: fn.empty.html
|
||||||
|
pub struct Empty { _priv: () }
|
||||||
|
|
||||||
|
/// Constructs a new handle to an empty reader.
|
||||||
|
///
|
||||||
|
/// All reads from the returned reader will return `Ok(0)`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// A slightly sad example of not reading anything into a buffer:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{self, Read};
|
||||||
|
///
|
||||||
|
/// let mut buffer = String::new();
|
||||||
|
/// io::empty().read_to_string(&mut buffer).unwrap();
|
||||||
|
/// assert!(buffer.is_empty());
|
||||||
|
/// ```
|
||||||
|
pub fn empty() -> Empty { Empty { _priv: () } }
|
||||||
|
|
||||||
|
impl Read for Empty {
|
||||||
|
fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> { Ok(0) }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BufRead for Empty {
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(&[]) }
|
||||||
|
fn consume(&mut self, _n: usize) {}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A reader which yields one byte over and over and over and over and over and...
|
||||||
|
///
|
||||||
|
/// This struct is generally created by calling [`repeat()`][repeat]. Please
|
||||||
|
/// see the documentation of `repeat()` for more details.
|
||||||
|
///
|
||||||
|
/// [repeat]: fn.repeat.html
|
||||||
|
pub struct Repeat { byte: u8 }
|
||||||
|
|
||||||
|
/// Creates an instance of a reader that infinitely repeats one byte.
|
||||||
|
///
|
||||||
|
/// All reads from this reader will succeed by filling the specified buffer with
|
||||||
|
/// the given byte.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{self, Read};
|
||||||
|
///
|
||||||
|
/// let mut buffer = [0; 3];
|
||||||
|
/// io::repeat(0b101).read_exact(&mut buffer).unwrap();
|
||||||
|
/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
|
||||||
|
/// ```
|
||||||
|
pub fn repeat(byte: u8) -> Repeat { Repeat { byte: byte } }
|
||||||
|
|
||||||
|
impl Read for Repeat {
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
for slot in &mut *buf {
|
||||||
|
*slot = self.byte;
|
||||||
|
}
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A writer which will move data into the void.
|
||||||
|
///
|
||||||
|
/// This struct is generally created by calling [`sink()`][sink]. Please
|
||||||
|
/// see the documentation of `sink()` for more details.
|
||||||
|
///
|
||||||
|
/// [sink]: fn.sink.html
|
||||||
|
pub struct Sink { _priv: () }
|
||||||
|
|
||||||
|
/// Creates an instance of a writer which will successfully consume all data.
|
||||||
|
///
|
||||||
|
/// All calls to `write` on the returned instance will return `Ok(buf.len())`
|
||||||
|
/// and the contents of the buffer will not be inspected.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// use std::io::{self, Write};
|
||||||
|
///
|
||||||
|
/// let mut buffer = vec![1, 2, 3, 5, 8];
|
||||||
|
/// let num_bytes = io::sink().write(&mut buffer).unwrap();
|
||||||
|
/// assert_eq!(num_bytes, 5);
|
||||||
|
/// ```
|
||||||
|
pub fn sink() -> Sink { Sink { _priv: () } }
|
||||||
|
|
||||||
|
impl Write for Sink {
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
|
||||||
|
fn flush(&mut self) -> io::Result<()> { Ok(()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use prelude::v1::*;
|
||||||
|
|
||||||
|
use io::prelude::*;
|
||||||
|
use io::{copy, sink, empty, repeat};
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn copy_copies() {
|
||||||
|
let mut r = repeat(0).take(4);
|
||||||
|
let mut w = sink();
|
||||||
|
assert_eq!(copy(&mut r, &mut w).unwrap(), 4);
|
||||||
|
|
||||||
|
let mut r = repeat(0).take(1 << 17);
|
||||||
|
assert_eq!(copy(&mut r as &mut Read, &mut w as &mut Write).unwrap(), 1 << 17);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn sink_sinks() {
|
||||||
|
let mut s = sink();
|
||||||
|
assert_eq!(s.write(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(s.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
|
||||||
|
assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn empty_reads() {
|
||||||
|
let mut e = empty();
|
||||||
|
assert_eq!(e.read(&mut []).unwrap(), 0);
|
||||||
|
assert_eq!(e.read(&mut [0]).unwrap(), 0);
|
||||||
|
assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
|
||||||
|
assert_eq!(e.by_ref().read(&mut [0; 1024]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn repeat_repeats() {
|
||||||
|
let mut r = repeat(4);
|
||||||
|
let mut b = [0; 1024];
|
||||||
|
assert_eq!(r.read(&mut b).unwrap(), 1024);
|
||||||
|
assert!(b.iter().all(|b| *b == 4));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn take_some_bytes() {
|
||||||
|
assert_eq!(repeat(4).take(100).bytes().count(), 100);
|
||||||
|
assert_eq!(repeat(4).take(100).bytes().next().unwrap().unwrap(), 4);
|
||||||
|
assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -1,9 +1,12 @@
|
||||||
#![feature(lang_items, asm, alloc, collections, libc, needs_panic_runtime)]
|
#![feature(lang_items, asm, alloc, collections, libc, needs_panic_runtime,
|
||||||
|
question_mark, unicode)]
|
||||||
#![no_std]
|
#![no_std]
|
||||||
#![needs_panic_runtime]
|
#![needs_panic_runtime]
|
||||||
|
|
||||||
|
extern crate rustc_unicode;
|
||||||
extern crate alloc_artiq;
|
extern crate alloc_artiq;
|
||||||
extern crate alloc;
|
extern crate alloc;
|
||||||
|
#[macro_use]
|
||||||
extern crate collections;
|
extern crate collections;
|
||||||
extern crate libc;
|
extern crate libc;
|
||||||
|
|
||||||
|
|
@ -18,10 +21,13 @@ pub mod prelude {
|
||||||
pub mod v1 {
|
pub mod v1 {
|
||||||
pub use core::prelude::v1::*;
|
pub use core::prelude::v1::*;
|
||||||
pub use collections::*;
|
pub use collections::*;
|
||||||
|
pub use io::{Read, Write, Seek};
|
||||||
|
pub use io::BufRead;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub mod time;
|
pub mod time;
|
||||||
|
pub mod io;
|
||||||
|
|
||||||
use core::fmt::Write;
|
use core::fmt::Write;
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue