在结构中存储BufferedReader行迭代器

Question

我应该使用什么类型来将BufferedReader行迭代器存储在结构中？以下是我尝试过的：

struct S<'a, R: 'a> {
    iter: std::io::Lines<'a, std::io::buffered::BufferedReader<R>>
}

pub fn read<'a, A, R: std::io::Reader>(reader: R) -> S<'a, R> {
    let mut br = std::io::BufferedReader::new(reader);
    S { iter: br.lines() }
}

#[test]
fn test() {
    let mut reader = std::io::BufReader::new("test".as_bytes());
    read(reader);
}

此输出的编译失败：

/home/nicholasbishop/rust-so-test-00/src/lib.rs:11:30: 11:66 error: struct `BufferedReader` is private
/home/nicholasbishop/rust-so-test-00/src/lib.rs:11     iter: std::io::Lines<'a, std::io::buffered::BufferedReader<R>>
                                                                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
Build failed, waiting for other jobs to finish...
/home/nicholasbishop/rust-so-test-00/src/lib.rs:22:5: 22:9 error: unable to infer enough type information about `_`; type annotations required
/home/nicholasbishop/rust-so-test-00/src/lib.rs:22     read(reader);
                                                   ^~~~

版本: rustc 0.13.0-每晚(eedfc0779 2014-11-25 22:36:59 +0000)

Answer 1

以下是一个可行的解决方案：

// Tested with: rustc 0.13.0-nightly (eedfc0779 2014-11-25 22:36:59 +0000)

use std::io::BufferedReader;

pub struct S<'a, R: Reader + 'a> {
    reader: BufferedReader<R>,
    iter: Option<std::io::Lines<'a, BufferedReader<R>>>
}

impl<'a, R: Reader> S<'a, R> {
    pub fn new<R: Reader>(reader: R) -> S<'a, R> {
        S { reader: BufferedReader::new(reader), iter: None }
    }

    // It seems like this code could live in Iterator::next, but I get
    // an error because the explicit lifetime for the self parameter
    // seems to be necessary for this code, but the Iterator trait
    // doesn't expect that and fails to compile. Having it call this
    // helper method seems to infer the correct thing.
    fn init_iter(&'a mut self) {
        match self.iter {
            None => {
                self.iter = Some(self.reader.lines());
            }
            _ => {
            }    
        }
    }
}

impl<'a, R: Reader> Iterator<String> for S<'a, R> {
    fn next(&mut self) -> Option<String> {
        self.init_iter();

        match self.iter {
            Some(ref mut iter) => {
                match iter.next() {
                    Some(line) => {
                        Some(line.unwrap())
                    }
                    None => {
                        None
                    }
                }
            }
            None => {
                None
            }
        }
    }
}

pub fn read<'a, R: Reader>(reader: R) -> S<'a, R> {
    S::<R>::new(reader)
}

#[test]
fn test1() {
    let reader = std::io::BufReader::new("a\nb\n".as_bytes());
    let mut iter = read(reader);
    assert!(iter.next().unwrap().as_slice() == "a\n");
    assert!(iter.next().unwrap().as_slice() == "b\n");
    assert!(iter.next() == None);
}

Answer 2

是的，该数据类型的原始路径是std::io::buffered::BufferedReader。但是它不是公开的，因为整个buffered模块都是私有的。它是作为std::io::BufferedReader导出的，这是您应该使用它的专用路径。

而且，如果您只想使用它，返回Lines<'a, BufferedReader<R>>类型(甚至给它提供别名，type S<'a, R: 'a> = Lines<'a, BufferedReader<R>>)是非常好的。