从寿命不够长的结构存储对底层缓冲区的引用

Question

我正在尝试使用 quick_xml.

在 Rust 中编写增量 XML 解析器

一些 XML 文件不适合内存（在我的笔记本电脑上）所以我试图只将每个文件的相关块存储在 Vec<u8>.[=24 的缓冲区中=]

在 Vec<u8> 的每个文件块中，我想在某些结构 Data

中存储对切片的借用

quick_xml 提供了一个 read_event 方法追加到缓冲区和 returns 一个 quick_xml::events::Event （一个枚举包含一个带有 buf: Cow<'a, [u8]> 字段的结构从缓冲区借用）

基本上我想获取 Event 引用的数据并将其存储在我的 Data 结构中。

但是借用检查器心脏病发作了，因为 Event 只在调用 read_event 时存在，我试图保留对它的引用，只要数据在缓冲区。

下面的代码是我在上面试图描述的内容的实现。我可以在从 Event 存储对基础 buf 的借用方面获得一些帮助吗？

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 以移动缓冲区。

看来解决这个问题的最好方法是 move/clone 事件名称，这样它的生命周期就不会绑定到缓冲区。令人沮丧的是，quick_xml::events::BytesStart<'a> 似乎没有办法直接移动底层的 Cow<'a, [u8]> 所以我们必须存储 BytesStart 对象本身以避免潜在的不必要的克隆。

这是一种方法。我对代码进行了重大更改，以便更多地 accurately/efficiently 执行我认为您想要的操作：

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);
}

从寿命不够长的结构存储对底层缓冲区的引用

Store a reference to the underlying buffer from a struct that doesn't live long enough

reference

rust

borrow-checker