let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
let mut reader = BufferedReader::with_capacity(2, in_buf);
let mut it = reader.lines();
- assert_eq!(it.next(), Some(~"a\n"));
- assert_eq!(it.next(), Some(~"b\n"));
- assert_eq!(it.next(), Some(~"c"));
+ assert_eq!(it.next(), Some(Ok(~"a\n")));
+ assert_eq!(it.next(), Some(Ok(~"b\n")));
+ assert_eq!(it.next(), Some(Ok(~"c")));
assert_eq!(it.next(), None);
}
let buf = [195u8, 159u8, 'a' as u8];
let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
let mut it = reader.chars();
- assert_eq!(it.next(), Some('ß'));
- assert_eq!(it.next(), Some('a'));
+ assert_eq!(it.next(), Some(Ok('ß')));
+ assert_eq!(it.next(), Some(Ok('a')));
assert_eq!(it.next(), None);
}
use container::Container;
use iter::Iterator;
-use option::Option;
-use io::Reader;
+use option::{Option, Some, None};
+use result::{Ok, Err};
+use io;
+use io::{IoError, IoResult, Reader};
use vec::{OwnedVector, ImmutableVector};
use ptr::RawPtr;
/// An iterator that reads a single byte on each iteration,
-/// until `.read_byte()` returns `None`.
+/// until `.read_byte()` returns `EndOfFile`.
///
/// # Notes about the Iteration Protocol
///
/// an iteration, but continue to yield elements if iteration
/// is attempted again.
///
-/// # Failure
+/// # Error
///
-/// Raises the same conditions as the `read` method, for
-/// each call to its `.next()` method.
-/// Yields `None` if the condition is handled.
+/// Any error other than `EndOfFile` that is produced by the underlying Reader
+/// is returned by the iterator and should be handled by the caller.
pub struct Bytes<'r, T> {
priv reader: &'r mut T,
}
}
}
-impl<'r, R: Reader> Iterator<u8> for Bytes<'r, R> {
+impl<'r, R: Reader> Iterator<IoResult<u8>> for Bytes<'r, R> {
#[inline]
- fn next(&mut self) -> Option<u8> {
- self.reader.read_byte().ok()
+ fn next(&mut self) -> Option<IoResult<u8>> {
+ match self.reader.read_byte() {
+ Ok(x) => Some(Ok(x)),
+ Err(IoError { kind: io::EndOfFile, .. }) => None,
+ Err(e) => Some(Err(e))
+ }
}
}
count: 0,
};
let byte = reader.bytes().next();
- assert!(byte == Some(10));
+ assert!(byte == Some(Ok(10)));
}
#[test]
let mut reader = ErroringReader;
let mut it = reader.bytes();
let byte = it.next();
- assert!(byte.is_none());
+ assert!(byte.unwrap().is_err());
}
#[test]
use std::io;
for line in io::stdin().lines() {
- print!("{}", line);
+ print!("{}", line.unwrap());
}
```
* Iterate over the lines of a file
- ```rust
+ ```rust,no_run
use std::io::BufferedReader;
use std::io::File;
let path = Path::new("message.txt");
let mut file = BufferedReader::new(File::open(&path));
for line in file.lines() {
- print!("{}", line);
+ print!("{}", line.unwrap());
}
```
* Pull the lines of a file into a vector of strings
- ```rust
+ ```rust,no_run
use std::io::BufferedReader;
use std::io::File;
let path = Path::new("message.txt");
let mut file = BufferedReader::new(File::open(&path));
- let lines: ~[~str] = file.lines().collect();
+ let lines: ~[~str] = file.lines().map(|x| x.unwrap()).collect();
```
* Make a simple TCP client connection and request
///
/// # Error
///
- /// The iterator protocol causes all specifics about errors encountered to
- /// be swallowed. All errors will be signified by returning `None` from the
- /// iterator. If this is undesirable, it is recommended to use the
- /// `read_byte` method.
+ /// Any error other than `EndOfFile` that is produced by the underlying Reader
+ /// is returned by the iterator and should be handled by the caller.
fn bytes<'r>(&'r mut self) -> extensions::Bytes<'r, Self> {
extensions::Bytes::new(self)
}
impl<T: Reader + Writer> Stream for T {}
/// An iterator that reads a line on each iteration,
-/// until `.read_line()` returns `None`.
+/// until `.read_line()` encounters `EndOfFile`.
///
/// # Notes about the Iteration Protocol
///
///
/// # Error
///
-/// This iterator will swallow all I/O errors, transforming `Err` values to
-/// `None`. If errors need to be handled, it is recommended to use the
-/// `read_line` method directly.
+/// Any error other than `EndOfFile` that is produced by the underlying Reader
+/// is returned by the iterator and should be handled by the caller.
pub struct Lines<'r, T> {
priv buffer: &'r mut T,
}
-impl<'r, T: Buffer> Iterator<~str> for Lines<'r, T> {
- fn next(&mut self) -> Option<~str> {
- self.buffer.read_line().ok()
+impl<'r, T: Buffer> Iterator<IoResult<~str>> for Lines<'r, T> {
+ fn next(&mut self) -> Option<IoResult<~str>> {
+ match self.buffer.read_line() {
+ Ok(x) => Some(Ok(x)),
+ Err(IoError { kind: EndOfFile, ..}) => None,
+ Err(y) => Some(Err(y))
+ }
}
}
/// An iterator that reads a utf8-encoded character on each iteration,
-/// until `.read_char()` returns `None`.
+/// until `.read_char()` encounters `EndOfFile`.
///
/// # Notes about the Iteration Protocol
///
///
/// # Error
///
-/// This iterator will swallow all I/O errors, transforming `Err` values to
-/// `None`. If errors need to be handled, it is recommended to use the
-/// `read_char` method directly.
+/// Any error other than `EndOfFile` that is produced by the underlying Reader
+/// is returned by the iterator and should be handled by the caller.
pub struct Chars<'r, T> {
priv buffer: &'r mut T
}
-impl<'r, T: Buffer> Iterator<char> for Chars<'r, T> {
- fn next(&mut self) -> Option<char> {
- self.buffer.read_char().ok()
+impl<'r, T: Buffer> Iterator<IoResult<char>> for Chars<'r, T> {
+ fn next(&mut self) -> Option<IoResult<char>> {
+ match self.buffer.read_char() {
+ Ok(x) => Some(Ok(x)),
+ Err(IoError { kind: EndOfFile, ..}) => None,
+ Err(y) => Some(Err(y))
+ }
}
}
///
/// # Error
///
- /// This iterator will transform all error values to `None`, discarding the
- /// cause of the error. If this is undesirable, it is recommended to call
- /// `read_line` directly.
+ /// Any error other than `EndOfFile` that is produced by the underlying Reader
+ /// is returned by the iterator and should be handled by the caller.
fn lines<'r>(&'r mut self) -> Lines<'r, Self> {
Lines { buffer: self }
}
///
/// # Error
///
- /// This iterator will transform all error values to `None`, discarding the
- /// cause of the error. If this is undesirable, it is recommended to call
- /// `read_char` directly.
+ /// Any error other than `EndOfFile` that is produced by the underlying Reader
+ /// is returned by the iterator and should be handled by the caller.
fn chars<'r>(&'r mut self) -> Chars<'r, Self> {
Chars { buffer: self }
}