Łańcuchowe wywoływanie metod

Część sekcji Programowanie obiektowe ścieżki Rust w Coddy. Lekcja 6 z 61.

Jak dotąd nasze metody modyfikujące zmieniały strukturę i niczego nie zwracały. Ale co, jeśli chcemy wywołać kilka metod jedna po drugiej na tej samej instancji? Zwracając referencję do self, umożliwiamy łączenie metod: wzorzec, w którym wiele wywołań metod łączy się w jedno wyrażenie.

Kluczem jest to, aby metody &mut self zwracały &mut Self:

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

Każda metoda modyfikuje strukturę, a następnie zwraca self: mutowalne odwołanie do tej samej instancji. Dzięki temu następne wywołanie metody może od razu kontynuować pracę na niej:

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

Zamiast pisać trzy osobne instrukcje, konfigurujemy wszystko w jednym płynnym wierszu. Ten wzorzec „w stylu kreatora” jest szczególnie przydatny podczas konfigurowania obiektów z wieloma opcjonalnymi ustawieniami, dzięki czemu kod jest bardziej zwięzły i czytelny.

Wyzwanie

Łatwy

Utwórz strukturę TextStyle z trzema polami: bold (bool), italic (bool) i size (u32).

Dodaj blok implementacji dla TextStyle z następującymi elementami:

new: funkcja skojarzona, która zwraca TextStyle z polem bold ustawionym na false, polem italic ustawionym na false i polem size ustawionym na 12
set_bold: przyjmuje &mut self i wartość typu bool, ustawia pole bold i zwraca &mut Self, aby umożliwić łączenie metod
set_italic: przyjmuje &mut self i wartość typu bool, ustawia pole italic i zwraca &mut Self, aby umożliwić łączenie metod
set_size: przyjmuje &mut self i wartość typu u32, ustawia pole size i zwraca &mut Self, aby umożliwić łączenie metod

Otrzymasz trzy dane wejściowe:

Pierwszy wiersz: ustawienie bold (true lub false)
Drugi wiersz: ustawienie italic (true lub false)
Trzeci wiersz: rozmiar czcionki (u32)

Utwórz mutowalny obiekt TextStyle za pomocą new, a następnie użyj łączenia metod, aby zastosować wszystkie trzy ustawienia w jednym wyrażeniu. Wypisz końcowy stan w formacie pokazanym poniżej.

Oczekiwany format wyjścia:

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

Spróbuj swoich sił

use std::io;

// TODO: Zdefiniuj tutaj strukturę TextStyle


// TODO: Dodaj blok implementacji dla TextStyle zawierający:
// - funkcję powiązaną new()
// - metodę set_bold()
// - metodę set_italic()
// - metodę set_size()


fn main() {
    let mut input = String::new();
    
    // Odczytaj ustawienie pogrubienia
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Odczytaj ustawienie kursywy
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Odczytaj ustawienie rozmiaru
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO: Utwórz modyfikowalny obiekt TextStyle za pomocą new(), a następnie połącz wywołania metod
    // aby zastosować wszystkie trzy ustawienia w jednym wyrażeniu
    
    
    // TODO: Wypisz wynik w formacie: Bold: {bold}, Italic: {italic}, Size: {size}
    
}