src/libstd/old_io/result.rs

   1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Implementations of I/O traits for the IoResult type
  12 //!
  13 //! I/O constructors return option types to allow errors to be handled.
  14 //! These implementations allow e.g. `IoResult<File>` to be used
  15 //! as a `Reader` without unwrapping the result first.
  16
  17 use clone::Clone;
  18 use result::Result::{Ok, Err};
  19 use super::{Reader, Writer, Listener, Acceptor, Seek, SeekStyle, IoResult};
  20
  21 impl<W: Writer> Writer for IoResult<W> {
  22     fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
  23         match *self {
  24             Ok(ref mut writer) => writer.write_all(buf),
  25             Err(ref e) => Err((*e).clone())
  26         }
  27     }
  28
  29     fn flush(&mut self) -> IoResult<()> {
  30         match *self {
  31             Ok(ref mut writer) => writer.flush(),
  32             Err(ref e) => Err(e.clone()),
  33         }
  34     }
  35 }
  36
  37 impl<R: Reader> Reader for IoResult<R> {
  38     fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
  39         match *self {
  40             Ok(ref mut reader) => reader.read(buf),
  41             Err(ref e) => Err(e.clone()),
  42         }
  43     }
  44 }
  45
  46 impl<S: Seek> Seek for IoResult<S> {
  47     fn tell(&self) -> IoResult<u64> {
  48         match *self {
  49             Ok(ref seeker) => seeker.tell(),
  50             Err(ref e) => Err(e.clone()),
  51         }
  52     }
  53     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
  54         match *self {
  55             Ok(ref mut seeker) => seeker.seek(pos, style),
  56             Err(ref e) => Err(e.clone())
  57         }
  58     }
  59 }
  60
  61 impl<A: Acceptor, L: Listener<A>> Listener<A> for IoResult<L> {
  62     fn listen(self) -> IoResult<A> {
  63         match self {
  64             Ok(listener) => listener.listen(),
  65             Err(e) => Err(e),
  66         }
  67     }
  68 }
  69
  70 impl<A: Acceptor> Acceptor for IoResult<A> {
  71     type Connection = A::Connection;
  72     fn accept(&mut self) -> IoResult<A::Connection> {
  73         match *self {
  74             Ok(ref mut acceptor) => acceptor.accept(),
  75             Err(ref e) => Err(e.clone()),
  76         }
  77     }
  78 }
  79
  80 #[cfg(test)]
  81 mod test {
  82     use prelude::v1::*;
  83     use super::super::mem::*;
  84     use old_io::{self, Reader, Writer};
  85
  86     #[test]
  87     fn test_option_writer() {
  88         let mut writer: old_io::IoResult<Vec<u8>> = Ok(Vec::new());
  89         writer.write_all(&[0, 1, 2]).unwrap();
  90         writer.flush().unwrap();
  91         assert_eq!(writer.unwrap(), [0, 1, 2]);
  92     }
  93
  94     #[test]
  95     fn test_option_writer_error() {
  96         let mut writer: old_io::IoResult<Vec<u8>> =
  97             Err(old_io::standard_error(old_io::EndOfFile));
  98
  99         match writer.write_all(&[0, 0, 0]) {
 100             Ok(..) => panic!(),
 101             Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
 102         }
 103         match writer.flush() {
 104             Ok(..) => panic!(),
 105             Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
 106         }
 107     }
 108
 109     #[test]
 110     fn test_option_reader() {
 111         let mut reader: old_io::IoResult<MemReader> =
 112             Ok(MemReader::new(vec!(0, 1, 2, 3)));
 113         let mut buf = [0, 0];
 114         reader.read(&mut buf).unwrap();
 115         let b: &[_] = &[0, 1];
 116         assert_eq!(buf, b);
 117     }
 118
 119     #[test]
 120     fn test_option_reader_error() {
 121         let mut reader: old_io::IoResult<MemReader> =
 122             Err(old_io::standard_error(old_io::EndOfFile));
 123         let mut buf = [];
 124
 125         match reader.read(&mut buf) {
 126             Ok(..) => panic!(),
 127             Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
 128         }
 129     }
 130 }