Dependency Injection

main.rs

use std::rc::Rc;

/*
    Box -> Référencer une valeur sans connaitre à la compilation sa taille en mémoire
    Rc -> reference count
    Arc -> atomic reference count
*/

struct Car {
    engine: Engine,
    wheels: Vec<Rc<Wheel>>,
    brake: Rc<Brake>
}
impl Car {
    fn new() -> Car {
        let brake = Rc::new(Brake::new());

        let front_right_wheel = Rc::new(Wheel::new(brake.clone()));
        let front_left_wheel = Rc::new(Wheel::new(brake.clone()));

        let wheels_as_ref = Vec::from([front_right_wheel.clone(), front_left_wheel.clone()]);

        let engine = Engine::new(wheels_as_ref);
        Car {
            engine,
            wheels: Vec::from([front_left_wheel, front_right_wheel]),
            brake
        }
    }

    fn start(&self) {
        print!("Vroum");
    }
}

struct Engine {
    wheels: Vec<Rc<Wheel>>,
}
impl Engine {
    fn new(wheels: Vec<Rc<Wheel>>) -> Engine {
        Engine {
            wheels
        }
    }
}

struct Wheel {
    brake: Rc<Brake>,
}
impl Wheel {
    fn new(brake: Rc<Brake>) -> Wheel{
        Wheel {
            brake
        }
    }
}

struct Brake {}
impl Brake {
    fn new() -> Brake {
        Brake { }
    }
}


fn main() {
    let car = Car::new();
    car.start();
}