Question

我编写了以下代码，用于过滤工作正常的数据流，直到我从解析简单数字更改为也具有绑定到生存期的类型，例如&str和&[u8]。

use wirefilter::{ExecutionContext, Filter, Scheme};

lazy_static::lazy_static! {
    static ref SCHEME: Scheme = Scheme! {
        port: Int,
        name: Bytes,
    };
}

#[derive(Debug)]
struct MyStruct {
    port: i32,
    name: String,
}

impl MyStruct {
    fn scheme() -> &'static Scheme {
        &SCHEME
    }

    fn filter_matches<'s>(&self, filter: &Filter<'s>) -> bool {
        let mut ctx = ExecutionContext::new(Self::scheme());
        ctx.set_field_value("port", self.port).unwrap();
        ctx.set_field_value("name", self.name.as_str()).unwrap();

        filter.execute(&ctx).unwrap()
    }
}

fn main() -> Result<(), failure::Error> {
    let data = expensive_data_iterator();
    let scheme = MyStruct::scheme();
    let filter = scheme
        .parse("port in {2 5} && name matches \"http.*\"")?
        .compile();

    for my_struct in data
        .filter(|my_struct| my_struct.filter_matches(&filter))
        .take(2)
    {
        println!("{:?}", my_struct);
    }

    Ok(())
}

fn expensive_data_iterator() -> impl Iterator<Item = MyStruct> {
    (0..).map(|port| MyStruct {
        port,
        name: format!("http {}", port % 2),
    })
}

如果我尝试对其进行编译，则编译器将因以下原因而失败：

error[E0623]: lifetime mismatch
  --> src/main.rs:26:16
   |
21 |     fn filter_matches<'s>(&self, filter: &Filter<'s>) -> bool {
   |                           -----           ----------
   |                           |
   |                           these two types are declared with different lifetimes...
...
26 |         filter.execute(&ctx).unwrap()
   |                ^^^^^^^ ...but data from `self` flows into `filter` here

error: aborting due to previous error

error: Could not compile `wirefilter_playground`.

To learn more, run the command again with --verbose.

Process finished with exit code 101

我首先想到的是self和filter在fn filter_matches<'s>(&self, filter: &Filter<'s>) -> bool中应具有相同的生存期，但是如果将签名更改为fn filter_matches<'s>(&'s self, filter: &Filter<'s>) -> bool，我将开始遇到此错误：

error: borrowed data cannot be stored outside of its closure
  --> src/main.rs:38:29
   |
33 |     let filter = scheme
   |         ------ ...so that variable is valid at time of its declaration
...
38 |         .filter(|my_struct| my_struct.filter_matches(&filter))
   |                 ----------- ^^^^^^^^^ -------------- cannot infer an appropriate lifetime...
   |                 |           |
   |                 |           cannot be stored outside of its closure
   |                 borrowed data cannot outlive this closure

error: aborting due to previous error

error: Could not compile `wirefilter_playground`.

To learn more, run the command again with --verbose.

Process finished with exit code 101

我无法理解原因，Filter<'s>绑定到延迟生成的SCHEME上，并绑定到'static上，这不允许filter.execute引用{ {1}}，因为它会过期，但不是&self.name.as_str()签名是filter.execute(&ctx)的签名，因为它没有其他生命周期，所以应该在引用完成后立即删除引用吗？

为了尝试编译上面的代码，您可以使用以下pub fn execute(&self, ctx: &ExecutionContext<'s>) -> Result<bool, SchemeMismatchError>：

Cargo.toml

PS：这可以通过在内部[package] name = "wirefilter_playground" version = "0.1.0" edition = "2018" [dependencies] wirefilter-engine = "0.6.1" failure = "0.1.5" lazy_static = "1.3.0"中编译as来解决，但这有点不好，因为用户在尝试过滤时只会得到parse错误，并且可能会更慢。

Answer 1

我看到了两种解决此问题的方法：
1）延长self.name的寿命。这可以通过将expensive_data_iterator收集到Vec中来实现。

--- let data = expensive_data_iterator();
+++ let data: Vec<_> = expensive_data_iterator().collect();

2）缩短filter的生存期。

--- let filter = scheme.parse("...")?.compile();
+++ let filter = scheme.parse("...")?;

--- .filter(|my_struct| my_struct.filter_matches(&filter))
+++ .filter(|my_struct| my_struct.filter_matches(&filter.clone().compile()))

我省略了其他一些小的更改。是的，无论哪种情况，filter_matches<'s>(&'s self, ...)都是强制性的。

PS是的，第二个选项起作用是因为my_struct比filter寿命更长。好吧，如果两种方法都不好，那么您可以将它们组合起来！按块处理data，将每个收集到向量中。

const N: usize = 10; // or any other size
loop {
    let cur_chunk: Vec<_> = data.by_ref().take(N).collect();
    if cur_chunk.is_empty() {
        break;
    }
    let cur_filter = filter.clone().compile();
    // etc
}

仅使用O（N）内存，并且将过滤器的编译次数减少了N倍

Rust生命周期，数据流入其他参考

1 个答案: