在开发 Rust 程序的时候,会使用到各式各样别人开发的套件。这些套件虽然很方便,可以替我们节省不少开发时间,但是套件提供的 API,却不一定能够完全满足我们的需求。「Reader」的拥有权被取走,就是一个常见的例子。

有些套件定义的 API,会需要输入有实作 Read 特性的实体,来作为数据的输入来源。以 Rust 标准函数库提供的 Vec<u8> 结构体来说,它本身虽然并没有实作 Read 特性,但是可以借由使用 Cursor 结构体来包裹 Vec<u8> 结构实体,使其也能拥有 Read 特性。例如以下程序:

use std::io::{self, Read, Cursor};

fn read_to_string<R: Read>(mut reader: R) -> Result<String, io::Error> {
    let mut s = String::new();

    reader.read_to_string(&mut s)?;

    Ok(s)
}

...

let data: Vec<u8> = vec![48, 49, 50, 51, 52];

let result = read_to_string(Cursor::new(data)).unwrap();

assert_eq!("01234".to_string(), result);

在这个程序中,read_to_string 函数要传入一个有实作 Read 特性的类型的实体,所以我们把 data 这个 Vec<u8> 结构实体包裹进 Cursor 结构体中,作为参数传给 read_to_string 函数。当然,这个程序如果只写到这样是没有问题的,但是如果我们有另外一个函数也要处理 data 的话怎么办呢?

use std::io::{self, Read, Cursor};

fn read_to_string<R: Read>(mut reader: R) -> Result<String, io::Error> {
    let mut s = String::new();

    reader.read_to_string(&mut s)?;

    Ok(s)
}

fn sum<R: Read>(mut reader: R) -> Result<u64, io::Error> {
    let mut sum = 0;

    let mut buffer = [0; 32];

    loop {
        let c = reader.read(&mut buffer)?;

        if c == 0 {
            break;
        }

        sum += buffer[0..c].iter().map(|&v| v as u64).sum::<u64>();
    }

    Ok(sum)
}

...

let data: Vec<u8> = vec![48, 49, 50, 51, 52];

let result = read_to_string(Cursor::new(data)).unwrap();

assert_eq!("01234".to_string(), result);

let result = sum(Cursor::new(data)).unwrap();

assert_eq!(250, result);

以上程序会编译失败,因为传给 sum 函数使用的 data 的值的拥有权,在之前就已经为了要给 read_to_string 函数使用而被转移了。所以我们可以怎么解决这个问题呢?很简单,把先前有需要转移 data 的值的拥有权的地方,通通在使用 data 时加上 .clone() 来先拷贝成新的一份!

use std::io::{self, Read, Cursor};

fn read_to_string<R: Read>(mut reader: R) -> Result<String, io::Error> {
    let mut s = String::new();

    reader.read_to_string(&mut s)?;

    Ok(s)
}

fn sum<R: Read>(mut reader: R) -> Result<u64, io::Error> {
    let mut sum = 0;

    let mut buffer = [0; 32];

    loop {
        let c = reader.read(&mut buffer)?;

        if c == 0 {
            break;
        }

        sum += buffer[0..c].iter().map(|&v| v as u64).sum::<u64>();
    }

    Ok(sum)
}

...

let data: Vec<u8> = vec![48, 49, 50, 51, 52];

let result = read_to_string(Cursor::new(data.clone())).unwrap();

assert_eq!("01234".to_string(), result);

let result = sum(Cursor::new(data)).unwrap();

assert_eq!(250, result);

这样做虽然可以通过编译,也可以正常运行,但程序性能是很差的,因为同一份数据会被拷贝成两份以上(在这个例子中是两份)。在先前的文章中有提到 Rc 智能型指针,我们可以利用 Rc 智能型指针,来让 Vec<u8> 结构实体能够允许多个拥有者。于是为了让程序性能更好,我们尝试使用 Rc 智能型指针先包裹 data 变量所保存的 Vec<u8> 结构实体,使其在进行拷贝的时候只需要拷贝 Rc 智能型指针就好,而不必拷贝整个 Vec<u8> 结构实体。将以上的程序改写如下:

use std::io::{self, Read, Cursor};
use std::rc::Rc;

fn read_to_string<R: Read>(mut reader: R) -> Result<String, io::Error> {
    let mut s = String::new();

    reader.read_to_string(&mut s)?;

    Ok(s)
}

fn sum<R: Read>(mut reader: R) -> Result<u64, io::Error> {
    let mut sum = 0;

    let mut buffer = [0; 32];

    loop {
        let c = reader.read(&mut buffer)?;

        if c == 0 {
            break;
        }

        sum += buffer[0..c].iter().map(|&v| v as u64).sum::<u64>();
    }

    Ok(sum)
}

...

let data: Rc<Vec<u8>> = Rc::new(vec![48, 49, 50, 51, 52]);

let result = read_to_string(Cursor::new(data.clone())).unwrap();

assert_eq!("01234".to_string(), result);

let result = sum(Cursor::new(data)).unwrap();

assert_eq!(250, result);

然而,这样做是无法通过编译的,因为 Rc<Vec<u8>> 并没有实作 AsRef<[u8]> 特性,所以无法交给 Cursor 结构体来包裹。

为了解决这个问题,就需要用到以下要介绍的套件啦!

Rc U8 Reader

「Rc U8 Reader」是笔者开发的套件,提供了四种结构体,RcU8Reader、RcRefCellU8Reader、ArcU8Reader 和 ArcMutexU8Reader,可以分别用来包裹 Rc<T>、Rc<RefCell<T>>、Arc<T>、Arc<Mutex<T>> 类型的数据,使其拥有 Read 特性。此处的泛型参数 T 为必须要有实作 AsRef<[u8]> 特性的类型。

Crates.io

Cargo.toml

rc-u8-reader = "*"

使用方法

直接用「Rc U8 Reader」套件来修改上面的例子,程序如下:

use std::io::{self, Read};
use std::rc::Rc;

use rc_u8_reader::RcU8Reader;

fn read_to_string<R: Read>(mut reader: R) -> Result<String, io::Error> {
    let mut s = String::new();

    reader.read_to_string(&mut s)?;

    Ok(s)
}

fn sum<R: Read>(mut reader: R) -> Result<u64, io::Error> {
    let mut sum = 0;

    let mut buffer = [0; 32];

    loop {
        let c = reader.read(&mut buffer)?;

        if c == 0 {
            break;
        }

        sum += buffer[0..c].iter().map(|&v| v as u64).sum::<u64>();
    }

    Ok(sum)
}

...

let data: Rc<Vec<u8>> = Rc::new(vec![48, 49, 50, 51, 52]);

let result = read_to_string(RcU8Reader::new(data.clone())).unwrap();

assert_eq!("01234".to_string(), result);

let result = sum(RcU8Reader::new(data)).unwrap();

assert_eq!(250, result);

顺带一提,RcU8Reader 和 ArcU8Reader 结构体,除了有实作 Read 特性外,还有实作 Seek 特性。