rust - 如何安抚嵌套数据结构的借用检查器？

Question

我正在开发一个(相当雄心勃勃的)文本编辑器，我正在尝试实现任意垂直和水平拆分以显示文本缓冲区，如下所示:

     buffer
-----------------
buffer |
-------|  buffer
buffer |

我将这个结构表示为二叉树类型的东西:

    h
   / \
  v   b
 / \
b   h
   / \
  b   b

其中 v 是垂直分割，h 是水平分割，b 是缓冲区。

代码形式是这样的:

pub enum LayoutNode {
    Buf(Buffer),
    Split(Box<Split>),
}

pub enum Split {
    Vertical(LayoutNode, LayoutNode),
    Horizontal(LayoutNode, LayoutNode)
}

pub struct Buffer {
    content: String,
    // more buffer-related stuff
}

一切顺利。我的垂直拆分方法:

impl LayoutNode {
    pub fn vertical_split(layout: LayoutNode) -> LayoutNode {
        LayoutNode::Split(Box::new(Split::Vertical(layout, LayoutNode::Buf(Buffer::new()))))
        // Buffer::new() returns an empty Buffer
    }
}

这个函数可以编译，但不是全部。我有一个负责编辑器布局节点的数据结构，称为 Editor:

impl Editor {
    pub fn new() -> Editor {
        Editor {
            buffers: LayoutNode::Buf(Buffer::empty()),
            // more editor-related stuff
        }
    }

    pub fn vertical_split(&mut self) {
        // buffers needs to be a part of itself
        self.buffers = LayoutNode::vertical_split(self.buffers);
        // cannot move out of borrowed content    ^
    }
}

我看过 mem::replace 但我不确定它是否是我在这种情况下使用嵌套数据结构所需要的。 E0507 的 rustc --explain 页面在这方面不是很有帮助。

在这种情况下，我该如何使用借用检查器？我宁愿不克隆所有内容，因为每次拆分时每个文件的新副本很容易浪费大量内存。

Answer 1

mem::replace 通常在这种情况下使用，以在生成新值时将字段设置为虚拟但有效的值。这是必要的，以确保如果线程在生成新值时崩溃，析构函数将不会释放相同的对象两次。

在您的情况下，它可能看起来像这样:

impl Editor {
    pub fn new() -> Editor {
        Editor {
            buffers: LayoutNode::Buf(Buffer::empty()),
        }
    }

    pub fn vertical_split(&mut self) {
        // buffers needs to be a part of itself
        self.buffers = LayoutNode::vertical_split(
            mem::replace(&mut self.buffers, LayoutNode::Buf(Buffer::empty())));
    }
}

它的工作原理是这样的:mem::replace 接收对要替换的变量或字段的可变引用以及要分配的值，并返回旧值。您获得结果的所有权，因此您可以自由移动它。