Théorie: singleton Vs collection #

Singleton #

Jusqu’à maintenant on a travaillé avec une seule instance de chaque modèle
- (singleton veut dire «une seule instance»)
```
└── models
    ├── ModeleFileAttente.json
    └── ModelePartie.json
```

Collection #

Souvent, un modèle correspond plutôt à une collection d’instances
Par exemple, on peut avoir une file d’attente pour chacune des régions ci-bas
On a alors plusieurs version du modèle, chacune identifée par un id de région unique
```
public enum Region {

    AFRIQUE, ASIE, AMERIQUE, EUROPE;

}
```

Dans le tutoriel 10, on transforme ModeleFileAttente en Collection:

└── models
    ├── ModeleFileAttente
        ├── AFRIQUE.json
        ├── AMERIQUE.json
        ├── ASIE.json
        └── EUROPE.json
    └── ModelePartie

NOTES:
- ModeleFileAttente est maintenant un répertoire (une collection)
- chaque fichier JSON du répertoire est une instance du modèle

Observer une instance en particulier #

Pour observer l’instance AMEMRIQUE, faire p.ex.

SessionPong session = Ntro.session();

session.setModelSelection(ModeleFileAttente.class, "AMERIQUE");

De façon plus générale, dans une méthode

public class SessionPong extends Session<SessionPong> {

    // ...

    private Region                regionCourante      = Region.AMERIQUE;

    public SessionPong memoriserRegionCourante(Region region) {
        this.regionCourante = region;


        return this;
    }

    public SessionPong observerRegionCourante() {

        this.setModelSelection(ModeleFileAttente.class, regionCourante.name());

        return this;
    }

Modifier une instance en particulier #

Si on envoi un message, c’est l’instance observée qui sera modifiée

// observer l'instance AMERIQUE
Ntro.session(SessionPong.class)
    .setModelSelection(ModeleFileAttente.class, "AMERIQUE");

// comme AMERIQUE est observée
// le message ci-bas va modifier l'instance AMERIQUE
Ntro.newMessage(MsgAjouterRendezVous.class)
    .setPremierJoueur(/* ... */)
    .send();

On peut aussi préciser quelle instance modifier pour chaque message

// on précise quelle instance modifier pour CE message
Ntro.newMessage(MsgAjouterRendezVous.class)
    .setModelSelection(ModeleFileAttente.class, "AMERIQUE");
    .setPremierJoueur(/* ... */)
    .send();

Les tâches et le reste du code ne change pas #

On a le même graphe de tâche, p.ex.

L’instance du modèle est chargée avant que le code s’exécute:

private static void afficherFileAttente(FrontendTasks tasks) {

    tasks.task("afficherFileAttente")

         .waitsFor(modified(ModeleFileAttente.class))  // va charger une instance du modèle

         .waitsFor(created(VueFileAttente.class))

         .executes(inputs -> {

             VueFileAttente              vueFileAttente = inputs.get(created(VueFileAttente.class));
             Modified<ModeleFileAttente> fileAttente    = inputs.get(modified(ModeleFileAttente.class));

             // le code ne change pas, mais il s'applique à une autre instance
             // selon l'instance observée en ce moment
             fileAttente.currentValue().afficherSur(vueFileAttente);

         });
}