Method Berantai

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Rust di Coddy. Pelajaran 6 dari 61.

Sejauh ini, method yang dapat diubah telah mengubah struct dan tidak mengembalikan apa pun. Namun, bagaimana jika kita ingin memanggil beberapa method secara berurutan pada instance yang sama? Dengan mengembalikan referensi ke self, kita dapat menggunakan method chaining: pola yang menggabungkan beberapa pemanggilan method dalam satu ekspresi.

Kuncinya adalah membuat method &mut self mengembalikan &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
    }
}

Setiap method memodifikasi struct, lalu mengembalikan self: referensi yang dapat diubah kembali ke instance yang sama. Ini memungkinkan pemanggilan method berikutnya langsung melanjutkan proses pada instance tersebut:

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

Daripada menulis tiga pernyataan terpisah, kita mengatur semuanya dalam satu baris yang mengalir. Pola bergaya builder ini sangat berguna saat menyiapkan object dengan banyak pengaturan opsional, sehingga kodemu lebih ringkas dan mudah dibaca.

Tantangan

Mudah

Buat struct TextStyle dengan tiga field: bold (bool), italic (bool), dan size (u32).

Tambahkan blok implementasi untuk TextStyle dengan hal-hal berikut:

new: fungsi terkait yang mengembalikan TextStyle dengan bold bernilai false, italic bernilai false, dan size bernilai 12
set_bold: menerima &mut self dan nilai bool, menetapkan field bold, lalu mengembalikan &mut Self agar bisa dirangkai
set_italic: menerima &mut self dan nilai bool, menetapkan field italic, lalu mengembalikan &mut Self agar bisa dirangkai
set_size: menerima &mut self dan nilai u32, menetapkan field size, lalu mengembalikan &mut Self agar bisa dirangkai

Kamu akan menerima tiga input:

Baris pertama: pengaturan bold (true atau false)
Baris kedua: pengaturan italic (true atau false)
Baris ketiga: ukuran font (u32)

Buat TextStyle yang mutable menggunakan new, lalu gunakan perangkaian method untuk menerapkan ketiga pengaturan dalam satu ekspresi. Cetak keadaan akhirnya dengan format yang ditunjukkan di bawah ini.

Format output yang diharapkan:

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

Coba sendiri

use std::io;

// TODO: Definisikan struct TextStyle di sini


// TODO: Tambahkan blok implementasi untuk TextStyle dengan:
// - fungsi terkait new()
// - method set_bold()
// - method set_italic()
// - method set_size()


fn main() {
    let mut input = String::new();
    
    // Baca pengaturan bold
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Baca pengaturan italic
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Baca pengaturan size
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO: Buat TextStyle yang dapat diubah menggunakan new(), lalu rangkai pemanggilan method
    // untuk menerapkan ketiga pengaturan dalam satu ekspresi
    
    
    // TODO: Cetak hasil dengan format: Bold: {bold}, Italic: {italic}, Size: {size}
    
}