rust - 存储对来自生命周期不够长的结构的底层缓冲区的引用

Question

我正在尝试使用 quick_xml 在 Rust 中编写增量 XML 解析器。 .
一些 XML 文件不适合内存(在我的笔记本电脑上)，所以我试图只将每个文件的相关 block 存储在 Vec<u8> 的缓冲区中。 .
在 Vec<u8> 的每个文件 block 内我想将借用存储到某个结构中的切片 Dataquick_xml 提供了一个 read_event附加到缓冲区并返回 quick_xml::events::Event 的方法(一个枚举，包含一个结构体，该结构体带有一个从缓冲区借用的 buf: Cow<'a, [u8]> 字段)
本质上，我想获取 Event 引用的数据并将其存储在我的Data结构。
然而借用检查器心脏病发作，因为 Event只为调用read_event而活我试图保留对它的引用，该引用与缓冲区中的数据一样长。
下面的代码是我上面试图描述的实现。我可以在存储借入基础 buf 方面获得一些帮助吗？来自 Event ?

use quick_xml::events::Event;
use quick_xml::Reader;

const XML: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
<RUN_SET xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <RUN xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" alias="HAP1 gene trap unselected control dataset" accession="SRR2034585" center_name="Stanford University">
    <IDENTIFIERS>
      <PRIMARY_ID>SRR2034585</PRIMARY_ID>
      <SUBMITTER_ID namespace="Stanford University">HAP1 gene trap unselected control dataset</SUBMITTER_ID>
    </IDENTIFIERS>
    <EXPERIMENT_REF accession="SRX1034759"/>
  </RUN>
</RUN_SET>
"#;

#[derive(Debug)]
struct Data<'a> {
    primary_id: Option<&'a [u8]>,
    experiment_ref: Option<&'a [u8]>,
}


fn main() {
    let mut buf: Vec<u8> = vec![];
    let mut reader = Reader::from_str(XML);
    let mut depth = 0;
    let mut path: Vec<u8> = vec![];
    reader.expand_empty_elements(true);
    let mut data = Data { primary_id: None, experiment_ref: None };
    loop {
        match reader.read_event(&mut buf) {
            Ok(Event::Start(ref e)) => {
                depth += 1;
                path.push(b"/"[0]);
                path.append(&mut e.name().to_vec());

                if path == "/RUN_SET/RUN/EXPERIMENT_REF".as_bytes() {
                    let experiment_ref = // What to put here?
                    data = Data { experiment_ref, ..data };
                }
            }
            Ok(Event::End(ref e)) => {
                depth -= 1;
                path.truncate(path.len() - e.name().len() - 1);
            }
            Ok(Event::Eof) => { break; }
            _ => {}
        }
        if depth == 1 {
            println!("{:?}", data);
            buf.clear();
            path.clear();
        }
    }
    
}

Answer 1

调用read_event如有必要，将导致缓冲区扩展，这可能会更改其地址，因此任何引用都将变为无效。具体来说，您正在尝试调用 read_event ，存储一个指向缓冲区的引用( data )，然后调用 read_event再次可以移动缓冲区。
似乎解决此问题的最佳方法是移动/克隆事件名称，使其生命周期不绑定(bind)到缓冲区。令人沮丧的是，似乎 quick_xml::events::BytesStart<'a>无法直接移动底层 Cow<'a, [u8]>所以我们必须存储BytesStart对象本身，以避免潜在的不必要的克隆。
这是执行此操作的一种方法。我对代码进行了重大更改，以便更准确/有效地执行我认为您想要的操作:

use quick_xml::events::Event;
use quick_xml::Reader;

const XML: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
<RUN_SET xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <RUN xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" alias="HAP1 gene trap unselected control dataset" accession="SRR2034585" center_name="Stanford University">
    <IDENTIFIERS>
      <PRIMARY_ID>SRR2034585</PRIMARY_ID>
      <SUBMITTER_ID namespace="Stanford University">HAP1 gene trap unselected control dataset</SUBMITTER_ID>
    </IDENTIFIERS>
    <EXPERIMENT_REF accession="SRX1034759"/>
  </RUN>
</RUN_SET>
"#;

#[derive(Debug)]
struct Data<'a> {
    primary_id: Option<&'a [u8]>,
    experiment_ref: Option<quick_xml::events::BytesStart<'static>>,
}

fn main() {
    let target: &[&[u8]] = &[b"RUN_SET", b"RUN", b"EXPERIMENT_REF"];
    let mut buf: Vec<u8> = vec![];
    let mut reader = Reader::from_str(XML);
    let mut depth = 0;
    let mut good = 0;
    reader.expand_empty_elements(true);
    let mut data = Data {
        primary_id: None,
        experiment_ref: None,
    };
    loop {
        match reader.read_event(&mut buf) {
            Ok(Event::Start(e)) => {
                if depth == good && target.get(depth) == Some(&e.name()) {
                    good += 1;
                    if good == target.len() {
                        data = Data {
                            experiment_ref: Some(e.into_owned()),
                            ..data
                        };
                    }
                }
                depth += 1;
            }
            Ok(Event::End(_)) => {
                depth -= 1;
                good = good.min(depth);
            }
            Ok(Event::Eof) => {
                buf.clear();
                break;
            }
            _ => {}
        }
        buf.clear();
    }
    println!("{:?}", data);
}