nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-28 02:57:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

std: Rename io to old_io

Browse Source 
In preparation for the I/O rejuvination of the standard library, this commit
renames the current `io` module to `old_io` in order to make room for the new
I/O modules. It is expected that the I/O RFCs will land incrementally over time
instead of all at once, and this provides a fresh clean path for new modules to
enter into as well as guaranteeing that all old infrastructure will remain in
place for some time.

As each `old_io` module is replaced it will be deprecated in-place for new
structures in `std::{io, fs, net}` (as appropriate).

This commit does *not* leave a reexport of `old_io as io` as the deprecation
lint does not currently warn on this form of use. This is quite a large breaking
change for all imports in existing code, but all functionality is retained
precisely as-is and path statements simply need to be renamed from `io` to
`old_io`.

[breaking-change]
This commit is contained in:
Alex Crichton 2015-01-22 16:27:48 -08:00
parent 8ec3a833d5
commit f72b164510
21 changed files with 311 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/libstd/lib.rs
View File

@ -79,7 +79,8 @@
//! memory types, including [`atomic`](sync/atomic/index.html).
//!
//! Common types of I/O, including files, TCP, UDP, pipes, Unix domain sockets,
//! timers, and process spawning, are defined in the [`io`](io/index.html) module.
//! timers, and process spawning, are defined in the
//! [`old_io`](old_io/index.html) module.
//!
//! Rust's I/O and concurrency depends on a small runtime interface
//! that lives, along with its support code, in mod [`rt`](rt/index.html).
@ -239,7 +240,7 @@ pub mod thread_local;
pub mod dynamic_lib;
pub mod ffi;
pub mod fmt;
pub mod io;
pub mod old_io;
pub mod os;
pub mod path;
pub mod rand;
@ -284,7 +285,7 @@ mod std {
pub use sync; // used for select!()
pub use error; // used for try!()
pub use fmt; // used for any formatting strings
pub use io; // used for println!()
pub use old_io; // used for println!()
pub use option; // used for bitflags!{}
pub use rt; // used for panic!()
pub use vec; // used for vec![]

30
src/libstd/io/buffered.rs → src/libstd/old_io/buffered.rs
View File

@ -14,7 +14,7 @@
use cmp;
use fmt;
use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
use old_io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
use iter::{IteratorExt, ExactSizeIterator, repeat};
use ops::Drop;
use option::Option;
@ -34,7 +34,7 @@ use vec::Vec;
/// # Example
///
/// ```rust
/// use std::io::{BufferedReader, File};
/// use std::old_io::{BufferedReader, File};
///
/// let file = File::open(&Path::new("message.txt"));
/// let mut reader = BufferedReader::new(file);
@ -137,7 +137,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
/// # Example
///
/// ```rust
/// use std::io::{BufferedWriter, File};
/// use std::old_io::{BufferedWriter, File};
///
/// let file = File::create(&Path::new("message.txt")).unwrap();
/// let mut writer = BufferedWriter::new(file);
@ -324,7 +324,7 @@ impl<W: Reader> Reader for InternalBufferedWriter<W> {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::{BufferedStream, File};
/// use std::old_io::{BufferedStream, File};
///
/// let file = File::open(&Path::new("message.txt"));
/// let mut stream = BufferedStream::new(file);
@ -437,13 +437,13 @@ mod test {
pub struct NullStream;
impl Reader for NullStream {
fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
Err(io::standard_error(io::EndOfFile))
fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
impl Writer for NullStream {
fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
fn write(&mut self, _: &[u8]) -> old_io::IoResult<()> { Ok(()) }
}
/// A dummy reader intended at testing short-reads propagation.
@ -452,9 +452,9 @@ mod test {
}
impl Reader for ShortReader {
fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
if self.lengths.is_empty() {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
} else {
Ok(self.lengths.remove(0))
}
@ -555,13 +555,13 @@ mod test {
fn test_buffered_stream() {
struct S;
impl io::Writer for S {
fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
impl old_io::Writer for S {
fn write(&mut self, _: &[u8]) -> old_io::IoResult<()> { Ok(()) }
}
impl io::Reader for S {
fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
Err(io::standard_error(io::EndOfFile))
impl old_io::Reader for S {
fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
@ -664,7 +664,7 @@ mod test {
impl Writer for FailFlushWriter {
fn write(&mut self, _buf: &[u8]) -> IoResult<()> { Ok(()) }
fn flush(&mut self) -> IoResult<()> { Err(io::standard_error(EndOfFile)) }
fn flush(&mut self) -> IoResult<()> { Err(old_io::standard_error(EndOfFile)) }
}
let writer = FailFlushWriter;

22
src/libstd/io/comm_adapters.rs → src/libstd/old_io/comm_adapters.rs
View File

@ -11,7 +11,7 @@
use clone::Clone;
use cmp;
use sync::mpsc::{Sender, Receiver};
use io;
use old_io;
use option::Option::{None, Some};
use result::Result::{Ok, Err};
use slice::{bytes, SliceExt};
@ -24,7 +24,7 @@ use vec::Vec;
///
/// ```
/// use std::sync::mpsc::channel;
/// use std::io::ChanReader;
/// use std::old_io::ChanReader;
///
/// let (tx, rx) = channel();
/// # drop(tx);
@ -70,7 +70,7 @@ impl Buffer for ChanReader {
}
}
if self.closed {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
} else {
Ok(&self.buf[self.pos..])
}
@ -102,7 +102,7 @@ impl Reader for ChanReader {
}
}
if self.closed && num_read == 0 {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
} else {
Ok(num_read)
}
@ -116,7 +116,7 @@ impl Reader for ChanReader {
/// ```
/// # #![allow(unused_must_use)]
/// use std::sync::mpsc::channel;
/// use std::io::ChanWriter;
/// use std::old_io::ChanWriter;
///
/// let (tx, rx) = channel();
/// # drop(rx);
@ -144,8 +144,8 @@ impl Clone for ChanWriter {
impl Writer for ChanWriter {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
self.tx.send(buf.to_vec()).map_err(|_| {
io::IoError {
kind: io::BrokenPipe,
old_io::IoError {
kind: old_io::BrokenPipe,
desc: "Pipe closed",
detail: None
}
@ -193,14 +193,14 @@ mod test {
match reader.read(buf.as_mut_slice()) {
Ok(..) => panic!(),
Err(e) => assert_eq!(e.kind, io::EndOfFile),
Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
}
assert_eq!(a, buf);
// Ensure it continues to panic in the same way.
match reader.read(buf.as_mut_slice()) {
Ok(..) => panic!(),
Err(e) => assert_eq!(e.kind, io::EndOfFile),
Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
}
assert_eq!(a, buf);
}
@ -223,7 +223,7 @@ mod test {
assert_eq!(Ok("how are you?".to_string()), reader.read_line());
match reader.read_line() {
Ok(..) => panic!(),
Err(e) => assert_eq!(e.kind, io::EndOfFile),
Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
}
}
@ -242,7 +242,7 @@ mod test {
match writer.write_u8(1) {
Ok(..) => panic!(),
Err(e) => assert_eq!(e.kind, io::BrokenPipe),
Err(e) => assert_eq!(e.kind, old_io::BrokenPipe),
}
}
}

28
src/libstd/io/extensions.rs → src/libstd/old_io/extensions.rs
View File

@ -15,8 +15,8 @@
// FIXME: Not sure how this should be structured
// FIXME: Iteration should probably be considered separately
use io::{IoError, IoResult, Reader};
use io;
use old_io::{IoError, IoResult, Reader};
use old_io;
use iter::Iterator;
use num::Int;
use ops::FnOnce;
@ -59,7 +59,7 @@ impl<'r, R: Reader> Iterator for Bytes<'r, R> {
fn next(&mut self) -> Option<IoResult<u8>> {
match self.reader.read_byte() {
Ok(x) => Some(Ok(x)),
Err(IoError { kind: io::EndOfFile, .. }) => None,
Err(IoError { kind: old_io::EndOfFile, .. }) => None,
Err(e) => Some(Err(e))
}
}
@ -179,14 +179,14 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
mod test {
use prelude::v1::*;
use io;
use io::{MemReader, BytesReader};
use old_io::{MemReader, BytesReader};
struct InitialZeroByteReader {
count: int,
}
impl Reader for InitialZeroByteReader {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
if self.count == 0 {
self.count = 1;
Ok(0)
@ -200,16 +200,16 @@ mod test {
struct EofReader;
impl Reader for EofReader {
fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
Err(io::standard_error(io::EndOfFile))
fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
struct ErroringReader;
impl Reader for ErroringReader {
fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
Err(io::standard_error(io::InvalidInput))
fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
Err(old_io::standard_error(old_io::InvalidInput))
}
}
@ -218,7 +218,7 @@ mod test {
}
impl Reader for PartialReader {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
if self.count == 0 {
self.count = 1;
buf[0] = 10;
@ -237,13 +237,13 @@ mod test {
}
impl Reader for ErroringLaterReader {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
if self.count == 0 {
self.count = 1;
buf[0] = 10;
Ok(1)
} else {
Err(io::standard_error(io::InvalidInput))
Err(old_io::standard_error(old_io::InvalidInput))
}
}
}
@ -253,7 +253,7 @@ mod test {
}
impl Reader for ThreeChunkReader {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
if self.count == 0 {
self.count = 1;
buf[0] = 10;
@ -265,7 +265,7 @@ mod test {
buf[1] = 13;
Ok(2)
} else {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
}
}
}

191
src/libstd/io/fs.rs → src/libstd/old_io/fs.rs
View File

@ -18,21 +18,21 @@
//! At the top-level of the module are a set of freestanding functions, associated
//! with various filesystem operations. They all operate on `Path` objects.
//!
//! All operations in this module, including those as part of `File` et al
//! block the task during execution. In the event of failure, all functions/methods
//! All operations in this module, including those as part of `File` et al block
//! the task during execution. In the event of failure, all functions/methods
//! will return an `IoResult` type with an `Err` value.
//!
//! Also included in this module is an implementation block on the `Path` object
//! defined in `std::path::Path`. The impl adds useful methods about inspecting the
//! metadata of a file. This includes getting the `stat` information, reading off
//! particular bits of it, etc.
//! defined in `std::path::Path`. The impl adds useful methods about inspecting
//! the metadata of a file. This includes getting the `stat` information,
//! reading off particular bits of it, etc.
//!
//! # Example
//!
//! ```rust
//! # #![allow(unused_must_use)]
//! use std::io::fs::PathExtensions;
//! use std::io::{File, fs};
//! use std::old_io::fs::PathExtensions;
//! use std::old_io::{File, fs};
//!
//! let path = Path::new("foo.txt");
//!
@ -51,13 +51,13 @@
//! ```
use clone::Clone;
use io::standard_error;
use io::{FilePermission, Write, Open, FileAccess, FileMode, FileType};
use io::{IoResult, IoError, InvalidInput};
use io::{FileStat, SeekStyle, Seek, Writer, Reader};
use io::{Read, Truncate, ReadWrite, Append};
use io::UpdateIoError;
use io;
use old_io::standard_error;
use old_io::{FilePermission, Write, Open, FileAccess, FileMode, FileType};
use old_io::{IoResult, IoError, InvalidInput};
use old_io::{FileStat, SeekStyle, Seek, Writer, Reader};
use old_io::{Read, Truncate, ReadWrite, Append};
use old_io::UpdateIoError;
use old_io;
use iter::{Iterator, Extend};
use option::Option;
use option::Option::{Some, None};
@ -101,7 +101,7 @@ impl File {
/// # Example
///
/// ```rust,should_fail
/// use std::io::{File, Open, ReadWrite};
/// use std::old_io::{File, Open, ReadWrite};
///
/// let p = Path::new("/some/file/path.txt");
///
@ -170,7 +170,7 @@ impl File {
/// # Example
///
/// ```rust
/// use std::io::File;
/// use std::old_io::File;
///
/// let contents = File::open(&Path::new("foo.txt")).read_to_end();
/// ```
@ -188,12 +188,12 @@ impl File {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::File;
/// use std::old_io::File;
///
/// let mut f = File::create(&Path::new("foo.txt"));
/// f.write(b"This is a sample file");
/// # drop(f);
/// # ::std::io::fs::unlink(&Path::new("foo.txt"));
/// # ::std::old_io::fs::unlink(&Path::new("foo.txt"));
/// ```
pub fn create(path: &Path) -> IoResult<File> {
File::open_mode(path, Truncate, Write)
@ -265,7 +265,7 @@ impl File {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::fs;
/// use std::old_io::fs;
///
/// let p = Path::new("/some/file/path.txt");
/// fs::unlink(&p);
@ -293,7 +293,7 @@ pub fn unlink(path: &Path) -> IoResult<()> {
/// # Example
///
/// ```rust
/// use std::io::fs;
/// use std::old_io::fs;
///
/// let p = Path::new("/some/file/path.txt");
/// match fs::stat(&p) {
@ -333,7 +333,7 @@ pub fn lstat(path: &Path) -> IoResult<FileStat> {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::fs;
/// use std::old_io::fs;
///
/// fs::rename(&Path::new("foo"), &Path::new("bar"));
/// ```
@ -359,7 +359,7 @@ pub fn rename(from: &Path, to: &Path) -> IoResult<()> {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::fs;
/// use std::old_io::fs;
///
/// fs::copy(&Path::new("foo.txt"), &Path::new("bar.txt"));
/// ```
@ -386,7 +386,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
if !from.is_file() {
return update_err(Err(IoError {
kind: io::MismatchedFileTypeForOperation,
kind: old_io::MismatchedFileTypeForOperation,
desc: "the source path is not an existing file",
detail: None
}), from, to)
@ -408,12 +408,12 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io;
/// use std::io::fs;
/// use std::old_io::fs;
///
/// fs::chmod(&Path::new("file.txt"), io::USER_FILE);
/// fs::chmod(&Path::new("file.txt"), io::USER_READ | io::USER_WRITE);
/// fs::chmod(&Path::new("dir"), io::USER_DIR);
/// fs::chmod(&Path::new("file.exe"), io::USER_EXEC);
/// fs::chmod(&Path::new("file.txt"), old_io::USER_FILE);
/// fs::chmod(&Path::new("file.txt"), old_io::USER_READ | old_io::USER_WRITE);
/// fs::chmod(&Path::new("dir"), old_io::USER_DIR);
/// fs::chmod(&Path::new("file.exe"), old_io::USER_EXEC);
/// ```
///
/// # Error
@ -421,7 +421,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
/// This function will return an error if the provided `path` doesn't exist, if
/// the process lacks permissions to change the attributes of the file, or if
/// some other I/O error is encountered.
pub fn chmod(path: &Path, mode: io::FilePermission) -> IoResult<()> {
pub fn chmod(path: &Path, mode: old_io::FilePermission) -> IoResult<()> {
fs_imp::chmod(path, mode.bits() as uint)
.update_err("couldn't chmod path", |e|
format!("{}; path={}; mode={:?}", e, path.display(), mode))
@ -470,10 +470,10 @@ pub fn readlink(path: &Path) -> IoResult<Path> {
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io;
/// use std::io::fs;
/// use std::old_io::fs;
///
/// let p = Path::new("/some/dir");
/// fs::mkdir(&p, io::USER_RWX);
/// fs::mkdir(&p, old_io::USER_RWX);
/// ```
///
/// # Error
@ -492,7 +492,7 @@ pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::fs;
/// use std::old_io::fs;
///
/// let p = Path::new("/some/dir");
/// fs::rmdir(&p);
@ -513,12 +513,12 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
/// # Example
///
/// ```rust
/// use std::io::fs::PathExtensions;
/// use std::io::fs;
/// use std::old_io::fs::PathExtensions;
/// use std::old_io::fs;
/// use std::io;
///
/// // one possible implementation of fs::walk_dir only visiting files
/// fn visit_dirs<F>(dir: &Path, cb: &mut F) -> io::IoResult<()> where
/// fn visit_dirs<F>(dir: &Path, cb: &mut F) -> old_io::IoResult<()> where
/// F: FnMut(&Path),
/// {
/// if dir.is_dir() {
@ -532,7 +532,7 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
/// }
/// Ok(())
/// } else {
/// Err(io::standard_error(io::InvalidInput))
/// Err(old_io::standard_error(old_io::InvalidInput))
/// }
/// }
/// ```
@ -664,7 +664,7 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
// (eg: deleted by someone else since readdir)
match update_err(unlink(&child), path) {
Ok(()) => (),
Err(ref e) if e.kind == io::FileNotFound => (),
Err(ref e) if e.kind == old_io::FileNotFound => (),
Err(e) => return Err(e)
}
}
@ -675,7 +675,7 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
let result = update_err(rmdir(&rm_stack.pop().unwrap()), path);
match result {
Ok(()) => (),
Err(ref e) if e.kind == io::FileNotFound => (),
Err(ref e) if e.kind == old_io::FileNotFound => (),
Err(e) => return Err(e)
}
}
@ -709,7 +709,7 @@ impl Reader for File {
Ok(read) => {
self.last_nread = read as int;
match read {
0 => update_err(Err(standard_error(io::EndOfFile)), self),
0 => update_err(Err(standard_error(old_io::EndOfFile)), self),
_ => Ok(read as uint)
}
},
@ -824,10 +824,10 @@ fn access_string(access: FileAccess) -> &'static str {
#[allow(unused_mut)]
mod test {
use prelude::v1::*;
use io::{SeekSet, SeekCur, SeekEnd, Read, Open, ReadWrite, FileType};
use old_io::{SeekSet, SeekCur, SeekEnd, Read, Open, ReadWrite, FileType};
use io;
use str;
use io::fs::*;
use old_io::fs::*;
macro_rules! check { ($e:expr) => (
match $e {
@ -863,7 +863,7 @@ mod test {
// Gee, seeing how we're testing the fs module I sure hope that we
// at least implement this correctly!
let TempDir(ref p) = *self;
check!(io::fs::rmdir_recursive(p));
check!(old_io::fs::rmdir_recursive(p));
}
}
@ -871,7 +871,7 @@ mod test {
use os;
use rand;
let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
check!(io::fs::mkdir(&ret, io::USER_RWX));
check!(old_io::fs::mkdir(&ret, old_io::USER_RWX));
TempDir(ret)
}
@ -1055,7 +1055,7 @@ mod test {
fn file_test_stat_is_correct_on_is_dir() {
let tmpdir = tmpdir();
let filename = &tmpdir.join("file_stat_correct_on_is_dir");
check!(mkdir(filename, io::USER_RWX));
check!(mkdir(filename, old_io::USER_RWX));
let stat_res_fn = check!(stat(filename));
assert!(stat_res_fn.kind == FileType::Directory);
let stat_res_meth = check!(filename.stat());
@ -1067,7 +1067,7 @@ mod test {
fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
let tmpdir = tmpdir();
let dir = &tmpdir.join("fileinfo_false_on_dir");
check!(mkdir(dir, io::USER_RWX));
check!(mkdir(dir, old_io::USER_RWX));
assert!(dir.is_file() == false);
check!(rmdir(dir));
}
@ -1087,7 +1087,7 @@ mod test {
let tmpdir = tmpdir();
let dir = &tmpdir.join("before_and_after_dir");
assert!(!dir.exists());
check!(mkdir(dir, io::USER_RWX));
check!(mkdir(dir, old_io::USER_RWX));
assert!(dir.exists());
assert!(dir.is_dir());
check!(rmdir(dir));
@ -1099,7 +1099,7 @@ mod test {
use str;
let tmpdir = tmpdir();
let dir = &tmpdir.join("di_readdir");
check!(mkdir(dir, io::USER_RWX));
check!(mkdir(dir, old_io::USER_RWX));
let prefix = "foo";
for n in range(0i,3) {
let f = dir.join(format!("{}.txt", n));
@ -1130,14 +1130,14 @@ mod test {
fn file_test_walk_dir() {
let tmpdir = tmpdir();
let dir = &tmpdir.join("walk_dir");
check!(mkdir(dir, io::USER_RWX));
check!(mkdir(dir, old_io::USER_RWX));
let dir1 = &dir.join("01/02/03");
check!(mkdir_recursive(dir1, io::USER_RWX));
check!(mkdir_recursive(dir1, old_io::USER_RWX));
check!(File::create(&dir1.join("04")));
let dir2 = &dir.join("11/12/13");
check!(mkdir_recursive(dir2, io::USER_RWX));
check!(mkdir_recursive(dir2, old_io::USER_RWX));
check!(File::create(&dir2.join("14")));
let mut files = check!(walk_dir(dir));
@ -1155,12 +1155,12 @@ mod test {
#[test]
fn mkdir_path_already_exists_error() {
use io::{IoError, PathAlreadyExists};
use old_io::{IoError, PathAlreadyExists};
let tmpdir = tmpdir();
let dir = &tmpdir.join("mkdir_error_twice");
check!(mkdir(dir, io::USER_RWX));
match mkdir(dir, io::USER_RWX) {
check!(mkdir(dir, old_io::USER_RWX));
match mkdir(dir, old_io::USER_RWX) {
Err(IoError{kind:PathAlreadyExists,..}) => (),
_ => assert!(false)
};
@ -1170,7 +1170,7 @@ mod test {
fn recursive_mkdir() {
let tmpdir = tmpdir();
let dir = tmpdir.join("d1/d2");
check!(mkdir_recursive(&dir, io::USER_RWX));
check!(mkdir_recursive(&dir, old_io::USER_RWX));
assert!(dir.is_dir())
}
@ -1180,10 +1180,10 @@ mod test {
let dir = tmpdir.join("d1");
let file = dir.join("f1");
check!(mkdir_recursive(&dir, io::USER_RWX));
check!(mkdir_recursive(&dir, old_io::USER_RWX));
check!(File::create(&file));
let result = mkdir_recursive(&file, io::USER_RWX);
let result = mkdir_recursive(&file, old_io::USER_RWX);
error!(result, "couldn't recursively mkdir");
error!(result, "couldn't create directory");
@ -1193,7 +1193,7 @@ mod test {
#[test]
fn recursive_mkdir_slash() {
check!(mkdir_recursive(&Path::new("/"), io::USER_RWX));
check!(mkdir_recursive(&Path::new("/"), old_io::USER_RWX));
}
// FIXME(#12795) depends on lstat to work on windows
@ -1206,8 +1206,8 @@ mod test {
let dtt = dt.join("t");
let d2 = tmpdir.join("d2");
let canary = d2.join("do_not_delete");
check!(mkdir_recursive(&dtt, io::USER_RWX));
check!(mkdir_recursive(&d2, io::USER_RWX));
check!(mkdir_recursive(&dtt, old_io::USER_RWX));
check!(mkdir_recursive(&d2, old_io::USER_RWX));
check!(File::create(&canary).write(b"foo"));
check!(symlink(&d2, &dt.join("d2")));
check!(rmdir_recursive(&d1));
@ -1225,7 +1225,7 @@ mod test {
let mut dirpath = tmpdir.path().clone();
dirpath.push(format!("test-가一ー你好"));
check!(mkdir(&dirpath, io::USER_RWX));
check!(mkdir(&dirpath, old_io::USER_RWX));
assert!(dirpath.is_dir());
let mut filepath = dirpath;
@ -1243,7 +1243,7 @@ mod test {
let tmpdir = tmpdir();
let unicode = tmpdir.path();
let unicode = unicode.join(format!("test-각丁ー再见"));
check!(mkdir(&unicode, io::USER_RWX));
check!(mkdir(&unicode, old_io::USER_RWX));
assert!(unicode.exists());
assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
}
@ -1324,12 +1324,12 @@ mod test {
let out = tmpdir.join("out.txt");
check!(File::create(&input));
check!(chmod(&input, io::USER_READ));
check!(chmod(&input, old_io::USER_READ));
check!(copy(&input, &out));
assert!(!check!(out.stat()).perm.intersects(io::USER_WRITE));
assert!(!check!(out.stat()).perm.intersects(old_io::USER_WRITE));
check!(chmod(&input, io::USER_FILE));
check!(chmod(&out, io::USER_FILE));
check!(chmod(&input, old_io::USER_FILE));
check!(chmod(&out, old_io::USER_FILE));
}
#[cfg(not(windows))] // FIXME(#10264) operation not permitted?
@ -1405,16 +1405,16 @@ mod test {
let file = tmpdir.join("in.txt");
check!(File::create(&file));
assert!(check!(stat(&file)).perm.contains(io::USER_WRITE));
check!(chmod(&file, io::USER_READ));
assert!(!check!(stat(&file)).perm.contains(io::USER_WRITE));
assert!(check!(stat(&file)).perm.contains(old_io::USER_WRITE));
check!(chmod(&file, old_io::USER_READ));
assert!(!check!(stat(&file)).perm.contains(old_io::USER_WRITE));
match chmod(&tmpdir.join("foo"), io::USER_RWX) {
match chmod(&tmpdir.join("foo"), old_io::USER_RWX) {
Ok(..) => panic!("wanted a panic"),
Err(..) => {}
}
check!(chmod(&file, io::USER_FILE));
check!(chmod(&file, old_io::USER_FILE));
}
#[test]
@ -1422,7 +1422,7 @@ mod test {
let tmpdir = tmpdir();
let path = tmpdir.join("in.txt");
let mut file = check!(File::open_mode(&path, io::Open, io::ReadWrite));
let mut file = check!(File::open_mode(&path, old_io::Open, old_io::ReadWrite));
check!(file.fsync());
check!(file.datasync());
check!(file.write(b"foo"));
@ -1436,7 +1436,7 @@ mod test {
let tmpdir = tmpdir();
let path = tmpdir.join("in.txt");
let mut file = check!(File::open_mode(&path, io::Open, io::ReadWrite));
let mut file = check!(File::open_mode(&path, old_io::Open, old_io::ReadWrite));
check!(file.write(b"foo"));
check!(file.fsync());
@ -1467,41 +1467,41 @@ mod test {
fn open_flavors() {
let tmpdir = tmpdir();
match File::open_mode(&tmpdir.join("a"), io::Open, io::Read) {
match File::open_mode(&tmpdir.join("a"), old_io::Open, old_io::Read) {
Ok(..) => panic!(), Err(..) => {}
}
// Perform each one twice to make sure that it succeeds the second time
// (where the file exists)
check!(File::open_mode(&tmpdir.join("b"), io::Open, io::Write));
check!(File::open_mode(&tmpdir.join("b"), old_io::Open, old_io::Write));
assert!(tmpdir.join("b").exists());
check!(File::open_mode(&tmpdir.join("b"), io::Open, io::Write));
check!(File::open_mode(&tmpdir.join("b"), old_io::Open, old_io::Write));
check!(File::open_mode(&tmpdir.join("c"), io::Open, io::ReadWrite));
check!(File::open_mode(&tmpdir.join("c"), old_io::Open, old_io::ReadWrite));
assert!(tmpdir.join("c").exists());
check!(File::open_mode(&tmpdir.join("c"), io::Open, io::ReadWrite));
check!(File::open_mode(&tmpdir.join("c"), old_io::Open, old_io::ReadWrite));
check!(File::open_mode(&tmpdir.join("d"), io::Append, io::Write));
check!(File::open_mode(&tmpdir.join("d"), old_io::Append, old_io::Write));
assert!(tmpdir.join("d").exists());
check!(File::open_mode(&tmpdir.join("d"), io::Append, io::Write));
check!(File::open_mode(&tmpdir.join("d"), old_io::Append, old_io::Write));
check!(File::open_mode(&tmpdir.join("e"), io::Append, io::ReadWrite));
check!(File::open_mode(&tmpdir.join("e"), old_io::Append, old_io::ReadWrite));
assert!(tmpdir.join("e").exists());
check!(File::open_mode(&tmpdir.join("e"), io::Append, io::ReadWrite));
check!(File::open_mode(&tmpdir.join("e"), old_io::Append, old_io::ReadWrite));
check!(File::open_mode(&tmpdir.join("f"), io::Truncate, io::Write));
check!(File::open_mode(&tmpdir.join("f"), old_io::Truncate, old_io::Write));
assert!(tmpdir.join("f").exists());
check!(File::open_mode(&tmpdir.join("f"), io::Truncate, io::Write));
check!(File::open_mode(&tmpdir.join("f"), old_io::Truncate, old_io::Write));
check!(File::open_mode(&tmpdir.join("g"), io::Truncate, io::ReadWrite));
check!(File::open_mode(&tmpdir.join("g"), old_io::Truncate, old_io::ReadWrite));
assert!(tmpdir.join("g").exists());
check!(File::open_mode(&tmpdir.join("g"), io::Truncate, io::ReadWrite));
check!(File::open_mode(&tmpdir.join("g"), old_io::Truncate, old_io::ReadWrite));
check!(File::create(&tmpdir.join("h")).write("foo".as_bytes()));
check!(File::open_mode(&tmpdir.join("h"), io::Open, io::Read));
check!(File::open_mode(&tmpdir.join("h"), old_io::Open, old_io::Read));
{
let mut f = check!(File::open_mode(&tmpdir.join("h"), io::Open,
io::Read));
let mut f = check!(File::open_mode(&tmpdir.join("h"), old_io::Open,
old_io::Read));
match f.write("wut".as_bytes()) {
Ok(..) => panic!(), Err(..) => {}
}
@ -1509,15 +1509,15 @@ mod test {
assert!(check!(stat(&tmpdir.join("h"))).size == 3,
"write/stat failed");
{
let mut f = check!(File::open_mode(&tmpdir.join("h"), io::Append,
io::Write));
let mut f = check!(File::open_mode(&tmpdir.join("h"), old_io::Append,
old_io::Write));
check!(f.write("bar".as_bytes()));
}
assert!(check!(stat(&tmpdir.join("h"))).size == 6,
"append didn't append");
{
let mut f = check!(File::open_mode(&tmpdir.join("h"), io::Truncate,
io::Write));
let mut f = check!(File::open_mode(&tmpdir.join("h"), old_io::Truncate,
old_io::Write));
check!(f.write("bar".as_bytes()));
}
assert!(check!(stat(&tmpdir.join("h"))).size == 3,
@ -1529,8 +1529,9 @@ mod test {
let tmpdir = tmpdir();
let path = tmpdir.join("a");
check!(File::create(&path));
// These numbers have to be bigger than the time in the day to account for timezones
// Windows in particular will fail in certain timezones with small enough values
// These numbers have to be bigger than the time in the day to account
// for timezones Windows in particular will fail in certain timezones
// with small enough values
check!(change_file_times(&path, 100000, 200000));
assert_eq!(check!(path.stat()).accessed, 100000);
assert_eq!(check!(path.stat()).modified, 200000);
@ -1565,7 +1566,7 @@ mod test {
let tmpdir = tmpdir();
let path = tmpdir.join("file");
check!(File::create(&path));
check!(chmod(&path, io::USER_READ));
check!(chmod(&path, old_io::USER_READ));
check!(unlink(&path));
}
}

44
src/libstd/io/mem.rs → src/libstd/old_io/mem.rs
View File

@ -15,8 +15,8 @@
use cmp::min;
use option::Option::None;
use result::Result::{Err, Ok};
use io;
use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
use old_io;
use old_io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
use slice::{self, AsSlice, SliceExt};
use vec::Vec;
@ -25,14 +25,14 @@ const BUF_CAPACITY: uint = 128;
fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
// compute offset as signed and clamp to prevent overflow
let pos = match seek {
io::SeekSet => 0,
io::SeekEnd => end,
io::SeekCur => cur,
old_io::SeekSet => 0,
old_io::SeekEnd => end,
old_io::SeekCur => cur,
} as i64;
if offset + pos < 0 {
Err(IoError {
kind: io::InvalidInput,
kind: old_io::InvalidInput,
desc: "invalid seek to a negative offset",
detail: None
})
@ -55,7 +55,7 @@ impl Writer for Vec<u8> {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::MemWriter;
/// use std::old_io::MemWriter;
///
/// let mut w = MemWriter::new();
/// w.write(&[0, 1, 2]);
@ -111,7 +111,7 @@ impl Writer for MemWriter {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::MemReader;
/// use std::old_io::MemReader;
///
/// let mut r = MemReader::new(vec!(0, 1, 2));
///
@ -155,7 +155,7 @@ impl MemReader {
impl Reader for MemReader {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
@ -189,7 +189,7 @@ impl Buffer for MemReader {
if self.pos < self.buf.len() {
Ok(&self.buf[self.pos..])
} else {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
}
}
@ -200,7 +200,7 @@ impl Buffer for MemReader {
impl<'a> Reader for &'a [u8] {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
if self.is_empty() { return Err(io::standard_error(io::EndOfFile)); }
if self.is_empty() { return Err(old_io::standard_error(old_io::EndOfFile)); }
let write_len = min(buf.len(), self.len());
{
@ -219,7 +219,7 @@ impl<'a> Buffer for &'a [u8] {
#[inline]
fn fill_buf(&mut self) -> IoResult<&[u8]> {
if self.is_empty() {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
} else {
Ok(*self)
}
@ -241,7 +241,7 @@ impl<'a> Buffer for &'a [u8] {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::BufWriter;
/// use std::old_io::BufWriter;
///
/// let mut buf = [0; 4];
/// {
@ -274,7 +274,7 @@ impl<'a> Writer for BufWriter<'a> {
let dst_len = dst.len();
if dst_len == 0 {
return Err(io::standard_error(io::EndOfFile));
return Err(old_io::standard_error(old_io::EndOfFile));
}
let src_len = src.len();
@ -290,7 +290,7 @@ impl<'a> Writer for BufWriter<'a> {
self.pos += dst_len;
Err(io::standard_error(io::ShortWrite(dst_len)))
Err(old_io::standard_error(old_io::ShortWrite(dst_len)))
}
}
}
@ -313,7 +313,7 @@ impl<'a> Seek for BufWriter<'a> {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::BufReader;
/// use std::old_io::BufReader;
///
/// let buf = [0, 1, 2, 3];
/// let mut r = BufReader::new(&buf);
@ -345,7 +345,7 @@ impl<'a> BufReader<'a> {
impl<'a> Reader for BufReader<'a> {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
@ -379,7 +379,7 @@ impl<'a> Buffer for BufReader<'a> {
if self.pos < self.buf.len() {
Ok(&self.buf[self.pos..])
} else {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
}
}
@ -390,7 +390,7 @@ impl<'a> Buffer for BufReader<'a> {
#[cfg(test)]
mod test {
extern crate "test" as test_crate;
use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
use prelude::v1::{Ok, Err, range, Vec, Buffer, AsSlice, SliceExt};
use prelude::v1::IteratorExt;
use io;
@ -432,8 +432,8 @@ mod test {
writer.write(&[]).unwrap();
assert_eq!(writer.tell(), Ok(8));
assert_eq!(writer.write(&[8, 9]).err().unwrap().kind, io::ShortWrite(1));
assert_eq!(writer.write(&[10]).err().unwrap().kind, io::EndOfFile);
assert_eq!(writer.write(&[8, 9]).err().unwrap().kind, old_io::ShortWrite(1));
assert_eq!(writer.write(&[10]).err().unwrap().kind, old_io::EndOfFile);
}
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
assert_eq!(buf, b);
@ -476,7 +476,7 @@ mod test {
match writer.write(&[0, 0]) {
Ok(..) => panic!(),
Err(e) => assert_eq!(e.kind, io::ShortWrite(1)),
Err(e) => assert_eq!(e.kind, old_io::ShortWrite(1)),
}
}

62
src/libstd/io/mod.rs → src/libstd/old_io/mod.rs
View File

@ -18,6 +18,24 @@
//! I/O, including files, networking, timers, and processes
//!
//! > **Warning**: This module is currently called `old_io` for a reason! The
//! > module is currently being redesigned in a number of RFCs. For more details
//! > follow the RFC repository in connection with [RFC 517][base] or follow
//! > some of these sub-RFCs
//! >
//! > * [String handling][osstr]
//! > * [Core I/O support][core]
//! > * [Deadlines][deadlines]
//! > * [std::env][env]
//! > * [std::process][process]
//!
//! [base]: https://github.com/rust-lang/rfcs/blob/master/text/0517-io-os-reform.md
//! [osstr]: https://github.com/rust-lang/rfcs/pull/575
//! [core]: https://github.com/rust-lang/rfcs/pull/576
//! [deadlines]: https://github.com/rust-lang/rfcs/pull/577
//! [env]: https://github.com/rust-lang/rfcs/pull/578
//! [process]: https://github.com/rust-lang/rfcs/pull/579
//!
//! `std::io` provides Rust's basic I/O types,
//! for reading and writing to files, TCP, UDP,
//! and other types of sockets and pipes,
@ -30,7 +48,7 @@
//! * Read lines from stdin
//!
//! ```rust
//! use std::io;
//! use std::old_io as io;
//!
//! for line in io::stdin().lock().lines() {
//! print!("{}", line.unwrap());
@ -40,7 +58,7 @@
//! * Read a complete file
//!
//! ```rust
//! use std::io::File;
//! use std::old_io::File;
//!
//! let contents = File::open(&Path::new("message.txt")).read_to_end();
//! ```
@ -49,19 +67,19 @@
//!
//! ```rust
//! # #![allow(unused_must_use)]
//! use std::io::File;
//! use std::old_io::File;
//!
//! let mut file = File::create(&Path::new("message.txt"));
//! file.write(b"hello, file!\n");
//! # drop(file);
//! # ::std::io::fs::unlink(&Path::new("message.txt"));
//! # ::std::old_io::fs::unlink(&Path::new("message.txt"));
//! ```
//!
//! * Iterate over the lines of a file
//!
//! ```rust,no_run
//! use std::io::BufferedReader;
//! use std::io::File;
//! use std::old_io::BufferedReader;
//! use std::old_io::File;
//!
//! let path = Path::new("message.txt");
//! let mut file = BufferedReader::new(File::open(&path));
@ -73,8 +91,8 @@
//! * Pull the lines of a file into a vector of strings
//!
//! ```rust,no_run
//! use std::io::BufferedReader;
//! use std::io::File;
//! use std::old_io::BufferedReader;
//! use std::old_io::File;
//!
//! let path = Path::new("message.txt");
//! let mut file = BufferedReader::new(File::open(&path));
@ -85,7 +103,7 @@
//!
//! ```rust
//! # #![allow(unused_must_use)]
//! use std::io::TcpStream;
//! use std::old_io::TcpStream;
//!
//! # // connection doesn't fail if a server is running on 8080
//! # // locally, we still want to be type checking this code, so lets
@ -103,8 +121,8 @@
//! # fn main() { }
//! # fn foo() {
//! # #![allow(dead_code)]
//! use std::io::{TcpListener, TcpStream};
//! use std::io::{Acceptor, Listener};
//! use std::old_io::{TcpListener, TcpStream};
//! use std::old_io::{Acceptor, Listener};
//! use std::thread::Thread;
//!
//! let listener = TcpListener::bind("127.0.0.1:80");
@ -166,14 +184,14 @@
//!
//! ```rust
//! # #![allow(unused_must_use)]
//! use std::io::File;
//! use std::old_io::File;
//!
//! match File::create(&Path::new("diary.txt")).write(b"Met a girl.\n") {
//! Ok(()) => (), // succeeded
//! Err(e) => println!("failed to write to my diary: {}", e),
//! }
//!
//! # ::std::io::fs::unlink(&Path::new("diary.txt"));
//! # ::std::old_io::fs::unlink(&Path::new("diary.txt"));
//! ```
//!
//! So what actually happens if `create` encounters an error?
@ -199,7 +217,7 @@
//! If you wanted to read several `u32`s from a file and return their product:
//!
//! ```rust
//! use std::io::{File, IoResult};
//! use std::old_io::{File, IoResult};
//!
//! fn file_product(p: &Path) -> IoResult<u32> {
//! let mut f = File::open(p);
@ -925,9 +943,9 @@ unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: uint, end: uint) -
/// # Examples
///
/// ```
/// use std::io;
/// use std::io::ByRefReader;
/// use std::io::util::LimitReader;
/// use std::old_io as io;
/// use std::old_io::ByRefReader;
/// use std::old_io::util::LimitReader;
///
/// fn process_input<R: Reader>(r: R) {}
///
@ -1254,8 +1272,8 @@ impl<'a> Writer for &'a mut (Writer+'a) {
/// # Example
///
/// ```
/// use std::io::util::TeeReader;
/// use std::io::{stdin, ByRefWriter};
/// use std::old_io::util::TeeReader;
/// use std::old_io::{stdin, ByRefWriter};
///
/// fn process_input<R: Reader>(r: R) {}
///
@ -1379,7 +1397,7 @@ pub trait Buffer: Reader {
/// # Example
///
/// ```rust
/// use std::io::BufReader;
/// use std::old_io::BufReader;
///
/// let mut reader = BufReader::new(b"hello\nworld");
/// assert_eq!("hello\n", &*reader.read_line().unwrap());
@ -1601,7 +1619,7 @@ impl<'a, T, A: ?Sized + Acceptor<T>> Iterator for IncomingConnections<'a, A> {
/// # Example
///
/// ```
/// use std::io;
/// use std::old_io as io;
///
/// let eof = io::standard_error(io::EndOfFile);
/// let einval = io::standard_error(io::InvalidInput);
@ -1691,7 +1709,7 @@ pub enum FileType {
/// ```no_run
/// # #![allow(unstable)]
///
/// use std::io::fs::PathExtensions;
/// use std::old_io::fs::PathExtensions;
///
/// let info = match Path::new("foo.txt").stat() {
/// Ok(stat) => stat,

6
src/libstd/io/net/addrinfo.rs → src/libstd/old_io/net/addrinfo.rs
View File

@ -20,8 +20,8 @@ pub use self::Flag::*;
pub use self::Protocol::*;
use iter::IteratorExt;
use io::{IoResult};
use io::net::ip::{SocketAddr, IpAddr};
use old_io::{IoResult};
use old_io::net::ip::{SocketAddr, IpAddr};
use option::Option;
use option::Option::{Some, None};
use string::String;
@ -114,7 +114,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>)
mod test {
use prelude::v1::*;
use super::*;
use io::net::ip::*;
use old_io::net::ip::*;
#[test]
fn dns_smoke_test() {

16
src/libstd/io/net/ip.rs → src/libstd/old_io/net/ip.rs
View File

@ -19,8 +19,8 @@ pub use self::IpAddr::*;
use boxed::Box;
use fmt;
use io::{self, IoResult, IoError};
use io::net;
use old_io::{self, IoResult, IoError};
use old_io::net;
use iter::{Iterator, IteratorExt};
use ops::{FnOnce, FnMut};
use option::Option;
@ -406,9 +406,9 @@ impl FromStr for SocketAddr {
/// ```rust,no_run
/// # #![allow(unused_must_use)]
///
/// use std::io::{TcpStream, TcpListener};
/// use std::io::net::udp::UdpSocket;
/// use std::io::net::ip::{Ipv4Addr, SocketAddr};
/// use std::old_io::{TcpStream, TcpListener};
/// use std::old_io::net::udp::UdpSocket;
/// use std::old_io::net::ip::{Ipv4Addr, SocketAddr};
///
/// fn main() {
/// // The following lines are equivalent modulo possible "localhost" name resolution
@ -438,7 +438,7 @@ pub trait ToSocketAddr {
fn to_socket_addr(&self) -> IoResult<SocketAddr> {
self.to_socket_addr_all()
.and_then(|v| v.into_iter().next().ok_or_else(|| IoError {
kind: io::InvalidInput,
kind: old_io::InvalidInput,
desc: "no address available",
detail: None
}))
@ -481,7 +481,7 @@ fn parse_and_resolve_socket_addr(s: &str) -> IoResult<Vec<SocketAddr>> {
match $e {
Some(r) => r,
None => return Err(IoError {
kind: io::InvalidInput,
kind: old_io::InvalidInput,
desc: $msg,
detail: None
})
@ -526,7 +526,7 @@ impl<'a> ToSocketAddr for &'a str {
parse_and_resolve_socket_addr(*self)
.and_then(|v| v.into_iter().next()
.ok_or_else(|| IoError {
kind: io::InvalidInput,
kind: old_io::InvalidInput,
desc: "no address available",
detail: None
})

2
src/libstd/io/net/mod.rs → src/libstd/old_io/net/mod.rs
View File

@ -10,7 +10,7 @@
//! Networking I/O
use io::{IoError, IoResult, InvalidInput};
use old_io::{IoError, IoResult, InvalidInput};
use ops::FnMut;
use option::Option::None;
use result::Result::{Ok, Err};

18
src/libstd/io/net/pipe.rs → src/libstd/old_io/net/pipe.rs
View File

@ -24,7 +24,7 @@ use prelude::v1::*;
use ffi::CString;
use path::BytesContainer;
use io::{Listener, Acceptor, IoResult, TimedOut, standard_error};
use old_io::{Listener, Acceptor, IoResult, TimedOut, standard_error};
use sys::pipe::UnixAcceptor as UnixAcceptorImp;
use sys::pipe::UnixListener as UnixListenerImp;
use sys::pipe::UnixStream as UnixStreamImp;
@ -48,7 +48,7 @@ impl UnixStream {
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::io::net::pipe::UnixStream;
/// use std::old_io::net::pipe::UnixStream;
///
/// let server = Path::new("path/to/my/socket");
/// let mut stream = UnixStream::connect(&server);
@ -169,8 +169,8 @@ impl UnixListener {
///
/// ```
/// # fn foo() {
/// use std::io::net::pipe::UnixListener;
/// use std::io::{Listener, Acceptor};
/// use std::old_io::net::pipe::UnixListener;
/// use std::old_io::{Listener, Acceptor};
///
/// let server = Path::new("/path/to/my/socket");
/// let stream = UnixListener::bind(&server);
@ -270,11 +270,11 @@ impl sys_common::AsInner<UnixAcceptorImp> for UnixAcceptor {
mod tests {
use prelude::v1::*;
use io::fs::PathExtensions;
use io::{EndOfFile, TimedOut, ShortWrite, IoError, ConnectionReset};
use io::{NotConnected, BrokenPipe, FileNotFound, InvalidInput, OtherIoError};
use io::{PermissionDenied, Acceptor, Listener};
use io::test::*;
use old_io::fs::PathExtensions;
use old_io::{EndOfFile, TimedOut, ShortWrite, IoError, ConnectionReset};
use old_io::{NotConnected, BrokenPipe, FileNotFound, InvalidInput, OtherIoError};
use old_io::{PermissionDenied, Acceptor, Listener};
use old_io::test::*;
use super::*;
use sync::mpsc::channel;
use thread::Thread;

38
src/libstd/io/net/tcp.rs → src/libstd/old_io/net/tcp.rs
View File

@ -18,11 +18,11 @@
//! listener (socket server) implements the `Listener` and `Acceptor` traits.
use clone::Clone;
use io::IoResult;
use old_io::IoResult;
use result::Result::Err;
use io::net::ip::{SocketAddr, ToSocketAddr};
use io::{Reader, Writer, Listener, Acceptor};
use io::{standard_error, TimedOut};
use old_io::net::ip::{SocketAddr, ToSocketAddr};
use old_io::{Reader, Writer, Listener, Acceptor};
use old_io::{standard_error, TimedOut};
use option::Option;
use option::Option::{None, Some};
use time::Duration;
@ -41,7 +41,7 @@ use sys_common;
/// # Example
///
/// ```no_run
/// use std::io::TcpStream;
/// use std::old_io::TcpStream;
///
/// {
/// let mut stream = TcpStream::connect("127.0.0.1:34254");
@ -133,8 +133,8 @@ impl TcpStream {
///
/// ```no_run
/// # #![allow(unused_must_use)]
/// use std::io::timer;
/// use std::io::TcpStream;
/// use std::old_io::timer;
/// use std::old_io::TcpStream;
/// use std::time::Duration;
/// use std::thread::Thread;
///
@ -276,8 +276,8 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
///
/// ```
/// # fn foo() {
/// use std::io::{TcpListener, TcpStream};
/// use std::io::{Acceptor, Listener};
/// use std::old_io::{TcpListener, TcpStream};
/// use std::old_io::{Acceptor, Listener};
/// use std::thread::Thread;
///
/// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
@ -373,8 +373,8 @@ impl TcpAcceptor {
///
/// ```no_run
/// # #![allow(unstable)]
/// use std::io::TcpListener;
/// use std::io::{Listener, Acceptor, TimedOut};
/// use std::old_io::TcpListener;
/// use std::old_io::{Listener, Acceptor, TimedOut};
///
/// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap();
///
@ -417,7 +417,7 @@ impl TcpAcceptor {
///
/// ```
/// # #![allow(unstable)]
/// use std::io::{TcpListener, Listener, Acceptor, EndOfFile};
/// use std::old_io::{TcpListener, Listener, Acceptor, EndOfFile};
/// use std::thread::Thread;
///
/// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap();
@ -486,13 +486,13 @@ mod test {
use sync::mpsc::channel;
use thread::Thread;
use io::net::tcp::*;
use io::net::ip::*;
use io::test::*;
use io::{EndOfFile, TimedOut, ShortWrite, IoError};
use io::{ConnectionRefused, BrokenPipe, ConnectionAborted};
use io::{ConnectionReset, NotConnected, PermissionDenied, OtherIoError};
use io::{Acceptor, Listener};
use old_io::net::tcp::*;
use old_io::net::ip::*;
use old_io::test::*;
use old_io::{EndOfFile, TimedOut, ShortWrite, IoError};
use old_io::{ConnectionRefused, BrokenPipe, ConnectionAborted};
use old_io::{ConnectionReset, NotConnected, PermissionDenied, OtherIoError};
use old_io::{Acceptor, Listener};
// FIXME #11530 this fails on android because tests are run as root
#[cfg_attr(any(windows, target_os = "android"), ignore)]

14
src/libstd/io/net/udp.rs → src/libstd/old_io/net/udp.rs
View File

@ -16,8 +16,8 @@
//! datagram protocol.
use clone::Clone;
use io::net::ip::{SocketAddr, IpAddr, ToSocketAddr};
use io::IoResult;
use old_io::net::ip::{SocketAddr, IpAddr, ToSocketAddr};
use old_io::IoResult;
use option::Option;
use sys::udp::UdpSocket as UdpSocketImp;
use sys_common;
@ -34,8 +34,8 @@ use sys_common;
/// # #![allow(unused_must_use)]
/// #![feature(slicing_syntax)]
///
/// use std::io::net::udp::UdpSocket;
/// use std::io::net::ip::{Ipv4Addr, SocketAddr};
/// use std::old_io::net::udp::UdpSocket;
/// use std::old_io::net::ip::{Ipv4Addr, SocketAddr};
/// fn main() {
/// let addr = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 34254 };
/// let mut socket = match UdpSocket::bind(addr) {
@ -181,9 +181,9 @@ mod test {
use prelude::v1::*;
use sync::mpsc::channel;
use io::net::ip::*;
use io::test::*;
use io::{IoError, TimedOut, PermissionDenied, ShortWrite};
use old_io::net::ip::*;
use old_io::test::*;
use old_io::{IoError, TimedOut, PermissionDenied, ShortWrite};
use super::*;
use thread::Thread;

6
src/libstd/io/pipe.rs → src/libstd/old_io/pipe.rs
View File

@ -17,7 +17,7 @@
use prelude::v1::*;
use io::IoResult;
use old_io::IoResult;
use libc;
use sync::Arc;
@ -49,7 +49,7 @@ impl PipeStream {
/// # #![allow(unused_must_use)]
/// extern crate libc;
///
/// use std::io::pipe::PipeStream;
/// use std::old_io::pipe::PipeStream;
///
/// fn main() {
/// let mut pipe = PipeStream::open(libc::STDERR_FILENO);
@ -120,7 +120,7 @@ mod test {
#[test]
fn partial_read() {
use os;
use io::pipe::PipeStream;
use old_io::pipe::PipeStream;
let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() };
let out = PipeStream::open(writer);

28
src/libstd/io/process.rs → src/libstd/old_io/process.rs
View File

@ -21,9 +21,9 @@ use prelude::v1::*;
use collections::HashMap;
use ffi::CString;
use fmt;
use io::pipe::{PipeStream, PipePair};
use io::{IoResult, IoError};
use io;
use old_io::pipe::{PipeStream, PipePair};
use old_io::{IoResult, IoError};
use old_io;
use libc;
use os;
use path::BytesContainer;
@ -58,7 +58,7 @@ use thread::Thread;
/// # Example
///
/// ```should_fail
/// use std::io::Command;
/// use std::old_io::Command;
///
/// let mut child = match Command::new("/bin/cat").arg("file.txt").spawn() {
/// Ok(child) => child,
@ -159,7 +159,7 @@ pub type EnvMap = HashMap<EnvKey, CString>;
/// to be changed (for example, by adding arguments) prior to spawning:
///
/// ```
/// use std::io::Command;
/// use std::old_io::Command;
///
/// let mut process = match Command::new("sh").arg("-c").arg("echo hello").spawn() {
/// Ok(p) => p,
@ -359,7 +359,7 @@ impl Command {
/// # Example
///
/// ```
/// use std::io::Command;
/// use std::old_io::Command;
///
/// let output = match Command::new("cat").arg("foot.txt").output() {
/// Ok(output) => output,
@ -380,7 +380,7 @@ impl Command {
/// # Example
///
/// ```
/// use std::io::Command;
/// use std::old_io::Command;
///
/// let status = match Command::new("ls").status() {
/// Ok(status) => status,
@ -583,7 +583,7 @@ impl Process {
// newer process that happens to have the same (re-used) id
if self.exit_code.is_some() {
return Err(IoError {
kind: io::InvalidInput,
kind: old_io::InvalidInput,
desc: "invalid argument: can't kill an exited process",
detail: None,
})
@ -654,8 +654,8 @@ impl Process {
///
/// ```no_run
/// # #![allow(unstable)]
/// use std::io::{Command, IoResult};
/// use std::io::process::ProcessExit;
/// use std::old_io::{Command, IoResult};
/// use std::old_io::process::ProcessExit;
///
/// fn run_gracefully(prog: &str) -> IoResult<ProcessExit> {
/// let mut p = try!(Command::new("long-running-process").spawn());
@ -698,7 +698,7 @@ impl Process {
/// fail.
pub fn wait_with_output(mut self) -> IoResult<ProcessOutput> {
drop(self.stdin.take());
fn read(stream: Option<io::PipeStream>) -> Receiver<IoResult<Vec<u8>>> {
fn read(stream: Option<old_io::PipeStream>) -> Receiver<IoResult<Vec<u8>>> {
let (tx, rx) = channel();
match stream {
Some(stream) => {
@ -752,12 +752,12 @@ impl Drop for Process {
#[cfg(test)]
mod tests {
use io::{Truncate, Write, TimedOut, timer, process, FileNotFound};
use old_io::{Truncate, Write, TimedOut, timer, process, FileNotFound};
use prelude::v1::{Ok, Err, range, drop, Some, None, Vec};
use prelude::v1::{Path, String, Reader, Writer, Clone};
use prelude::v1::{SliceExt, Str, StrExt, AsSlice, ToString, GenericPath};
use io::fs::PathExtensions;
use io::timer::*;
use old_io::fs::PathExtensions;
use old_io::timer::*;
use rt::running_on_valgrind;
use str;
use super::{CreatePipe};

0
src/libstd/io/result.rs → src/libstd/old_io/result.rs
View File

10
src/libstd/io/stdio.rs → src/libstd/old_io/stdio.rs
View File

@ -21,7 +21,7 @@
//! # #![allow(unused_must_use)]
//! use std::io;
//!
//! let mut out = io::stdout();
//! let mut out = old_io::stdout();
//! out.write(b"Hello, world!");
//! ```
@ -32,7 +32,7 @@ use cell::RefCell;
use clone::Clone;
use failure::LOCAL_STDERR;
use fmt;
use io::{Reader, Writer, IoResult, IoError, OtherIoError, Buffer,
use old_io::{Reader, Writer, IoResult, IoError, OtherIoError, Buffer,
standard_error, EndOfFile, LineBufferedWriter, BufferedReader};
use marker::{Sync, Send};
use libc;
@ -143,7 +143,7 @@ impl StdinReader {
/// ```rust
/// use std::io;
///
/// for line in io::stdin().lock().lines() {
/// for line in old_io::stdin().lock().lines() {
/// println!("{}", line.unwrap());
/// }
/// ```
@ -539,7 +539,7 @@ mod tests {
#[test]
fn capture_stdout() {
use io::{ChanReader, ChanWriter};
use old_io::{ChanReader, ChanWriter};
let (tx, rx) = channel();
let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
@ -552,7 +552,7 @@ mod tests {
#[test]
fn capture_stderr() {
use io::{ChanReader, ChanWriter, Reader};
use old_io::{ChanReader, ChanWriter, Reader};
let (tx, rx) = channel();
let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));

8
src/libstd/io/tempfile.rs → src/libstd/old_io/tempfile.rs
View File

@ -10,8 +10,8 @@
//! Temporary files and directories
use io::{fs, IoError, IoErrorKind, IoResult};
use io;
use old_io::{fs, IoError, IoErrorKind, IoResult};
use old_io;
use iter::{IteratorExt, range};
use ops::Drop;
use option::Option;
@ -29,7 +29,7 @@ use string::String;
/// # Examples
///
/// ```no_run
/// use std::io::TempDir;
/// use std::old_io::TempDir;
///
/// {
/// // create a temporary directory
@ -113,7 +113,7 @@ impl TempDir {
suffix
};
let path = tmpdir.join(leaf);
match fs::mkdir(&path, io::USER_RWX) {
match fs::mkdir(&path, old_io::USER_RWX) {
Ok(_) => return Ok(TempDir { path: Some(path), disarmed: false }),
Err(IoError{kind:IoErrorKind::PathAlreadyExists,..}) => (),
Err(e) => return Err(e)

2
src/libstd/io/test.rs → src/libstd/old_io/test.rs
View File

@ -14,7 +14,7 @@ use prelude::v1::*;
use libc;
use os;
use std::io::net::ip::*;
use std::old_io::net::ip::*;
use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
/// Get a port number, starting at 9600, for use in tests

16
src/libstd/io/timer.rs → src/libstd/old_io/timer.rs
View File

@ -17,7 +17,7 @@
use sync::mpsc::{Receiver, Sender, channel};
use time::Duration;
use io::IoResult;
use old_io::IoResult;
use sys::timer::Callback;
use sys::timer::Timer as TimerImp;
@ -31,7 +31,7 @@ use sys::timer::Timer as TimerImp;
///
/// ```
/// # fn foo() {
/// use std::io::Timer;
/// use std::old_io::Timer;
/// use std::time::Duration;
///
/// let mut timer = Timer::new().unwrap();
@ -50,11 +50,11 @@ use sys::timer::Timer as TimerImp;
/// ```
///
/// If only sleeping is necessary, then a convenience API is provided through
/// the `io::timer` module.
/// the `old_io::timer` module.
///
/// ```
/// # fn foo() {
/// use std::io::timer;
/// use std::old_io::timer;
/// use std::time::Duration;
///
/// // Put this task to sleep for 5 seconds
@ -115,7 +115,7 @@ impl Timer {
/// # Example
///
/// ```rust
/// use std::io::Timer;
/// use std::old_io::Timer;
/// use std::time::Duration;
///
/// let mut timer = Timer::new().unwrap();
@ -128,7 +128,7 @@ impl Timer {
/// ```
///
/// ```rust
/// use std::io::Timer;
/// use std::old_io::Timer;
/// use std::time::Duration;
///
/// // Incorrect, method chaining-style:
@ -167,7 +167,7 @@ impl Timer {
/// # Example
///
/// ```rust
/// use std::io::Timer;
/// use std::old_io::Timer;
/// use std::time::Duration;
///
/// let mut timer = Timer::new().unwrap();
@ -186,7 +186,7 @@ impl Timer {
/// ```
///
/// ```rust
/// use std::io::Timer;
/// use std::old_io::Timer;
/// use std::time::Duration;
///
/// // Incorrect, method chaining-style.

54
src/libstd/io/util.rs → src/libstd/old_io/util.rs
View File

@ -12,7 +12,7 @@
use prelude::v1::*;
use cmp;
use io;
use old_io;
use slice::bytes::MutableByteVector;
/// Wraps a `Reader`, limiting the number of bytes that can be read from it.
@ -42,9 +42,9 @@ impl<R: Reader> LimitReader<R> {
}
impl<R: Reader> Reader for LimitReader<R> {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
if self.limit == 0 {
return Err(io::standard_error(io::EndOfFile));
return Err(old_io::standard_error(old_io::EndOfFile));
}
let len = cmp::min(self.limit, buf.len());
@ -58,11 +58,11 @@ impl<R: Reader> Reader for LimitReader<R> {
}
impl<R: Buffer> Buffer for LimitReader<R> {
fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
fn fill_buf<'a>(&'a mut self) -> old_io::IoResult<&'a [u8]> {
let amt = try!(self.inner.fill_buf());
let buf = &amt[..cmp::min(amt.len(), self.limit)];
if buf.len() == 0 {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
} else {
Ok(buf)
}
@ -83,7 +83,7 @@ pub struct NullWriter;
impl Writer for NullWriter {
#[inline]
fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> { Ok(()) }
fn write(&mut self, _buf: &[u8]) -> old_io::IoResult<()> { Ok(()) }
}
/// A `Reader` which returns an infinite stream of 0 bytes, like /dev/zero.
@ -92,14 +92,14 @@ pub struct ZeroReader;
impl Reader for ZeroReader {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
buf.set_memory(0);
Ok(buf.len())
}
}
impl Buffer for ZeroReader {
fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
fn fill_buf<'a>(&'a mut self) -> old_io::IoResult<&'a [u8]> {
static DATA: [u8; 64] = [0; 64];
Ok(DATA.as_slice())
}
@ -113,14 +113,14 @@ pub struct NullReader;
impl Reader for NullReader {
#[inline]
fn read(&mut self, _buf: &mut [u8]) -> io::IoResult<uint> {
Err(io::standard_error(io::EndOfFile))
fn read(&mut self, _buf: &mut [u8]) -> old_io::IoResult<uint> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
impl Buffer for NullReader {
fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
Err(io::standard_error(io::EndOfFile))
fn fill_buf<'a>(&'a mut self) -> old_io::IoResult<&'a [u8]> {
Err(old_io::standard_error(old_io::EndOfFile))
}
fn consume(&mut self, _amt: uint) {}
}
@ -143,7 +143,7 @@ impl<W> MultiWriter<W> where W: Writer {
impl<W> Writer for MultiWriter<W> where W: Writer {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::IoResult<()> {
fn write(&mut self, buf: &[u8]) -> old_io::IoResult<()> {
for writer in self.writers.iter_mut() {
try!(writer.write(buf));
}
@ -151,7 +151,7 @@ impl<W> Writer for MultiWriter<W> where W: Writer {
}
#[inline]
fn flush(&mut self) -> io::IoResult<()> {
fn flush(&mut self) -> old_io::IoResult<()> {
for writer in self.writers.iter_mut() {
try!(writer.flush());
}
@ -176,13 +176,13 @@ impl<R: Reader, I: Iterator<Item=R>> ChainedReader<I, R> {
}
impl<R: Reader, I: Iterator<Item=R>> Reader for ChainedReader<I, R> {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
loop {
let err = match self.cur_reader {
Some(ref mut r) => {
match r.read(buf) {
Ok(len) => return Ok(len),
Err(ref e) if e.kind == io::EndOfFile => None,
Err(ref e) if e.kind == old_io::EndOfFile => None,
Err(e) => Some(e),
}
}
@ -194,7 +194,7 @@ impl<R: Reader, I: Iterator<Item=R>> Reader for ChainedReader<I, R> {
None => {}
}
}
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
}
}
@ -221,7 +221,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
}
impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
self.reader.read(buf).and_then(|len| {
self.writer.write(&mut buf[..len]).map(|()| len)
})
@ -229,12 +229,12 @@ impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
}
/// Copies all data from a `Reader` to a `Writer`.
pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> old_io::IoResult<()> {
let mut buf = [0; super::DEFAULT_BUF_SIZE];
loop {
let len = match r.read(&mut buf) {
Ok(len) => len,
Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
Err(ref e) if e.kind == old_io::EndOfFile => return Ok(()),
Err(e) => return Err(e),
};
try!(w.write(&buf[..len]));
@ -257,14 +257,14 @@ impl<T: Iterator<Item=u8>> IterReader<T> {
impl<T: Iterator<Item=u8>> Reader for IterReader<T> {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
let mut len = 0;
for (slot, elt) in buf.iter_mut().zip(self.iter.by_ref()) {
*slot = elt;
len += 1;
}
if len == 0 && buf.len() != 0 {
Err(io::standard_error(io::EndOfFile))
Err(old_io::standard_error(old_io::EndOfFile))
} else {
Ok(len)
}
@ -275,7 +275,7 @@ impl<T: Iterator<Item=u8>> Reader for IterReader<T> {
mod test {
use prelude::v1::*;
use io::{MemReader, ByRefReader};
use old_io::{MemReader, ByRefReader};
use io;
use super::*;
@ -347,12 +347,12 @@ mod test {
struct TestWriter;
impl Writer for TestWriter {
fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> {
fn write(&mut self, _buf: &[u8]) -> old_io::IoResult<()> {
unsafe { writes += 1 }
Ok(())
}
fn flush(&mut self) -> io::IoResult<()> {
fn flush(&mut self) -> old_io::IoResult<()> {
unsafe { flushes += 1 }
Ok(())
}
@ -400,7 +400,7 @@ mod test {
let mut r = LimitReader::new(r.by_ref(), 3);
assert_eq!(r.read_line(), Ok("012".to_string()));
assert_eq!(r.limit(), 0);
assert_eq!(r.read_line().err().unwrap().kind, io::EndOfFile);
assert_eq!(r.read_line().err().unwrap().kind, old_io::EndOfFile);
}
{
let mut r = LimitReader::new(r.by_ref(), 9);
@ -432,7 +432,7 @@ mod test {
assert_eq!(len, 2);
assert!(buf == [6, 7, 5]);
assert_eq!(r.read(&mut buf).unwrap_err().kind, io::EndOfFile);
assert_eq!(r.read(&mut buf).unwrap_err().kind, old_io::EndOfFile);
}
#[test]