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。然后，通过仅传递常规的非可变引用，您仍然可以修改内部向量，但这会带来相当多的复杂性和较小的锁定开销。

循环的上一个迭代中有多个借位

2 个答案: