Monteur

// L’utilisation du patron de conception monteur n’est
// conseillée que si vos produits sont complexes et nécessitent
// une configuration étendue. Bien qu’ils n’aient pas la même
// interface, les deux produits suivants sont liés.
class Car is
    // Une voiture est équipée d’un GPS, d’un ordinateur de bord
    // et d'un certain nombre de sièges. Les différents modèles
    // de voitures (sport, SUV, cabriolet) ont différentes
    // fonctionnalités installées ou activées.

class Manual is
    // Chaque voiture doit avoir un manuel d’utilisation qui
    // correspond à sa configuration et décrit toutes ses
    // fonctionnalités.


// L’interface du monteur contient des méthodes spécialisées
// pour créer les différentes parties des objets du produit.
interface Builder is
    method reset()
    method setSeats(...)
    method setEngine(...)
    method setTripComputer(...)
    method setGPS(...)

// Les classes concrètes du monteur suivent l’interface monteur
// et procurent des implémentations spécifiques pour les étapes
// de la fabrication. Votre programme peut contenir plusieurs
// variantes de monteurs, chacune avec sa propre implémentation.
class CarBuilder implements Builder is
    private field car:Car

    // Une instance monteur fraichement créée doit contenir un
    // objet produit vide qu’elle va ensuite assembler.
    constructor CarBuilder() is
        this.reset()

    // La méthode reset nettoie l’objet qui est construit.
    method reset() is
        this.car = new Car()

    // Toutes les étapes de la fabrication manipulent la même
    // instance du produit.
    method setSeats(...) is
        // Configure le nombre de sièges dans la voiture.

    method setEngine(...) is
        // Installe un moteur donné.

    method setTripComputer(...) is
        // Installe un ordinateur de bord.

    method setGPS(...) is
        // Installe un système de géolocalisation.

    // Les monteurs concrets sont censés fournir leurs propres
    // méthodes pour récupérer les résultats. Ce fonctionnement
    // permet aux différents types de monteurs de créer des
    // produits entièrement différents qui ne suivent pas la
    // même interface. Par conséquent, les méthodes ne peuvent
    // pas être déclarées dans l’interface du monteur (en tout
    // cas pas dans un langage de programmation doté d’un
    // système de typage statique).
    //
    // En général, après avoir retourné le résultat final au
    // client, une instance de monteur doit être prête à lancer
    // la fabrication d’un autre produit. C’est pour cette
    // raison que l’on appelle généralement la méthode reset à
    // la fin du corps de la méthode `getProduct`. Mais ce
    // comportement n’est pas obligatoire et votre monteur peut
    // attendre que le code client lance un appel explicite à un
    // reset pour vous débarrasser du résultat précédent.
    method getProduct():Car is
        product = this.car
        this.reset()
        return product

// Contrairement aux autres patrons de création, le monteur vous
// permet de fabriquer des produits qui ne suivent pas la même
// interface.
class CarManualBuilder implements Builder is
    private field manual:Manual

    constructor CarManualBuilder() is
        this.reset()

    method reset() is
        this.manual = new Manual()

    method setSeats(...) is
        // Fonctionnalités des sièges dans le manuel.

    method setEngine(...) is
        // Ajoute les informations concernant le moteur.

    method setTripComputer(...) is
        // Ajoute les instructions concernant l’ordinateur de
        // bord.

    method setGPS(...) is
        // Ajoute les instructions concernant le GPS.

    method getProduct():Manual is
        // Retourne le manuel et remet à zéro le monteur
        // (reset).


// Le directeur a pour seule responsabilité l’ordonnancement des
// étapes de la fabrication. Il se révèle utile lorsque vous
// fabriquez des produits avec un ordre précis ou dans une
// configuration particulière. À proprement parler, la classe
// Directeur n’est pas obligatoire, car le client peut manipuler
// les monteurs directement.
class Director is
    // Le directeur manipule n’importe quelle instance de
    // monteur que le code client lui envoie. Ainsi, le code
    // client peut modifier le type final du produit qui vient
    // d’être assemblé. Le directeur peut fabriquer plusieurs
    // variantes de produits en utilisant les mêmes étapes de
    // fabrication.
    method constructSportsCar(builder: Builder) is
        builder.reset()
        builder.setSeats(2)
        builder.setEngine(new SportEngine())
        builder.setTripComputer(true)
        builder.setGPS(true)

    method constructSUV(builder: Builder) is
        // ...


// Le code client crée un objet monteur, le passe au directeur
// et lance le processus de fabrication. Le résultat final est
// récupéré dans l’objet monteur.
class Application is

    method makeCar() is
        director = new Director()

        CarBuilder builder = new CarBuilder()
        director.constructSportsCar(builder)
        Car car = builder.getProduct()

        CarManualBuilder builder = new CarManualBuilder()
        director.constructSportsCar(builder)

        // Le produit final est souvent récupéré depuis un objet
        // monteur, car le directeur est indépendant des
        // monteurs et des produits concrets et il ne les voit
        // donc pas.
        Manual manual = builder.getProduct()