在开发 Rust 程序的时候,会使用到各式各样别人开发的套件。这些套件虽然很方便,可以替我们节省不少开发时间,但是套件提供的 API,却不一定能够完全满足我们的需求。「Writer」的拥有权被取走,就是一个常见的例子。
有些套件定义的 API,会需要输入有实作 Write 特性的实体,来输出处理结果。以 Rust 标准函数库提供的 File 结构体来说,它本身就有实作 Write 特性,可以一段一段地将数据写进文件中。如果套件需要输入有实作 Write 特性的实体,才能输出处理结果的话,那就意味着将 File 结构实体交给这个套件处理后就拿不回来了。之后如果还要继续使用这个 File 结构实体来读写文件,若是套件没有再提供能够操作 File 结构实体的 API,就只能再重新产生一个新的 File 结构实体了。
再举一个例子,Rust 标准函数库提供的 Vec 结构体,它本身也有实作 Write 特性。有些套件的设计理念是要把处理结果写进文件系统中,保存为一个完整的文件,因此它们提供的 API 多半是要直接输入有实作 Write 特性的实体来给套件使用。但是,我们可能因为还要继续处理数据,而不想把数据写进文件系统中,所以将拥有 Write 特性的 Vec 结构实体传给套件使用,但这样做的话,若是套件没有再提供能够操作 Vec 结构实体的 API,传进去的 Vec 结构实体根本就拿不回来,也就无法继续使用了。为了要能够访问到写进内存中的结果,就必须不能把 Vec 结构实体的拥有权直接交给套件,我们需要透过别种方式来留住 Vec 结构实体的拥有权。
为了解释这个问题,我们用以下这个程序来说明:
use std::io::{self, Write};
pub struct Encoder<W: Write> {
writer: W
}
impl<W: Write> Encoder<W> {
pub fn new(writer: W) -> Encoder<W> {
Encoder {
writer
}
}
pub fn save(&mut self) -> Result<(), io::Error> {
let buffer: Vec<u8> = Vec::new();
// do something
// ...
// and finally
self.writer.write(&buffer)?;
self.writer.flush()?;
Ok(())
}
}
mod encode;
fn main() {
let encoded_result = Vec::new();
let mut encoder = encode::Encoder::new(encoded_result);
encoder.save();
// How can I get the encoded_result back?
}
以上程序,若将 encoded_result 这个 Vec 结构实体作为 Writer 交给 Encoder 结构实体来使用,我们就再也拿不回它的拥有权了。
在先前的文章中有提到 Rc 智能型指针,我们可以利用 Rc 智能型指针,来让 Vec 结构实体能够允许多个拥有者。将以上的 main.rs 改写如下:
mod encode;
use std::rc::Rc;
fn main() {
let encoded_result: Rc<Vec<u8>> = Rc::new(Vec::new());
let encoded_result_writer = Rc::clone(&encoded_result);
let mut encoder = encode::Encoder::new(encoded_result_writer);
encoder.save().unwrap();
println!("{:?}", encoded_result.borrow()); // Am I getting the encoded_result back?
}
编译以上程序后,会发现程序编译失败了,因为 Rc 智能型指针并没有实作 Write 特性。看到这里,想必各位也应该知道要怎么解决这个问题了,那就是我们只要实作出一个新的结构体,让它可以保存 Rc<Vec<u8>> 实体,并且有实作 Write 特性,再把这个结构体的实体交给 Encoder 结构体使用即可!当然,还有一个要修改的地方是,因为 Write 特性的 write 相关方法都必须使用 & mut self,因此我们传给这个新结构体的智能型指针必须要允许取得可变参考,也就是说我们除了要使用 Rc 智能型指针外,还要使用 RefCell 智能型指针。
程序修改如下:
mod encode;
use std::rc::Rc;
use std::cell::RefCell;
use std::io::{self, Write};
pub struct RcWriter<W: Write> {
inner: Rc<RefCell<W>>
}
impl<W: Write> RcWriter<W> {
pub fn new(writer: Rc<RefCell<W>>) -> RcWriter<W> {
RcWriter {
inner: writer
}
}
}
impl<W: Write> Write for RcWriter<W> {
fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
self.inner.borrow_mut().write(buf)
}
fn flush(&mut self) -> Result<(), io::Error> {
self.inner.borrow_mut().flush()
}
}
fn main() {
let encoded_result: Rc<RefCell<Vec<u8>>> = Rc::new(RefCell::new(Vec::new()));
let encoded_result_writer = RcWriter::new(Rc::clone(&encoded_result));
let mut encoder = encode::Encoder::new(encoded_result_writer);
encoder.save().unwrap();
println!("{:?}", encoded_result.borrow()); // I can get it!
}
如此一来,就算套件提供的 API 会拿走 Writer 的拥有权,我们还是可以创建出 RcWriter 结构实体来制作出新的拥有者,使其乖乖让其它套件抢走,因为有 Rc 智能型指针的关系,我们之后依然可以继续使用同样的 Writer。
当然,因为在一开始我们就把 Writer 的拥有权交给 RefCell 智能型指针和 Rc 智能型指针来管理了,因此之后也只能使用 borrow 或是 borrow_mut 方法来取得 Writer 的不可变参考或是可变参考。如果连 Writer 的拥有权都想要能够完全取回的话,我们还可以再加一层 Option 枚举来包裹我们的 Writer。程序改写如下:
mod encode;
use std::rc::Rc;
use std::cell::RefCell;
use std::io::{self, Write, ErrorKind};
pub struct RcOptionWriter<W: Write> {
inner: Rc<RefCell<Option<W>>>
}
impl<W: Write> RcOptionWriter<W> {
pub fn new(writer: Rc<RefCell<Option<W>>>) -> RcOptionWriter<W> {
RcOptionWriter {
inner: writer
}
}
}
impl<W: Write> Write for RcOptionWriter<W> {
fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
match self.inner.borrow_mut().as_mut() {
Some(writer) => writer.write(buf),
None => Err(io::Error::new(ErrorKind::BrokenPipe, "the writer has been removed out"))
}
}
fn flush(&mut self) -> Result<(), io::Error> {
match self.inner.borrow_mut().as_mut() {
Some(writer) => writer.flush(),
None => Err(io::Error::new(ErrorKind::BrokenPipe, "the writer has been removed out"))
}
}
}
fn main() {
let encoded_result: Rc<RefCell<Option<Vec<u8>>>> = Rc::new(RefCell::new(Some(Vec::new())));
let encoded_result_writer = RcOptionWriter::new(Rc::clone(&encoded_result));
let mut encoder = encode::Encoder::new(encoded_result_writer);
encoder.save().unwrap();
let my_dear_writer: Vec<u8> = encoded_result.borrow_mut().take().unwrap();
println!("{:?}", my_dear_writer);
}
利用 Option 枚举实体提供的 take 方法,我们可以将 Some 变体中包裹的数据取出,改变该数据的拥有者,并将原本的 Option 枚举实体变为 None 变体。于是我们就能够取回最一开始的 Writer 的拥有权啦!
Rc Writer
「Rc Writer」是笔者开发的套件,将以上实作的 RcWriter 结构体和 RcOptionWriter 结构体包进这个套件,方便重复使用。
Crates.io
Cargo.toml
