将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版本：rustc 0.13.0-nightly（eedfc0779 2014年11月25日22:36:59 +0000）

- Nicholas Bishop

Answer 1

是的，该数据类型的原始路径是std::io::buffered::BufferedReader。但在那里它不是公共的，整个buffered模块都是私有的。它作为std::io::BufferedReader导出，这是您应该从中使用它的路径，独占地使用它。

此外，如果您只想使用它，返回类型Lines<'a, BufferedReader<R>>（甚至给它一个别名，type S<'a, R: 'a> = Lines<'a, BufferedReader<R>>）也是完全可以的。

- Chris Morgan

---

谢谢，那很有帮助。修复那个错误导致我遇到了各种其他错误，但我认为现在我已经有了一个基本可行的解决方案，我会将其作为一个单独的答案发布。 - Nicholas Bishop

Answer 2

这里有一个看起来可行的解决方案：

// 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);
}

- Nicholas Bishop