Method Chaining

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

Bisher haben unsere veränderlichen Methoden das Struct modifiziert und nichts zurückgegeben. Aber was ist, wenn wir mehrere Methoden hintereinander für dieselbe Instanz aufrufen möchten? Durch die Rückgabe einer Referenz auf self ermöglichen wir Method Chaining – ein Muster, bei dem mehrere Methodenaufrufe in einem einzigen Ausdruck zusammenfließen.

Der Schlüssel liegt darin, dass Ihre &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 das Struct und gibt anschließend self zurück – eine veränderbare Referenz zurück auf dieselbe Instanz. Dies ermöglicht es dem nächsten Methodenaufruf, sofort weiter damit zu arbeiten:

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
}

Anstatt drei separate Anweisungen zu schreiben, konfigurieren wir alles in einer flüssigen Zeile. Dieses „Builder-Style“-Muster ist besonders nützlich beim Einrichten von Objekten mit vielen optionalen Einstellungen, was Ihren Code prägnanter und lesbarer macht.

Aufgabe

Einfach

Erstellen Sie ein TextStyle-Struct mit drei Feldern: bold (bool), italic (bool) und size (u32).

Fügen Sie einen Implementierungsblock für TextStyle mit folgendem Inhalt hinzu:

new — eine assoziierte Funktion, die ein TextStyle zurückgibt, bei dem bold auf false, italic auf false und size auf 12 gesetzt ist
set_bold — nimmt &mut self und einen bool-Wert entgegen, setzt das bold-Feld und gibt &mut Self für Method Chaining zurück
set_italic — nimmt &mut self und einen bool-Wert entgegen, setzt das italic-Feld und gibt &mut Self für Method Chaining zurück
set_size — nimmt &mut self und einen u32-Wert entgegen, setzt das size-Feld und gibt &mut Self für Method Chaining zurück

Sie erhalten drei Eingaben:

Erste Zeile: Bold-Einstellung (true oder false)
Zweite Zeile: Italic-Einstellung (true oder false)
Dritte Zeile: Schriftgröße (u32)

Erstellen Sie ein veränderbares TextStyle-Objekt mit new und verwenden Sie dann Method Chaining, um alle drei Einstellungen in einem einzigen Ausdruck anzuwenden. Geben Sie den Endzustand in dem unten gezeigten Format aus.

Erwartetes Ausgabeformat:

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

Spickzettel

Methoden, die &mut self entgegennehmen, können &mut Self zurückgeben, um Methodenverkettung (Method Chaining) zu ermöglichen:

impl Config {
    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
    }
}

Dies ermöglicht mehrere Methodenaufrufe in einem einzigen Ausdruck:

let mut config = Config::new();
config.set_debug(true).set_timeout(60);

Jede Methode verändert das Struct und gibt eine mutable Referenz auf dieselbe Instanz zurück, wodurch die nächste Methode sofort weiter damit arbeiten kann.

Probier es selbst

use std::io;

// TODO: Definiere hier das TextStyle-Struct


// 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();
    
    // Fett-Einstellung lesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Kursiv-Einstellung lesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Größen-Einstellung lesen
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO: Erstelle einen veränderbaren TextStyle mit new(), verwende dann Method Chaining,
    // um alle drei Einstellungen in einem einzigen Ausdruck anzuwenden
    
    
    // TODO: Gib das Ergebnis im Format aus: Bold: {bold}, Italic: {italic}, Size: {size}
    
}