1

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

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可变 in handle_client()，否则我无法在其队列中推送任何内容。

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

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

4

0 回答 0