在结构中存储 BufferedReader 行迭代器答案

【问题标题】：Storing a BufferedReader line iterator in a struct在结构中存储 BufferedReader 行迭代器
【发布时间】：2015-01-25 11:32:13
【问题描述】：

我应该使用什么类型将 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)

【问题讨论】：

标签： rust

【解决方案1】：

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

另外，如果你只想使用它，返回类型Lines<'a, BufferedReader<R>>（或者甚至给它一个别名，type S<'a, R: 'a> = Lines<'a, BufferedReader<R>>）是非常好的。

【讨论】：

谢谢，有帮助。修复该错误导致我陷入各种其他错误，但我认为我现在有了一个可行的解决方案，我将作为单独的答案发布。

【解决方案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);
}

【讨论】：