Esiste un modo per utilizzare autonomamente un metodo come Rc <RefCell<T>>?

Question

Ho una struttura (Foo) che ha un campo Rc<RefCell<Bar>>, Barra ha un metodo che viene chiamato da un Rc<RefCell<Bar>>, in quel metodo ottiene un riferimento a Foo e vorrei impostare quello Rc<RefCell<Bar>> in quello Foo al Bar che ha chiamato il metodo.

Si consideri il seguente codice:

struct Foo { 
    thing: Rc<RefCell<Bar>>, 
} 

struct Bar; 

impl Foo { 
    pub fn set_thing(&mut self, thing: Rc<RefCell<Bar>>) { 
     self.thing = thing; 
    } 
} 

impl Bar { 
    pub fn something(&mut self) { 
     // Things happen, I get a &mut to a Foo, and here I would like to use this Bar reference 
     // as the argument needed in Foo::set_thing    
    } 
} 

// Somewhere else 
// Bar::something is called from something like this: 
let my_bar : Rc<RefCell<Bar>> = Rc::new(RefCell::new(Bar{})); 
my_bar.borrow_mut().something(); 
// ^--- I'd like my_bar.clone() to be "thing" in the foo I get at Bar::something 

è l'unico modo per fare quello che voglio aggiungere un altro parametro da Bar::something accettare un Rc<RefCell<Bar>>? Sembra ridondante, quando già lo chiamo da uno.

pub fn something(&mut self, rcSelf: Rc<RefCell<Bar>>) { 
     foo.set_thing(rcSelf); 

Answer 1

Ci sono due scelte principali qui:

• utilizzare un metodo statico:

  impl Bar { 
      pub fn something(self_: Rc<RefCell<Bar>>) { 
       … 
      } 
  } 
  
  Bar::something(my_bar) 
  

• nascondere il fatto che si sta utilizzando Rc<RefCell<X>>, avvolgendolo in un nuovo tipo con il campo singolo Rc<RefCell<X>>; quindi altri tipi possono utilizzare questo nuovo tipo anziché Rc<RefCell<Bar>> e puoi fare in modo che questo metodo something funzioni con self. Potrebbe non essere una buona idea, a seconda di come la usi. Senza ulteriori dettagli è difficile dirlo.