02882fbd7e
Formatting via reflection has been a little questionable for some time now, and
it's a little unfortunate that one of the standard macros will silently use
reflection when you weren't expecting it. This adds small bits of code bloat to
libraries, as well as not always being necessary. In light of this information,
this commit switches assert_eq!() to using {} in the error message instead of
{:?}.
In updating existing code, there were a few error cases that I encountered:
* It's impossible to define Show for [T, ..N]. I think DST will alleviate this
because we can define Show for [T].
* A few types here and there just needed a #[deriving(Show)]
* Type parameters needed a Show bound, I often moved this to `assert!(a == b)`
* `Path` doesn't implement `Show`, so assert_eq!() cannot be used on two paths.
I don't think this is much of a regression though because {:?} on paths looks
awful (it's a byte array).
Concretely speaking, this shaved 10K off a 656K binary. Not a lot, but sometime
significant for smaller binaries.
129 lines
3.6 KiB
Rust
129 lines
3.6 KiB
Rust
// Copyright 2013 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.
|
|
|
|
//! Implementations of I/O traits for the IoResult type
|
|
//!
|
|
//! I/O constructors return option types to allow errors to be handled.
|
|
//! These implementations allow e.g. `IoResult<File>` to be used
|
|
//! as a `Reader` without unwrapping the result first.
|
|
|
|
use clone::Clone;
|
|
use result::{Ok, Err};
|
|
use super::{Reader, Writer, Listener, Acceptor, Seek, SeekStyle, IoResult};
|
|
|
|
impl<W: Writer> Writer for IoResult<W> {
|
|
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
|
|
match *self {
|
|
Ok(ref mut writer) => writer.write(buf),
|
|
Err(ref e) => Err((*e).clone())
|
|
}
|
|
}
|
|
|
|
fn flush(&mut self) -> IoResult<()> {
|
|
match *self {
|
|
Ok(ref mut writer) => writer.flush(),
|
|
Err(ref e) => Err(e.clone()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<R: Reader> Reader for IoResult<R> {
|
|
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
|
|
match *self {
|
|
Ok(ref mut reader) => reader.read(buf),
|
|
Err(ref e) => Err(e.clone()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<S: Seek> Seek for IoResult<S> {
|
|
fn tell(&self) -> IoResult<u64> {
|
|
match *self {
|
|
Ok(ref seeker) => seeker.tell(),
|
|
Err(ref e) => Err(e.clone()),
|
|
}
|
|
}
|
|
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
|
|
match *self {
|
|
Ok(ref mut seeker) => seeker.seek(pos, style),
|
|
Err(ref e) => Err(e.clone())
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T, A: Acceptor<T>, L: Listener<T, A>> Listener<T, A> for IoResult<L> {
|
|
fn listen(self) -> IoResult<A> {
|
|
match self {
|
|
Ok(listener) => listener.listen(),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T, A: Acceptor<T>> Acceptor<T> for IoResult<A> {
|
|
fn accept(&mut self) -> IoResult<T> {
|
|
match *self {
|
|
Ok(ref mut acceptor) => acceptor.accept(),
|
|
Err(ref e) => Err(e.clone()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use prelude::*;
|
|
use super::super::mem::*;
|
|
use io;
|
|
|
|
#[test]
|
|
fn test_option_writer() {
|
|
let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new());
|
|
writer.write([0, 1, 2]).unwrap();
|
|
writer.flush().unwrap();
|
|
assert_eq!(writer.unwrap().unwrap(), ~[0, 1, 2]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_option_writer_error() {
|
|
let mut writer: io::IoResult<MemWriter> =
|
|
Err(io::standard_error(io::EndOfFile));
|
|
|
|
match writer.write([0, 0, 0]) {
|
|
Ok(..) => fail!(),
|
|
Err(e) => assert_eq!(e.kind, io::EndOfFile),
|
|
}
|
|
match writer.flush() {
|
|
Ok(..) => fail!(),
|
|
Err(e) => assert_eq!(e.kind, io::EndOfFile),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_option_reader() {
|
|
let mut reader: io::IoResult<MemReader> =
|
|
Ok(MemReader::new(~[0, 1, 2, 3]));
|
|
let mut buf = [0, 0];
|
|
reader.read(buf).unwrap();
|
|
assert_eq!(buf.as_slice(), &[0, 1]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_option_reader_error() {
|
|
let mut reader: io::IoResult<MemReader> =
|
|
Err(io::standard_error(io::EndOfFile));
|
|
let mut buf = [];
|
|
|
|
match reader.read(buf) {
|
|
Ok(..) => fail!(),
|
|
Err(e) => assert_eq!(e.kind, io::EndOfFile),
|
|
}
|
|
}
|
|
}
|