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 #

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

   

2. 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);
   
                });
       }