How to reference self in a spawned child object

[levitanus]

What I basically want to implement — a parent, that can spawn a child with reference to self. And if child gets mut — reference also gets mut.
If I create child object from scratch outside of parent — I can have parent in Rc<> and pass to child Rc copy. Which look good for me until I want to have elegant API (pseudo):

let parent = Parent::new();
parent.create_child(id="api test") \\ mut method
let child = parent.create_child(id="first child");  \\ mut method, but non-mut reference
let child2 = parent.create_child(id="second child"); \\ non mut
child2.change_id("second bud") \\ error — mut reference of parent

Since I make an high-level wrap of Cpp FFI to non-object API, I can avoid all the errors and warnings. But I would like to have something like this: when multiple child objects can be spawned by parent without borowing parent as &mut. Is it possible?

[quinedot]

As far as I can tell, you probably want Rc<RefCell<T>> or Arc<Mutex<T>> or similar. Read more here.

You may get a more precise response if you share some actual code and errors.

[levitanus]

Rc works great in case child is constructed outside the parent. e.g.

let parent = Rc::new(Parent::new());
let child = Child::new(parent.copy());

But how to make child in the method of parent?

impl Parent{
    fn make_child(&self) -> Child{
        Child{parent:self}
    }
}

[riking]

arbitrary_self_types is the unstable feature you want here: Tracking issue for `arbitrary_self_types` · Issue #44874 · rust-lang/rust · GitHub

It's usable today if you use UFCS instead of method call syntax.

impl Parent{
    fn make_child_with_n(self: &Rc<RefCell<Self>>, n: i32) -> Child{
        drop(n); // pretend we do something useful with it
        Child{parent: Rc::downgrade(Rc::clone(self))}
    }
}
fn main() {
  // ...
  let child = Parent::make_child_with_n(&parent, 3);
}

See also Rc::new_cyclic and rc::Weak.

[levitanus]

Interesting! Thank You, I'll try now!

P.S. real-world example. I'm sorry, it will take a while to make clean one-module example...

[riking]

If you want Track.name to be semantically settable without taking a &mut to the parent node, you can also consider wrapping only the name field in a RefCell.

struct Track {
  project: Weak<Project>,
  pointer: *mut MediaTrack,
  name: RefCell<Option<String>>,
}
impl Track {
  fn set_name(&self, name: impl Into<String>) {
    *self.name.borrow_mut() = Some(name.into);
  }
  fn remove_name(&self) { *self.name.borrow_mut() = None; }
  // ! Note change in function signature
  fn get_name(&self) -> Ref<'_, Option<&str>> { ... }
}

However, this gets complicated because you have long lived dynamic borrows being returned from get_name -- if any of those are standing when you call set_name, then borrow_mut will panic!

More complicated options include RefCell<Option<Rc<str>>> (solves Ref problems by returning Rc<str> from get_name) and other reference-counted string types, like the bytes crate bytes::Bytes.

[levitanus]

Thank You so much for the both examples! I need a bit of time to experiment with them. But, actually, I have an opposite problem: I do not have a error in place where I would like to see it (Track::set_name(& mut self) should also make ref to track.project mutable).

Or I have (currently) an option to carry &mut Project inside track, which will not allow having multiple immutable tracks in one scope and even have problems with iterations through them.

I'll write when got noticeable result)

[levitanus]

OK, this code behaves exactly like I want from it. But it not produces errors by rustcheck, which was my original wish. And, what bothers me more — that it makes the mutable behavior implicit, but for the crate I would like to see it explicit...

use std::rc::Rc;

struct Child {
    parent: Rc<Parent>,
}
impl Child {
    fn new(parent: Rc<Parent>) -> Self {
        Self { parent }
    }

    fn non_mut(&self) -> bool {
        self.parent.is_alive()
    }

    fn mut_f(&mut self, state: bool) {
        let parent = Rc::get_mut(&mut self.parent).unwrap();
        parent.make_alive(state)
    }
}

struct Parent {
    alive: bool,
}

impl Parent {
    fn new() -> Self {
        Self { alive: true }
    }
    fn make_child(self: &mut Rc<Self>) -> Child {
        Child::new(self.clone())
    }
    fn is_alive(&self) -> bool {
        self.alive
    }
    fn make_alive(&mut self, state: bool) {
        self.alive = state
    }
}

#[test]
fn childs() {
    let mut parent = Rc::new(Parent::new());
    let mut ch1 = parent.make_child();
    // let ch2 = parent.make_child(); // will error if uncommented
    drop(parent); // will error if commented
    println!("{}", ch1.non_mut());
    ch1.mut_f(false);
    // println!("{}", ch2.non_mut());  // will error if uncommented
}

[levitanus]

OK. I think, I finally found what I was looking for:

use std::ops::{Deref, DerefMut};

struct Child<T: Deref<Target = Parent>> {
    parent: T,
}
impl<T: Deref<Target = Parent>> Child<T> {
    fn new(parent: T) -> Self {
        Self { parent }
    }

    fn is_alive(&self) -> bool {
        self.parent.is_alive()
    }
}
impl<T: DerefMut<Target = Parent>> Child<T> {
    fn set_alive(&mut self, value: bool) {
        self.parent.make_alive(value);
    }
}

struct Parent {
    alive: bool,
}

impl Parent {
    fn new() -> Self {
        Self { alive: true }
    }
    fn make_child(self: &mut Self) -> Child<&Parent> {
        Child::new(self)
    }
    fn make_child_mut(self: &mut Self) -> Child<&mut Parent> {
        Child::new(self)
    }
    fn is_alive(&self) -> bool {
        self.alive
    }
    fn make_alive(&mut self, state: bool) {
        self.alive = state
    }
}

#[test]
fn childs() {
    let mut parent = Parent::new();
    let ch2 = parent.make_child();
    let mut ch1 = parent.make_child_mut();
    println!("{}", ch1.is_alive());
    ch1.set_alive(false);
    // println!("{}", ch2.is_alive()); // will not compille if uncommented.
}

UPD: Ahh, no. Now even immutable version of child from make_child borrows parent as mut until child drops.

[levitanus]

As an intermediate stable solution I've split creation of child (track) and getting it.
Works good and statically evaluates.

Only thing I would like to solve — making Iterator over &mut versions.

[levitanus]

Later I faced several problems with naive generic implementation. So, I've sketched the situation in one-module test, and found solution, that seems to me quite elegant: generic_mutability_test - Rust

env_logger::init();
let mut root = Root::new();
let window1 = root.make_child();
// Err: cannot borrow `root` as mutable more than once at a time
// let window2 = root.make_child(); // try to uncomment

let w1_id = window1.get_id(); // Drop window1 and finish &mut borrow of Root
debug!("{}", w1_id);
let id2 = root.make_child().get_id();
let _window1 = root.get_child(w1_id).unwrap();
let _window2 = root.get_child(id2).unwrap(); // OK!

// Err: no method named `make_button` found for struct `Window<'_,
// test::Immutable>` in the current scope. The method was found for
// `Window<'a, test::Mutable>`
// _window1.make_button()

let mut window1 = root.get_child_mut(w1_id).unwrap();
let button = window1.make_button();
let b_id = button.get_id();
let mut frame = window1.make_frame();
let fr_b_id = frame.make_button().get_id();
let f_id = frame.get_id();
// Err: cannot borrow `window1` as mutable more than once at a time
// debug!("button text: {}", button.get_text());

// Err: no method named `get_button` found for struct
// `Window<'_, test::Mutable>` in the current scope
// the method was found for - `Window<'a, test::Immutable>`
// let button = window1.get_button(b_id);
let window1 = root.get_child(w1_id).unwrap();
let frame = window1.get_frame(f_id).unwrap();
let w_b = window1.get_button(b_id).unwrap();
let fr_b = frame.get_button(fr_b_id).unwrap();

debug!("is window button clicked: {}", w_b.is_clicked());
debug!("is frame button clicked: {}", fr_b.is_clicked());