Chaînage de méthodes

Fait partie de la section Programmation Orientée Objet du Journey Rust de Coddy. Leçon 6 sur 61.

Jusqu’à présent, nos méthodes mutables ont modifié la structure et n’ont rien renvoyé. Mais que faire si nous voulons appeler plusieurs méthodes à la suite sur la même instance ? En renvoyant une référence vers self, nous permettons le chaînage de méthodes : un modèle dans lequel plusieurs appels de méthodes s’enchaînent au sein d’une seule expression.

L’essentiel est que vos méthodes &mut self renvoient &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
    }
}

Chaque méthode modifie la structure, puis renvoie self : une référence mutable vers la même instance. Cela permet à l’appel de méthode suivant de continuer immédiatement à travailler dessus :

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

Au lieu d’écrire trois instructions distinctes, nous configurons tout en une seule ligne fluide. Ce modèle de type « builder » est particulièrement utile lors de la configuration d’objets comportant de nombreux paramètres facultatifs, ce qui rend votre code plus concis et plus lisible.

Défi

Facile

Créez une structure TextStyle avec trois champs : bold (bool), italic (bool) et size (u32).

Ajoutez un bloc d’implémentation pour TextStyle avec les éléments suivants :

new : une fonction associée qui renvoie un TextStyle avec bold défini sur false, italic défini sur false et size défini sur 12
set_bold : prend &mut self et une valeur bool, définit le champ bold et renvoie &mut Self pour permettre l’enchaînement
set_italic : prend &mut self et une valeur bool, définit le champ italic et renvoie &mut Self pour permettre l’enchaînement
set_size : prend &mut self et une valeur u32, définit le champ size et renvoie &mut Self pour permettre l’enchaînement

Vous recevrez trois entrées :

Première ligne : paramètre gras (true ou false)
Deuxième ligne : paramètre italique (true ou false)
Troisième ligne : taille de police (u32)

Créez un TextStyle mutable à l’aide de new, puis utilisez l’enchaînement de méthodes pour appliquer les trois paramètres dans une seule expression. Affichez l’état final au format indiqué ci-dessous.

Format de sortie attendu :

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

Essayez vous-même

use std::io;

// TODO: Définir la structure TextStyle ici


// TODO: Ajouter le bloc d'implémentation pour TextStyle avec :
// - fonction associée new()
// - méthode set_bold()
// - méthode set_italic()
// - méthode set_size()


fn main() {
    let mut input = String::new();
    
    // Lire le paramètre bold
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Lire le paramètre italic
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Lire le paramètre size
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO: Créer un TextStyle mutable en utilisant new(), puis utiliser le chaînage de méthodes
    // pour appliquer les trois paramètres en une seule expression
    
    
    // TODO: Afficher le résultat au format : Bold: {bold}, Italic: {italic}, Size: {size}
    
}