Question

我正在尝试编写一个侦听套接字上的请求的应用程序，然后将它们添加到要处理的队列中。我的部分代码如下：

pub struct Middleware {
    listener: TcpListener,
    queue: Vec<String>,
    servers: Vec<String>,
}

impl Middleware {
    pub fn run(&mut self) {
        for stream in self.listener.incoming() {
            let mut stream = stream.unwrap();
            let mut buffer = vec![0u8; 512];
            stream.read(&mut buffer).unwrap();
            self.queue.push(String::from_utf8(buffer).unwrap());
        }
    }
}

然而，如果我尝试将run()中的一些代码抽象为函数（字面意思只是复制/粘贴）：

impl Middleware {
    pub fn run(&mut self) {
        for stream in self.listener.incoming() {
            let mut stream = stream.unwrap();
            self.handle_client(stream);
        }
    }

    fn handle_client(&mut self, mut stream: TcpStream) {
        let mut buffer = vec![0u8; 512];
        stream.read(&mut buffer).unwrap();
        self.queue.push(String::from_utf8(buffer).unwrap());
    }
}

我收到以下错误消息：

cannot borrow `*self` as mutable because `self.listener` is also borrowed as immutable
--> src/lib.rs:21:13
   |
19 |         for stream in self.listener.incoming() {
   |                       ------------- immutable borrow occurs here
20 |             let mut stream = stream.unwrap();
21 |             self.handle_client(stream);
   |             ^^^^ mutable borrow occurs here
22 |         }
   |         - immutable borrow ends here

根据我的理解，self.listener.incoming()实际上不仅借用了听众“字段”而且借用了整个结构。然后，由于我们不能同时使用不可变借用进行任何可变借用，编译器会抱怨。但是，我必须在self中使handle_client()变为可变，否则我无法在队列中推送任何内容。

我一直在考虑如何以不同方式构造代码以克服此问题，但似乎无法在不更改Middleware结构的情况下找到解决方案（如删除某些字段等）。

是否有可能以某种方式构造代码以使用函数（比如在我的第二个代码片段中）？

为什么编译器抱怨将字段借用为不可变字段，即使我的函数不以任何方式访问该字段？

0 个答案: