pub use self::IoErrorKind::*;
use char::CharExt;
-use clone::Clone;
use default::Default;
-use error::{FromError, Error};
+use error::Error;
use fmt;
use int;
use iter::{Iterator, IteratorExt};
}
}
-impl fmt::String for IoError {
+#[stable]
+impl fmt::Display for IoError {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
IoError { kind: OtherIoError, desc: "unknown error", detail: Some(ref detail) } =>
}
impl Error for IoError {
- fn description(&self) -> &str {
- self.desc
- }
-
- fn detail(&self) -> Option<String> {
- self.detail.clone()
- }
-}
-
-impl FromError<IoError> for Box<Error> {
- fn from_error(err: IoError) -> Box<Error> {
- box err
- }
+ fn description(&self) -> &str { self.desc }
}
/// A list specifying general categories of I/O error.
/// A `RefReader` is a struct implementing `Reader` which contains a reference
/// to another reader. This is often useful when composing streams.
///
-/// # Example
+/// # Examples
///
/// ```
-/// # fn main() {}
-/// # fn process_input<R: Reader>(r: R) {}
-/// # fn foo() {
/// use std::io;
/// use std::io::ByRefReader;
/// use std::io::util::LimitReader;
///
+/// fn process_input<R: Reader>(r: R) {}
+///
/// let mut stream = io::stdin();
///
/// // Only allow the function to process at most one kilobyte of input
/// }
///
/// // 'stream' is still available for use here
-///
-/// # }
/// ```
pub struct RefReader<'a, R:'a> {
/// The underlying reader which this is referencing
/// # Example
///
/// ```
-/// # fn main() {}
-/// # fn process_input<R: Reader>(r: R) {}
-/// # fn foo () {
/// use std::io::util::TeeReader;
/// use std::io::{stdin, ByRefWriter};
///
+/// fn process_input<R: Reader>(r: R) {}
+///
/// let mut output = Vec::new();
///
/// {
/// }
///
/// println!("input processed: {:?}", output);
-/// # }
/// ```
pub struct RefWriter<'a, W:'a> {
/// The underlying writer which this is referencing
/// A structure used to describe metadata information about a file. This
/// structure is created through the `stat` method on a `Path`.
///
-/// # Example
+/// # Examples
+///
+/// ```no_run
+/// # #![allow(unstable)]
+///
+/// use std::io::fs::PathExtensions;
///
-/// ```
-/// # use std::io::fs::PathExtensions;
-/// # fn main() {}
-/// # fn foo() {
/// let info = match Path::new("foo.txt").stat() {
/// Ok(stat) => stat,
/// Err(e) => panic!("couldn't read foo.txt: {}", e),
/// };
///
/// println!("byte size: {}", info.size);
-/// # }
/// ```
#[derive(Copy, Hash)]
pub struct FileStat {
bitflags! {
/// A set of permissions for a file or directory is represented by a set of
/// flags which are or'd together.
+ #[derive(Show)]
flags FilePermission: u32 {
const USER_READ = 0o400,
const USER_WRITE = 0o200,
fn default() -> FilePermission { FilePermission::empty() }
}
-impl fmt::Show for FilePermission {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::String::fmt(self, f)
- }
-}
-
-impl fmt::String for FilePermission {
+#[stable]
+impl fmt::Display for FilePermission {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:04o}", self.bits)
}