如何扁平化持有引用的Rust迭代器 解决E0515生命周期错误

我使用memmap2 crate读取大型二进制文件，同时使用midasio库，该库提供了若干"viewer"结构，这类结构仅引用字节切片中的内部数据。

基于字节切片（即内存映射）可创建FileView，通过FileView可遍历EventView，再通过EventView可遍历BankView，以上所有结构均仅引用底层的内存映射切片。

通常按如下方式即可很方便地遍历多文件中的所有BankViews：

最小可运行示例 #

Cargo.toml配置：

[dependencies]
midasio = "0.3"
memmap2 = "0.5"

main.rs初始实现：

use std::path::PathBuf;
use std::fs::File;
use memmap2::Mmap;
use midasio::read::file::FileView;

fn main() {
    let args: Vec<PathBuf> = Vec::new(); // 此处替换为待读取的文件路径列表
    for path in args {
        let file = File::open(path).unwrap();
        let mmap = unsafe { Mmap::map(&file).unwrap() };

        let file_view = FileView::try_from(&mmap[..]).unwrap();
        for event_view in &file_view {
            for _bank_view in &event_view {
                // 此处遍历所有BankView实例
            }
        }
    }
}

我需要将上述嵌套遍历逻辑“扁平化”为单个迭代器，使得每次调用next()方法时的行为与上述嵌套循环完全一致。
实现需求的原因是：计划使用Cursive库开发交互界面，通过点击“下一个”按钮逐个遍历BankView，因此需要通过单个函数控制每次“下一个”操作，理想情况下该函数仅需调用这个组合迭代器的next()方法即可。

初始尝试与报错 #

最初尝试通过迭代器组合的方式实现：

use std::path::PathBuf;
use std::fs::File;
use memmap2::Mmap;
use midasio::read::file::FileView;

fn main() {
    let args: Vec<PathBuf> = Vec::new();
    let iterator = args
        .iter()
        .map(|path| {
            let file = File::open(path).unwrap();
            let mmap = unsafe { Mmap::map(&file).unwrap() };

            FileView::try_from(&mmap[..]).unwrap()
        })
        .flat_map(|file_view| file_view.into_iter())
        .flat_map(|event_view| event_view.into_iter());
}

编译产生如下错误：

error[E0515]: cannot return value referencing local variable `mmap`
  --> src/main.rs:14:13
   |
14 |             FileView::try_from(&mmap[..]).unwrap()
   |             ^^^^^^^^^^^^^^^^^^^^----^^^^^^^^^^^^^^
   |             |                   |
   |             |                   `mmap` is borrowed here
   |             returns a value referencing data owned by the current function

error[E0515]: cannot return reference to function parameter `file_view`
  --> src/main.rs:16:31
   |
16 |         .flat_map(|file_view| file_view.into_iter())
   |                               ^^^^^^^^^^^^^^^^^^^^^ returns a reference to data owned by the current function

error[E0515]: cannot return reference to function parameter `event_view`
  --> src/main.rs:17:32
   |
17 |         .flat_map(|event_view| event_view.into_iter());
   |                                ^^^^^^^^^^^^^^^^^^^^^^ returns a reference to data owned by the current function

For more information about this error, try `rustc --explain E0515`.
error: could not compile `ugly_iteration` due to 3 previous errors

三个编译错误本质都是Rust生命周期校验拦截悬空引用：

• 闭包内创建的mmap是局部变量，离开闭包作用域就会被自动释放，而FileView持有对mmap内存的引用，直接返回FileView会造成悬空引用。
• flat_map闭包接收的file_view/event_view是闭包局部参数，闭包返回的迭代器引用了这两个参数，闭包执行结束后参数销毁，同样会造成悬空引用。

要实现符合要求的单迭代器，核心要满足两个条件：

1. 所有Mmap实例必须在整个迭代过程中保持存活，不能提前释放。
2. 迭代过程中的中间状态（当前文件位置、当前event迭代器、当前bank迭代器）必须和迭代器实例绑定，不能存在于临时闭包作用域中。

以下是无额外依赖、可直接运行的实现，遍历逻辑和原始嵌套循环完全一致：

use std::fs::File;
use std::path::PathBuf;
use memmap2::Mmap;
use midasio::read::bank::BankView;
use midasio::read::event::EventView;
use midasio::read::file::FileView;

struct BankIter<'a> {
    // 持有所有内存映射，保证迭代全程指向的内存有效
    _mmaps: Vec<Mmap>,
    // 预创建所有文件的FileView，生命周期与内存映射绑定
    file_views: Vec<FileView<'a>>,
    // 当前遍历到的文件索引
    cur_file: usize,
    // 当前文件的Event迭代器
    cur_event_iter: Option<Box<dyn Iterator<Item = EventView<'a>> + 'a>>,
    // 当前Event的Bank迭代器
    cur_bank_iter: Option<Box<dyn Iterator<Item = BankView<'a>> + 'a>>,
}

impl<'a> BankIter<'a> {
    fn new(paths: &[PathBuf]) -> Self {
        // 加载所有文件的内存映射，统一由迭代器持有
        let mmaps: Vec<Mmap> = paths
            .iter()
            .map(|path| {
                let file = File::open(path).unwrap();
                unsafe { Mmap::map(&file).unwrap() }
            })
            .collect();

        // 基于内存映射创建所有FileView
        let file_views: Vec<FileView<'a>> = mmaps
            .iter()
            .map(|mmap| FileView::try_from(&mmap[..]).unwrap())
            .collect();

        Self {
            _mmaps: mmaps,
            file_views,
            cur_file: 0,
            cur_event_iter: None,
            cur_bank_iter: None,
        }
    }
}

impl<'a> Iterator for BankIter<'a> {
    type Item = BankView<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            // 优先从当前Bank迭代器取元素
            if let Some(bank_iter) = &mut self.cur_bank_iter {
                if let Some(bank) = bank_iter.next() {
                    return Some(bank);
                }
            }

            // 当前Bank迭代器耗尽，取下一个Event并生成新的Bank迭代器
            if let Some(event_iter) = &mut self.cur_event_iter {
                if let Some(event) = event_iter.next() {
                    self.cur_bank_iter = Some(Box::new(event.into_iter()));
                    continue;
                }
            }

            // 当前Event迭代器耗尽，切换到下一个文件
            if self.cur_file >= self.file_views.len() {
                return None;
            }
            let file_view = &self.file_views[self.cur_file];
            self.cur_event_iter = Some(Box::new(file_view.into_iter()));
            self.cur_file += 1;
            self.cur_bank_iter = None;
        }
    }
}

fn main() {
    let args: Vec<PathBuf> = Vec::new(); // 替换为实际文件路径列表
    let mut bank_iter = BankIter::new(&args);

    // Cursive的按钮回调中直接调用bank_iter.next()即可获取下一个BankView
    while let Some(bank) = bank_iter.next() {
        // 编写Bank处理逻辑
    }
}

该实现完全按原始嵌套循环的顺序遍历：逐文件读取，每个文件内按顺序遍历Event，每个Event内按顺序遍历Bank。所有内存映射全程由迭代器持有，不会出现内存提前释放的问题，性能和原生嵌套循环一致，不需要引入额外依赖。

内容的提问来源于stack exchange，提问作者user17004502