Method Chaining

Teil des Abschnitts Objektorientierte Programmierung der Rust-Journey von Coddy. Lektion 6 von 61.

Bisher haben unsere veränderlichen Methoden die Struktur verändert und nichts zurückgegeben. Aber was ist, wenn wir mehrere Methoden nacheinander für dieselbe Instanz aufrufen möchten? Indem wir eine Referenz auf self zurückgeben, ermöglichen wir Methodenverkettung: ein Muster, bei dem mehrere Methodenaufrufe in einem einzigen Ausdruck ineinander übergehen.

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
    }
}

Jede Methode verändert die Struktur und gibt anschließend self zurück: eine veränderliche Referenz auf dieselbe Instanz. Dadurch kann der nächste Methodenaufruf sofort mit ihr fortfahren:

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 drei 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 Einstellungen eingerichtet werden, und macht deinen Code kompakter und besser lesbar.

Aufgabe

Einfach

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

Füge einen Implementierungsblock für TextStyle mit Folgendem hinzu:

new: eine zugehörige Funktion, die eine TextStyle-Struktur zurückgibt, bei der bold auf false, italic auf false und size auf 12 gesetzt ist
set_bold: nimmt &mut self und einen bool-Wert entgegen, setzt das Feld für Fettdruck und gibt für Verkettungen &mut Self zurück
set_italic: nimmt &mut self und einen bool-Wert entgegen, setzt das Kursivfeld und gibt für Verkettungen &mut Self zurück
set_size: nimmt &mut self und einen u32-Wert entgegen, setzt das Größenfeld und gibt für Verkettungen &mut Self zurück

Du erhältst drei Eingaben:

Erste Zeile: Einstellung für Fettdruck (true oder false)
Zweite Zeile: Einstellung für Kursivschrift (true oder false)
Dritte Zeile: Schriftgröße (u32)

Erstelle mithilfe von new eine veränderbare TextStyle-Struktur und wende anschließend mithilfe von Methodenverkettung alle drei Einstellungen in einem einzigen Ausdruck an. Gib den endgültigen Zustand im unten gezeigten Format aus.

Erwartetes Ausgabeformat:

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}
    
}