iterator - 遍历集合。 Iterator 被删除后立即删除它

Question

我将集合转储到磁盘上。当请求时，应该检索这些集合(没问题)和 iterator应该为它构建返回对检索到的值的引用。

iterator之后被丢弃了，我不再需要收藏了。我也希望它被删除。

到目前为止我尝试了什么:

1. Iterator拥有收藏。这对我来说最有意义，但这是不可能的；我不太清楚为什么。有人说 Iterator next 的特征方法签名是问题所在。 ( example )

2. 引用计数:Retriever返回 Rc<Vec<usize>> .我遇到了与拥有迭代器相同的问题。 ( example )

3. 让寻回犬拥有收藏并分发对它的引用。我试图实现具有内部可变性的检索器 ( RefCell<HashMap> )，但我无法将引用返回到 HashMap 中具有足够长的生命周期。

我看到了两种基本的可能性。

1. 猎犬转移所有权。然后 Iterator需要拥有数据。内容如下:

   use std::slice::Iter;
   
   fn retrieve(id: usize) -> Vec<usize> {
       //Create Data out of the blue (or disk, or memory, or network. I dont care)
       //Move the data out. Transfer ownership
       let data = vec![0, 1, 2, 3];
       data
   }
   
   fn consume_iterator<'a, TIterator: Iterator<Item=&'a usize>>(iterator: TIterator) {
       for i in iterator {
           println!("{}", i);
       }
   }
   
   fn handler<'a>(id: usize) -> Iter<'a, usize> {
       //handle_request now owns the vector.
       //I now want to build an owning iterator..
       //This does of course not compile as vector will be dropped at the end of this method
       retrieve(id).iter()
   }
   
   fn main() {
       consume_iterator(handler(0))
   }
   

2. 寻回犬拥有收藏。但是随后出现了两个新问题:

   1. 如何在迭代器超出范围时删除数据？
   2. 我如何告诉借阅检查员我将拥有该馆藏足够长的时间？

   use std::cell::{Ref, RefCell};
   
   struct Retriever {
       //Own the data. But I want it to be dropped as soon as the references to it go out of scope.
       data: RefCell<Vec<usize>>
   }
   
   impl Retriever{
   
       fn retrieve<'a>(&'a self, id: usize) -> Ref<'a, Vec<usize>> {
           //Create Data out of the blue (or disk, or memory, or network. I dont care)
           //Now data can be stored internally and a referece to it can be supplied.
           let mut data = self.data.borrow_mut();
           *data = vec![0, 1, 2, 3];
           self.data.borrow()
       }
   
   }
   
   fn consume_iterator<'a, TIterator: Iterator<Item=&'a usize>>(iterator: TIterator) {
       for i in iterator {
           println!("{}", i);
       }
   }
   
   
   fn handler<'a>(ret: &'a Retriever, id: usize) -> IterWrapper<'a> {
       //andle_request now has a reference to the collection
       //So just call iter()? Nope. Lifetime issues.
       ret.retrieve(id).iter()        
   }
   
   fn main() {
       let retriever = Retriever{data: RefCell::new(Vec::new())};
       consume_iterator(handler(&retriever, 0))
   }
   

我觉得这里有点迷茫，我忽略了一些显而易见的事情。

Answer 1

The Iterator owns the collection. [or joint ownership via reference-counting]

ContainerIterator { 
    data: data,
    iter: data.iter(),
}

不，你cannot have a value and a reference to that value in the same struct .

Letting the retriever own the collection and handing out a reference to it.

不，你cannot return references to items owned by the iterator .

正如评论者所说，使用 IntoIter 将项目的所有权转移到迭代器，然后将它们作为迭代值分发出去:

use std::vec::IntoIter;

struct ContainerIterator {
    iter: IntoIter<usize>,
}

impl Iterator for ContainerIterator {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next()
    }
}

fn main() {
    let data = vec![0, 1, 2, 3];
    let cont = ContainerIterator { iter: data.into_iter() };

    for x in cont {
        println!("Hi {}", x)
    }
}

如果您必须返回引用...那么您需要在所有引用可能存在的整个时间内保持拥有它们的东西。

How can I drop the data when the iterator is out of range?

不再使用该值:

fn main() {
    {
        let loaded_from_disk = vec![0, 1, 2, 3];
        for i in &loaded_from_disk {
            println!("{}", i)
        }
        // loaded_from_disk goes out of scope and is dropped. Nothing to *do*, per se.
    }
}

How do I tell the borrow-checker that I will own the collection long enough?

拥有收藏足够长的时间。没有 Rust Illuminati 与借用检查器使用的 secret 握手。代码只需要结构化，使得借用的东西在借用未完成时不会变得无效。你不能移动它(改变内存地址)或放下它(改变内存地址)。