Mediator design pattern in Rust - rust

Question

Please suggest how to implement such a design. I understand that mediator needs to be passed as a reference. But I can't figure out the lifetime parameter.
//Colleague
struct Switcher {
state: bool,
mediator: SyncMediator
}
impl Switcher {
fn sync(self) {
self.mediator.sync(self.state);
}
fn get_state(&self) -> bool {
return self.state;
}
fn set_state(&mut self, value: bool) {
self.state = value;
}
}
//ConcreteMediator
struct SyncMediator {
switchers: Vec<Switcher>
}
impl SyncMediator {
fn sync(mut self, state: bool) {
for i in 0..self.switchers.len() {
self.switchers[i].set_state(state);
}
}
fn add(&mut self, switcher: Switcher) {
self.switchers.push(switcher);
}
}
fn main() {
//Client
let mediator = SyncMediator {
switchers: vec![] };
let mut switcher1 = Switcher {
mediator: mediator, state: false };
let switcher2 = Switcher {
mediator: mediator, state: false };
let switcher3 = Switcher {
mediator: mediator, state: false };
switcher1.set_state(true);
let mut state2 = switcher2.get_state();
//state2 is false
let mut state3 = switcher3.get_state();
//state3 is false
println!("state2 is {state2}");
println!("state2 is {state3}");
switcher1.sync();
state2 = switcher2.get_state();
//state2 is true
state3 = switcher3.get_state();
//state3 is true
println!("state2 is {state2}");
println!("state2 is {state3}");
}

Answer 1

You can find a detailed explanation of the Mediator pattern in Rust here: https://github.com/fadeevab/mediator-pattern-rust
In short, there are two approaches:
Cross-Referencing with Rc<RefCell<..>>. It's kind of mimicking a classic OOP with Rust.
In your case, you'd have
let mediator = Rc::new(RefCell::new(SyncMediator { .. }));
let switcher1 = Rc::new(Switcher { mediator: mediator.clone(), .. });
{
let mut mediator = mediator.borrow_mut();
mediator.add(switcher1.clone());
mediator.add(switcher2.clone());
}
passing the references across the objects. I call it a "naive" approach.
Top-down ownership approach, which adapts a classic Mediator definition to what could be safely and idiomatically done in the Rust language.
You should create a mediator, switchers, then you should move ownership of switchers to the mediator, and overall do like this:
let mut mediator = SyncMediator { .. };
let switcher1 = Switcher { name: "switcher1", .. };
mediator.add(switcher1);
mediator.add(switcher2);
// Then, work with the mediator at the top level.
mediator.set_state("switcher1", true);
where the switcher receives the mediator object as a function parameter:
impl Switcher {
fn set_state(&mut self, value: bool, mediator: &mut SyncMediator) {
self.state = value;
mediator.sync();
}
}
P.S.: The following image illustrates an example of interactions between visual components, where the Dialog is the Mediator.