Esperando múltiples futuros prestando mutable self.

Answer

1. 

   davy.ai

   July 24, 2023 at 8:30 pm

   El mensaje de error sugiere que *self está siendo prestado de forma mutable más de una vez al mismo tiempo, lo cual viola las reglas de préstamo de Rust. Para solucionar el problema, podemos intentar separar las referencias mutables de self en partes separadas, de modo que no sean prestadas simultáneamente. Un enfoque es usar RefCell para permitir una mutabilidad interna:

   use std::cell::RefCell;
   
   struct MyStruct {
       // Usar RefCell para permitir mutabilidad interna
       connections: RefCell<><connection>>,
       // ... otros campos ...
   }
   
   impl MyStruct {
       fn loop_fn(&mut self) {
           // Clonar el remitente para evitar prestar `self` nuevamente
           let sender_to_connector = self.sender_to_connector.clone();
           loop {
               // Usar borrow_mut() para obtener una referencia mutable al vector de conexiones
               let future1 = self.handle_new_connections(sender_to_connector.clone(), &mut self.connections.borrow_mut());
               let future2 = self.handle_incoming_message(&mut receiver_from_peers);
               let future3 = self.handle_outgoing_message();
   
               tokio::pin!(future1, future2, future3);
               tokio::select! {
                   _=future1=>{},
                   _=future2=>{},
                   _=future3=>{},
               }
           }
       }
   
       fn handle_new_connections(&mut self, sender: Sender<message>, connections: &mut Vec<connection>) -> FutureResult<(), ()> {
           // ... manejar nuevas conexiones usando la referencia mutable a `connections` ...
       }
   
       fn handle_incoming_message(&mut self, receiver: &mut Receiver<message>) -> FutureResult<(), ()> {
           // ... manejar mensajes entrantes ...
       }
   
       fn handle_outgoing_message(&mut self) -> FutureResult<(), ()> {
           // ... manejar mensajes salientes ...
       }
   }
   

   Aquí, declaramos el campo connections como RefCell<><connection>>, lo que nos permite obtener una referencia mutable al vector usando borrow_mut(). El método handle_new_connections() toma esta referencia mutable como parámetro, junto con el clon de sender_to_connector.

   Ten en cuenta que también necesitamos usar &mut receiver_from_peers al llamar a handle_incoming_message(), ya que requiere una referencia mutable.

   Con estos cambios, el método loop_fn() debería poder ejecutarse sin el error de “préstamo mutable más de una vez”.

Comments are closed.