如何使用匹配处理 Rust 中的多个可变借用？

Question

我正在尝试使用 quick-xml 封装一个 XML 解析器，该解析器需要一些特定的 XML 条目。主要代码如下：

pub struct GPXParser<B: BufRead> {
    reader: Reader<B>,
    buff: Vec<u8>,
}

impl<B> GPXParser<B> {
    pub fn read_next<a>(&mut self) -> Result<XMLCache, Error> {
        match self.reader.read_event(&mut self.buff) {
            Ok(XMLEvent::Start(ref e)) if e.name() == b"wpt" => {
                self.read_next_wpt() // --> Multiple mutable borrows error
            }
            _ => Err(Error::NoCaches),
        }
    }

    fn read_next_wpt(&mut self) -> Result<XMLCache, Error> {
        match self.reader.read_event(&mut self.buff) {
            _ => Err(Error::NoCaches),
        }
    }
}

然后我在 rust-lang.org 上阅读了这个 topic，提到：

惯用的 Rust 代码通常避免持有对可变对象内部的长期引用，并倾向于使用不可变引用或独立值的替代方法

我尝试使用中间 buff 元素来改变我的方法：

pub struct GPXParser<B: BufRead> {
    reader: Reader<B>,
}

impl<B> GPXParser<B> {
    pub fn read_next<a>(&mut self) -> Result<XMLCache, Error> {
        let mut buff: Vec<u8> = Vec::new();

        match self.reader.read_event(&mut buff) {
            Ok(XMLEvent::Start(ref e)) if e.name() == b"wpt" => {
                self.read_next_wpt(&mut buff) // --> Multiple mutable borrows error
            }
            _ => Err(Error::NoCaches),
        }
    }

    fn read_next_wpt(&mut self, buff: &mut Vec<u8>) -> Result<XMLCache, Error> {
        match self.reader.read_event(buff) {
            _ => Err(Error::NoCaches),
        }
    }
}

我没有改变方法。

我试图将match 语句分成两行：

pub fn read_next<a>(&mut self) -> Result<XMLCache, Error> {
    let result = self.reader.read_event(&mut self.buff);
    match result {
        Ok(XMLEvent::Start(ref e)) if e.name() == b"wpt" => self.read_next_wpt(),
        _ => Err(Error::NoCaches),
    }
}

但我得到了同样的错误：

error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> src/gpx/mod.rs:34:17
   |
31 |         let result = self.reader.read_event(&mut self.buff);
   |                                                  --------- first mutable borrow occurs here
...
34 |                 self.read_next_wpt()
   |                 ^^^^ second mutable borrow occurs here
...
39 |     }
   |     - first borrow ends here

有没有办法在不同的方法调用中使用相同的缓冲区？

应该在游戏中加入一些生命吗？

如果不是，解决这个问题的惯用 Rust 方法是什么？

Answer 1

问题来自prototype for read_event中的'b生命周期：

pub fn read_event<'a, 'b>(
    &'a mut self, 
    buf: &'b mut Vec<u8>
) -> Result<Event<'b>>

这将缓冲区的生命周期与返回值的生命周期联系起来，因此只要结果还存在，就不能重复使用缓冲区。当你不想递归时，你可以通过提前返回来绕过它，并且只有在你使用完结果后才递归：

pub fn read_next<a>(&mut self) -> Result<XMLCache, Error> {
    match self.reader.read_event(&mut self.buff) {
        Ok(XMLEvent::Start(ref e)) if e.name() == b"wpt" => (),
        _ => { return Err(Error::NoCaches) },
    }
    self.read_next_wpt()
}

如果您想添加更多案例，您必须首先从结果中提取您希望使用的任何相关信息，包括选择要调用的方法所需的任何信息，然后在调用方法之前让结果超出范围.例如：

pub fn read_next<a>(&mut self) -> Result<XMLCache, Error> {
    let next_method = match self.reader.read_event(&mut self.buff) {
        Ok(XMLEvent::Start(ref e)) if e.name() == b"wpt" => GPXParser<B>::read_next_wpt,
        Ok(XMLEvent::Start(ref e)) if e.name() == b"foo" => GPXParser<B>::read_next_foo,
        _ => { return Err(Error::NoCaches) },
    }
    next_method(self)
}

或者，如果性能影响小到可以接受（您应该对其进行测量以支持您的决定），则每次只使用不同的缓冲区可能会更容易。

---

以下原始答案供参考：

尝试将read_event 和匹配项拆分为单独的行：

let result = self.reader.read_event(&mut self.buff);
match result {
    ...
}

您的问题是整个匹配表达式的缓冲区是可变借用的，因此您不能在匹配臂内重新借用缓冲区。通过将代码分成两行，缓冲区只为第一个表达式（let result=...）借用，并且可以在匹配中再次借用。

这可能会在未来非词法生命周期变得稳定时得到解决。