返回 RefCell 的迭代器

Question

我无法弄清如何在以下代码段中实现children_iter：

  use std::{cell::RefCell, rc::Rc};                                                                                                                                                                          
                                                                                                                                                                                                             
  struct Node {                                                                                                                                                                                              
      children: Vec<Rc<RefCell<Node>>>,                                                                                                                                                                      
  }                                                                                                                                                                                                          
                                                                                                                                                                                                             
  struct NodeIterator {                                                                                                                                                                                      
      current: Rc<RefCell<Node>>,                                                                                                                                                                            
  }                                                                                                                                                                                                          
                                                                                                                                                                                                             
  impl NodeIterator {                                                                                                                                                                                        
      fn new(node: Rc<RefCell<Node>>) -> NodeIterator {                                                                                                                                                      
          NodeIterator { current: node }                                                                                                                                                                     
      }                                                                                                                                                                                                      
           
      /// Returns an iterator over the children of the current node wrapped in a NodeIterator                                                                                                                                                                                                  
      fn children_iter(&self) -> impl Iterator<Item = NodeIterator> {                                                                                                                                         
          self.current ‣Rc<RefCell<Node>>                                                                                                                                                                    
              .borrow() ‣Ref<Node>                                                                                                                                                                           
              .children ‣Vec<Rc<RefCell<Node>>>                                                                                                                                                              
              .iter() ‣Iter<Rc<RefCell<Node>>>                                                                                                                                                               
              .map(|n| Self::new(n.clone())) ‣&Rc<RefCell<Node>>                                                                                                                                             
      }                                                                                                                                                                                                      
  }                                                                                                                                                                                                          
              

问题是我不确定在迭代器返回时，它应该包含什么子元素。我尝试了几种不同的方法：

1. 也许我可以将迭代器与self的生命周期绑定？：

fn children_iter<'a>(&'a self) -> impl 'a + Iterator<Item=NodeIterator>

这种情况会失败，因为它返回当前函数所拥有的数据

2. 或许我可以使self被消耗，这样我们就不需要保留对它的任何引用了吗？

fn children_iter(self) -> impl Iterator<Item=NodeIterator>

出现错误：self.current 存活时间不足

3. 我还尝试过克隆 Rc，以便它不引用 self 中的那个对象

self.current
    .clone()
    .borrow()
    ......

这个操作会出现“创建一个在使用过程中被释放的临时对象”的错误。

- jeanluc

Answer 1

找到了解决方案：

self.current
    .borrow()
    .children()
    .clone()
    .into_iter()
    .map(|n| Self::new(n))

这样，您将返回一个已转换为迭代器的克隆Vec。

- jeanluc