我正在尝试修改一个迫使我学习 rust 的现有应用程序，这让我很难(重新制定......
我想要一个带有两个字段的结构：
pub struct Something<'a> {
pkt_wtr: PacketWriter<&'a mut Vec<u8>>,
buf: Vec<u8>,
}
其中"buf"将用作 PacketWriter 写入其结果的 io。所以PacketWriter是这样的
use std::io::{self};
pub struct PacketWriter<T :io::Write> {
wtr :T,
}
impl <T :io::Write> PacketWriter<T> {
pub fn new(wtr :T) -> Self {
return PacketWriter {
wtr,
};
}
pub fn into_inner(self) -> T {
self.wtr
}
pub fn write(&mut self) {
self.wtr.write_all(&[10,11,12]).unwrap();
println!("wrote packet");
}
}
然后在"Something"中，我想以这种方式使用PacketWriter：让它在"buf"中写下它需要的东西，然后逐个耗尽它。
impl Something<'_> {
pub fn process(&mut self) {
self.pkt_wtr.write();
let c = self.buf.drain(0..1);
}
}
似乎不可能为"某事"创建一个可行的构造函数
impl Something<'_> {
pub fn new() -> Self {
let mut buf = Vec::new();
let pkt_wtr = PacketWriter::new(&mut buf);
return Something {
pkt_wtr: pkt_wtr,
buf: buf,
};
}
}
然而，似乎不可行的是，但是我尝试在从"buf"借来的引用上构建 PacketWriter，而"buf"也存储在"某物"对象中。
我可以将"buf"完全提供给"PacketWriter"(根据下面的示例)，但我以后无法访问"buf"的内容。我知道它在下面的示例中有效，但这是因为我可以在将"buf"提供给"PacketWriter"(通过"wtr")后访问它。实际上，"PacketWriter"将该字段(wtr)私有，此外，它是我无法修改的代码，例如，获取"wtr"的getter
谢谢
我写了一个小的工作程序来描述意图和问题，有两个选项
use std::io::{self};
pub struct PacketWriter<T :io::Write> {
wtr :T,
}
impl <T :io::Write> PacketWriter<T> {
pub fn new(wtr :T) -> Self {
return PacketWriter {
wtr,
};
}
pub fn into_inner(self) -> T {
self.wtr
}
pub fn write(&mut self) {
self.wtr.write_all(&[10,11,12]).unwrap();
println!("wrote packet");
}
}
/*
// that does not work of course because buf is local but this is not the issue
pub struct Something<'a> {
pkt_wtr: PacketWriter<&'a mut Vec<u8>>,
buf: Vec<u8>,
}
impl Something<'_> {
pub fn new() -> Self {
let mut buf = Vec::new();
let pkt_wtr = PacketWriter::new(&mut buf);
//let mut pkt_wtr = PacketWriter::new(buf);
return Something {
pkt_wtr,
buf,
};
}
pub fn process(&mut self) {
self.pkt_wtr.write();
println!("process {:?}", self.buf);
}
}
*/
pub struct Something {
pkt_wtr: PacketWriter<Vec<u8>>,
}
impl Something {
pub fn new() -> Self {
let pkt_wtr = PacketWriter::new(Vec::new());
return Something {
pkt_wtr,
};
}
pub fn process(&mut self) {
self.pkt_wtr.write();
let file = &mut self.pkt_wtr.wtr;
println!("processing Something {:?}", file);
let c = file.drain(0..1);
println!("Drained {:?}", c);
}
}
fn main() -> std::io::Result<()> {
let mut file = Vec::new();
let mut wtr = PacketWriter::new(&mut file);
wtr.write();
println!("Got data {:?}", file);
{
let c = file.drain(0..2);
println!("Drained {:?}", c);
}
println!("Remains {:?}", file);
let mut data = Something::new();
data.process();
Ok(())
}
鉴于代码似乎可以编译，目前还不完全清楚问题是什么，但我可以尝试一部分：为什么你不能在process函数内部对self.wtr使用into_inner()？
into_inner取得传递到其self参数中的PacketWriter的所有权。(您可以判断这一点，因为参数拼写为self，而不是&self或&mut self。获得所有权意味着它被消费：调用方不能再使用它，被调用方负责删除它(阅读：运行析构函数)。在取得PacketWriter的所有权后，into_inner函数只返回wtr字段，并删除(运行析构函数)其余字段。但是，这让Something结构何去何从？它有一个需要包含PacketWriter的领域，而你只是把它的PacketWriter拿走了并摧毁了它！函数结束，PacketWriter字段中保存的值是未知的：它不可能是从一开始就存在的东西，因为它被into_inner接管并销毁。但它也不能是别的任何东西。
Rust 通常禁止结构具有未初始化或未定义的字段。您需要始终定义该字段。
这是工作示例：
pub fn process(&mut self) {
self.pkt_wtr.write();
// There's a valid PacketWriter in pkt_wtr
let raw_wtr: Vec<u8> = self.pkt_wtr.into_inner();
// The PacketWriter in pkt_wtr was consumed by into_inner!
// We have a raw_wtr of type Vec<u8>, but that's not the right type for pkt_wtr
// We could try to call this function here, but what would it do?
self.pkt_wtr.write();
println!("processing Something");
}
(注意：上面的例子逻辑有点模糊。从形式上讲，因为你不拥有self，你不能做任何可以拥有它任何部分的事情，即使你在完成后把所有东西都整齐地放回去。
您有几个选项可以解决此问题，但有一个主要警告：使用您描述的公共接口，无法访问PacketWriter::wtr字段并将其放回同一PacketWriter中。您必须提取PacketWriter::wtr字段并将其放入新PacketWriter。
这是您可以做到的一种方法。请记住，目标是始终定义self.packet_wtr，因此我们将使用一个名为mem::replace的函数将虚拟PacketWriter放入self.pkt_wtr中。这确保了self.pkt_wtr总是有东西在里面。
pub fn process(&mut self) {
self.pkt_wtr.write();
// Create a new dummy PacketWriter and swap it with self.pkt_wtr
// Returns an owned version of pkt_wtr that we're free to consume
let pkt_wtr_owned = std::mem::replace(&mut self.pkt_wtr, PacketWriter::new(Vec::new()));
// Consume pkt_wtr_owned, returning its wtr field
let raw_wtr = pkt_wtr_owned.into_inner();
// Do anything you want with raw_wtr here -- you own it.
println!("The vec is: {:?}", &raw_wtr);
// Create a new PacketWriter with the old PacketWriter's buffer.
// The dummy PacketWriter is dropped here.
self.pkt_wtr = PacketWriter::new(raw_wtr);
println!("processing Something");
}
锈游乐场
这个解决方案绝对是一个黑客，它可能是一个可以改进借用检查器的地方，以意识到暂时不定义字段是可以的，只要在再次分配之前不访问它。(虽然我可能错过了一个边缘情况;一般来说，这些东西很难推理。此外，这是可以通过以后的编译器通过死存储消除来优化的事情。
如果这在分析时被证明是一个热点，那么unsafe技术可以让该字段在该时间段内无效，但这可能需要一个新问题。
但是，我的建议是找到一种方法将"逃生舱口"功能添加到PacketWriter中，使您可以完全执行要做的事情：获取对内部wtr的可变引用，而无需获得PacketWriter的所有权。
impl<T: io::Write> PacketWriter<T> {
pub fn inner_mut(&mut self) -> &mut T {
&mut self.wtr
}
}
为了澄清起见，我找到了使用Rc+RefCell或Arc+Mutex的解决方案。我将缓冲区封装在 Rc/RefCell 中并添加了一个写入
pub struct WrappedWriter {
data :Arc<Mutex<Vec<u8>>>,
}
impl WrappedWriter {
pub fn new(data : Arc<Mutex<Vec<u8>>>) -> Self {
return WrappedWriter {
data,
};
}
}
impl Write for WrappedWriter {
fn write(&mut self, buf: &[u8]) -> Result<usize, Error> {
let mut data = self.data.lock().unwrap();
data.write(buf)
}
fn flush(&mut self) -> Result<(), Error> {
Ok(())
}
}
pub struct Something {
wtr: PacketWriter<WrappedWriter>,
data : Arc<Mutex<Vec<u8>>>,
}
impl Something {
pub fn new() -> Result<Self, Error> {
let data :Arc<Mutex<Vec<u8>>> = Arc::new(Mutex::new(Vec::new()));
let wtr = PacketWriter::new(WrappedWriter::new(Arc::clone(&data)));
return Ok(PassthroughDecoder {
wtr,
data,
});
}
pub fn process(&mut self) {
let mut data = self.data.lock().unwrap();
data.clear();
}
}
如果您没有线程安全问题，您可以将 Arc 替换为 Rc，将互斥体替换为 RefCell，在这种情况下，引用访问变为
let data = self.data.borrow_mut();