Method Chaining

Teil des Abschnitts Object Oriented Programming der Rust-Journey von Coddy. Lektion 6 von 61.

Bisher haben unsere mutierenden Methoden die Struktur geändert und nichts zurückgegeben. Aber was, wenn wir mehrere Methoden nacheinander für dieselbe Instanz aufrufen möchten? Indem wir eine Referenz auf self zurückgeben, ermöglichen wir method chaining: ein Muster, bei dem mehrere Methodenaufrufe in einem einzigen Ausdruck zusammenfließen.

Der Schlüssel besteht darin, dass deine &mut self-Methoden &mut Self zurückgeben:

struct Config {
    debug: bool,
    timeout: u32,
}

impl Config {
    fn new() -> Config {
        Config { debug: false, timeout: 30 }
    }
    
    fn set_debug(&mut self, value: bool) -> &mut Self {
        self.debug = value;
        self
    }
    
    fn set_timeout(&mut self, seconds: u32) -> &mut Self {
        self.timeout = seconds;
        self
    }
}

Jedes method ändert den struct und gibt anschließend self zurück: eine mutable Referenz zurück auf dieselbe Instanz. Dadurch kann der nächste method-Aufruf sofort daran weiterarbeiten:

fn main() {
    let mut config = Config::new();
    
    config.set_debug(true).set_timeout(60);
    
    println!("Debug: {}, Timeout: {}", config.debug, config.timeout);
    // Ausgabe: Debug: true, Timeout: 60
}

Statt three separate Anweisungen zu schreiben, konfigurieren wir alles in einer einzigen flüssigen Zeile. Dieses Muster im „Builder-Stil“ ist besonders nützlich, wenn Objekte mit vielen optionalen settings eingerichtet werden, und macht deinen Code übersichtlicher und besser lesbar.

Aufgabe

Einfach

Create eine TextStyle-struct mit drei Feldern: bold (bool), italic (bool) und size (u32).

Add einen implementation block für TextStyle mit Folgendem hinzu:

new: eine associated function, die eine TextStyle mit auf false gesetztem bold, auf false gesetztem italic und auf 12 gesetztem size returnt
set_bold: nimmt &mut self und einen bool-Wert entgegen, setzt das bold-Feld und returnt &mut Self für chaining
set_italic: nimmt &mut self und einen bool-Wert entgegen, setzt das italic-Feld und returnt &mut Self für chaining
set_size: nimmt &mut self und einen u32-Wert entgegen, setzt das size-Feld und returnt &mut Self für chaining

Du erhältst drei Eingaben:

Erste Zeile: bold setting (true oder false)
Zweite Zeile: italic setting (true oder false)
Dritte Zeile: Schriftgröße (u32)

Create einen mutable TextStyle using new und verwende anschließend method chaining, um alle drei settings in einer einzigen expression anzuwenden. Gib den finalen Zustand im unten gezeigten format aus.

Expected output format:

Bold: {bold}, Italic: {italic}, Size: {size}

Probier es selbst

use std::io;

// TODO: Definiere die TextStyle-Struktur hier


// TODO: Füge den Implementierungsblock für TextStyle hinzu mit:
// - new() assoziierte Funktion
// - set_bold() Methode
// - set_italic() Methode
// - set_size() Methode


fn main() {
    let mut input = String::new();
    
    // Bold-Einstellung lesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Italic-Einstellung lesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Size-Einstellung lesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO: Erstelle ein veränderbares TextStyle mit new(), dann verwende Method Chaining
    // um alle drei Einstellungen in einem einzigen Ausdruck anzuwenden
    
    
    // TODO: Gib das Ergebnis im Format aus: Bold: {bold}, Italic: {italic}, Size: {size}
    
}