在前一次循环迭代中多次借用

Question

以下是我正在处理的代码，我探索了一个带队列的目录路径，我想将文件系统树存储在我的数据结构中（枚举Entry）：

use failure::Error;
use std::collections::VecDeque;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};

fn main() -> Result<(), Error> {
    let paths = visit_dir(Path::new(".")).map_err(Error::from)?;
    Ok(())
}

#[derive(Debug)]
enum Entry {
    Dir(PathBuf, Vec<Entry>),
    File(PathBuf),
}

impl Entry {
    fn new_dir(path: &Path) -> Entry {
        Entry::Dir(path.to_path_buf(), Vec::new())
    }

    fn new_file(path: &Path) -> Entry {
        Entry::File(path.to_path_buf())
    }

    /// Append a new Entry to self if self is a directory.
    fn push(&mut self, path: &Path) -> Option<&mut Entry> {
        if let Entry::Dir(_, ref mut content) = self {
            let entry = if path.is_dir() {
                Entry::new_dir(path)
            } else {
                Entry::new_file(path)
            };
            content.push(entry);
            return content.last_mut();
        }
        None
    }

    fn path(&self) -> &Path {
        match self {
            Entry::Dir(path, _) => path,
            Entry::File(path) => path,
        }
    }
}

fn visit_dir(root: &Path) -> io::Result<Entry> {
    let mut dir = Entry::new_dir(root);
    let mut queue = VecDeque::new();
    queue.push_back(&mut dir);

    while !queue.is_empty() {
        let parent = queue.pop_front().unwrap();
        let path = parent.path();
        if path.is_dir() {
            for entry in fs::read_dir(path)? {
                let entry = entry?;
                let path = entry.path();
                let entry = parent.push(&path).unwrap();

                if path.is_dir() {
                    queue.push_back(entry);
                }
            }
        }
    }

    Ok(dir)
}

链接到Playground

我得到的错误是：

error[E0499]: cannot borrow `*parent` as mutable more than once at a time
  --> src/main.rs:61:29
   |
61 |                 let entry = parent.push(&path).unwrap();
   |                             ^^^^^^ mutable borrow starts here in previous iteration of loop

我的问题是：

• 为什么我会收到此错误？
• 有什么解决方法可以解决吗？

Answer 1

• entry在线上可靠地借parent： let entry = parent.push(&path).unwrap();
• 然后，你不释放entry，因为你将它存储在queue中。所以，当这是循环中的第二次迭代时，parent仍然可以被借用。这样做是不安全的。

你要做的是一个可变参考树。这在Rust中不起作用，这通常是一个坏主意。您应该修改您想要实现的方式。

Answer 2

您收到此错误是因为您有多个对父项的可变引用。

第一个可变参考是通过parent.push(&mut self, ...)方法。而且你有一堆可变引用，因为每次调用push都会产生一个对矢量项（&mut Entry）的可变引用。

一种可能的解决方案是在RwLock中引入Entry。然后通过仅传递常规的非可变引用，您仍然可以修改内部向量，但这会引入相当多的复杂性和锁定的小开销。