Ejecución de la pantalla

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy — lección 53 de 61.

Desafío

Fácil

¡Felicitaciones por llegar al paso final del proyecto del Sistema de Documentos! Has construido todas las piezas individuales: el trait Draw, TextField, Button y Screen. Ahora es el momento de darle a tu Screen la capacidad de renderizar todos sus componentes a la vez con una sola llamada a un método.

Completarás tu proyecto agregando un método run a la estructura Screen. Este método iterará a través de todos los componentes almacenados en la pantalla y llamará a draw() en cada uno, dando vida a todo tu sistema de documentos.

Tus archivos del proyecto:

draw.rs: Tu trait Draw con el método draw.
text_field.rs: Tu componente TextField que imprime "Text: {}".
button.rs: Tu componente Button que imprime "Button: {} (width: {})".
screen.rs: Tu estructura Screen con los métodos new y add. Agrega un método run que tome &self y llame a draw() en cada componente de la colección.
main.rs: Une todo: crea una Screen, agrega tus componentes y llama a run() para renderizar toda la pantalla de una sola vez.

El método run encapsula la lógica de renderizado dentro de Screen, haciendo que tu función principal sea limpia y sencilla. En lugar de iterar manualmente a través de los componentes en main, simplemente llamas a screen.run().

Se proporcionarán las siguientes entradas:

Primera línea: el contenido del campo de texto (text field)
Segunda línea: la etiqueta del botón (button's label)
Tercera línea: el ancho del botón (como un número)

Tu salida debe mostrar cada componente en su propia línea, en el orden en que fueron agregados:

Text: Dashboard
Button: Save (width: 120)

Pruébalo tú mismo

mod draw;
mod text_field;
mod button;
mod screen;

use draw::Draw;
use text_field::TextField;
use button::Button;
use screen::Screen;

pub struct Label {
    pub text: String,
}

impl Draw for Label {
    fn draw(&self) {
        println!("{}", self.text);
    }
}

fn main() {
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let content = input1.trim().to_string();

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let label = input2.trim().to_string();

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let width: u32 = input3.trim().parse().expect("Failed to parse width");

    let mut screen = Screen::new();

    let text_field = TextField { content };
    screen.add(Box::new(text_field));

    let button = Button { label, width };
    screen.add(Box::new(button));

    // TODO: Reemplazar la iteración manual de abajo con una sola llamada a screen.run()
    for component in &screen.components {
        component.draw();
    }
}