Examen de Java Avancé

Exercice 1 - Interpolator

package fr.uge.interpolation;

public record Hole(int argumentIndex) {
  @Override
  public String toString() {
    return "Hole(" + argumentIndex + ')';
  }
}
      

package fr.uge.interpolation;

public record Text(String text) {
  @Override
  public String toString() {
    return "Text(" + text + ')';
  }
}
      

    index = 0;
    loop: tant que index < length(template):
      si template[index] == '@':
        index = index + 1
        print "HOLE !"
        continue loop;

      i = index + 1
      tant que i < template.length():
        si template[i] == '@'
          print "TEXT" avec les caractères de template entre index et i (non compris)
          index = i;
          continue loop;

        i = i + 1

      print "TEXT" avec caractères de template entre index et length(template) (non compris)
      index = length(template);
    
     

1. On cherche à créer la classe MutableInterpolator avec les méthodes addHole, holeCount, addText et segments. La méthode segment doit renvoyer une liste qui agit comme une vue, toute modification de l'Interpolator (par exemple, l'ajout d'un trou) devra être visible dans la liste même après que celle-ci ait déjà été créée.
   Implanter la classe MutableInterpolator sachant que les trous et les textes sont stockés dans une liste.
   Vérifier que les tests unitaires marqués "Q1" passent.
2. On souhaite maintenant implanter la méthode interpolate(arguments) qui effectue l'interpolation en remplaçant les trous des segments par les arguments pris en paramètre.
   De plus, on veut pouvoir manipuler la classe MutableInterpolator par son interface Interpolator.
   Créer l'interface Interpolator avec la méthode interpolate et implanter celle-ci dans la classe MutableInterpolator.
   Vérifier que les tests unitaires marqués "Q2" passent.
   Note : Java permet de faire des switchs sur les objets, et vous ne devriez pas avoir besoin de default.
3. On souhaite écrire dans l'interface Interpolator la méthode interpolateFields qui utilise les accesseurs d'une instance pour trouver les arguments utilisés pour l'interpolation.
   Par exemple, si on pré-suppose un record Person(String name, int age) et une instance new Person("John", 33), alors l'appel à interpolateFields avec un Interprolator, l'instance et les références sur les accesseurs Person::name et Person::age est équivalent à appeler la méthode interpolate avec les arguments "John" et 33.
   Vérifier que les tests unitaires marqués "Q3" passent.
4. On veut maintenant ajouter la méthode addTemplate(template) à la classe MutableInterpolator qui utilise l'algorithme de décomposition du template vu plus haut (en cherchant les '@') pour ajouter les segments correspondant.
   Écrire la méthode addTemplate et vérifier que les tests unitaires marqués "Q4" passent.
5. On souhaite écrire dans l'interface Interpolator la méthode iteratorFromTemplate(template) qui pour un template renvoie un itérateur qui permet de parcourir les trous et les textes toujours en utilisant le même algorithme. Bien sûr, l'itérateur doit être paresseux et ne pas découper la totalité du template au démarrage mais faire le travail au fur et à mesure.
   Écrire la méthode iteratorFromTemplate et vérifier que les tests unitaires marqués "Q5" passent.
6. On souhaite écrire dans l'interface Interpolator la méthode lazyInterpolator(template) qui pour un template, renvoie un Interpolator qui va utiliser l'itérateur écrit précédemment lors de l'interpolation. Chaque appel à la méthode interpolate devra utiliser un nouvel itérateur.
   Implanter la méthode lazyInterpolator et vérifier que les tests unitaires marqués "Q6" passent.
   Note : on peut remarquer que l'interface Interpolator a une seule méthode abstraite donc que l'Interpolator paresseux peut être écrit sous forme d'une lambda.
7. On souhaite écrire toujours dans l'interface Interpolator la méthode streamFromTemplate(template) qui renvoie un Stream des trous et des textes correspondant au template pris en paramètre en utilisant l'algorithme vu plus haut.
   Vérifier que les tests unitaires marqués "Q7" passent.
   Note : pour la taille estimée, on peut remarquer que l'on peut calculer facilement le nombre maximal de segments possibles pour un template.
8. Modifier l'implantation de la méthode streamFromTemplate(template) pour que le Stream renvoyé soit parallélisable.
   Vérifier que les tests unitaires marqués "Q8" passent.
   Attention : les index dans les trous sont ordonnés !