TD 6 généricité

src/main/java/fr/univamu/progav/td6/ArrayCellLens.java

+package fr.univamu.progav.td6;
+
+public class ArrayCellLens<T> implements Lens<T> {
+
+  // TODO ajouter les propriétés
+
+  public ArrayCellLens(T[] array, int index) {
+    // TODO
+  }
+
+  @Override
+  public T get() {
+    // TODO
+    return null;
+  }
+
+  @Override
+  public void set(T t) {
+    // TODO
+  }
+}

src/main/java/fr/univamu/progav/td6/Box.java

+package fr.univamu.progav.td6;
+
+public class Box implements Lens<Integer> {
+
+  private int content;
+
+  public Box(int content) {
+    this.content = content;
+  }
+
+  @Override
+  public void set(Integer newContent) {
+    this.content = newContent;
+  }
+
+  @Override
+  public Integer get() {
+    return this.content;
+  }
+}

src/main/java/fr/univamu/progav/td6/Lens.java

+package fr.univamu.progav.td6;
+
+public interface Lens<T> {
+  void set(T t);
+  T get();
+}

src/main/java/fr/univamu/progav/td6/ListCellLens.java

+package fr.univamu.progav.td6;
+
+import java.util.List;
+
+public class ListCellLens<T> implements Lens<T> {
+
+  // TODO ajouter les propriétés
+
+  public ListCellLens(List<T> list, int index) {
+    // TODO
+  }
+
+  @Override
+  public void set(T t) {
+    // TODO
+  }
+
+  @Override
+  public T get() {
+    // TODO
+    return null;
+  }
+}

src/main/java/fr/univamu/progav/td6/TD6.md

+Ces exercices ont pour sujet une interface `Lens` générique, permettant 
+de représenter un emplacement mémoire autorisant la lecture et l'écriture.
+
+Prendre connaissance de cette interface, qui propose deux méthodes `set`
+et `get`.
+
+
+Exercice 1
+==========
+
+Rendre la classe `Box` générique. Pour l'instant elle implémente un 
+`Lens<Integer>`, mais nous voulons l'utiliser avec d'autres types.
+
+Modifier la méthode de test `genericTest` de la classe `BoxTest` pour qu'elle 
+fonctionne.
+
+Exercice 2
+==========
+
+Étant donné une liste, chaque case de la liste est accessible en lecture et 
+en écriture. Il est donc possible de décrire chaque case avec l'interface 
+`Lens`. Compléter la classe générique `ListCellLens`, prenant une liste et 
+l'indice d'une case en paramètre du constructeur, et représentant la case ainsi 
+désignée.
+
+Vérifiez votre travail à l'aide des tests `ListCellLensTest` associés à la 
+classe.
+
+Exercice 3
+==========
+
+Nous pouvons faire la même chose avec les tableaux. Compléter la classe 
+générique `ArrayCellLens`, prenant un tableau et
+l'indice d'une case en paramètre du constructeur, et représentant la case ainsi
+désignée.
+
+Vérifiez votre travail à l'aide des tests `ArrayCellLensTest` associés à la 
+classe.
+
+Exercice 4
+==========
+
+Si vous essayez d'utiliser `ArrayCellLens` avec un tableau de type `int[]`, 
+cela produit une erreur à la compilation. Pourquoi ?
+
+Ajouter une classe `IntArrayCellLens` pour pouvoir faire un `Lens` sur une 
+case d'un tableau de type `int[]`.
+
+Ajouter un test dans la classe `ArrayCellLensTest`, s'assurant du bon 
+fonctionnement des méthodes `set` et `get` pour une case d'un tableau de 
+type `int[]`
+
+Exercice 5 (Optionnel)
+======================
+
+Nous pouvons utiliser un objet de type `Lens` pour stocker une valeur sous 
+un format compressé. Pour un type `S` (dont les valeurs prennent beaucoup de 
+place), si nous disposons d'une fonction de compression `f` vers un type `T` 
+(nécessitant moins de place), et de son inverse `g`, nous pouvons 
+représenter une valeur `s` de type `S` en stockant uniquement `f(s)`. La 
+méthode `get` applique automatiquement `g` pour retrouver la valeur initiale 
+(de type `S`). La méthode `set` applique automatiquement `f` pour ne stocker 
+qu'une image (de type `T`). Ainsi, nous réduisons l'espace utilisé, en 
+échange d'un coût de calcul des fonctions `f` et `g` `chaque opération.
+
+Ajouter une interface `Bijection` permettant de représenter par deux 
+méthodes les fonctions `f` et `g`.
+
+Ensuite créer une classe `ConvertingLens`, de type `Lens<S>`, et ayant une 
+propriété de type `T`. Le constructeur sera paramétré par la bijection à 
+utiliser.
+
+Tester avec `S = String`, `T = Integer`, en se restreignant aux chaînes de 
+caractères correspondant à des nombres décimaux (comme `"129873"`)

src/test/java/fr/univamu/progav/td6/ArrayCellLensTest.java

+package fr.univamu.progav.td6;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ArrayCellLensTest {
+
+  @Test
+  void testGet() {
+    Integer[] array = {4, 3, 2, 1};
+    Lens<Integer> lens1 = new ArrayCellLens<>(array, 1);
+    assertEquals(3, lens1.get());
+    array[1] = 5;
+    assertEquals(5, lens1.get());
+  }
+
+  @Test
+  void testSet() {
+    Integer[] array = {4, 3, 2, 1};
+    Lens<Integer> lens1 = new ArrayCellLens<>(array, 1);
+    lens1.set(8);
+    assertEquals(8, lens1.get());
+  }
+
+
+  @Test
+  void testSetModifyArray() {
+    Integer[] array = {4, 3, 2, 1};
+    Lens<Integer> lens1 = new ArrayCellLens<>(array, 1);
+    lens1.set(5);
+    assertEquals(5, lens1.get());
+    assertEquals(5, array[1]);
+    assertEquals(4, array[0]);
+    assertEquals(2, array[2]);
+  }
+
+}

src/test/java/fr/univamu/progav/td6/BoxTest.java

+package fr.univamu.progav.td6;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BoxTest {
+
+  @Test
+  void testGet() {
+    Lens<Integer> box = new Box(0);
+    assertEquals(0,box.get());
+    box = new Box(42);
+    assertEquals(42,box.get());
+  }
+
+  @Test
+  void testSet() {
+    Lens<Integer> box = new Box(0);
+    box.set(3);
+    assertEquals(3,box.get());
+    box.set(5);
+    assertEquals(5,box.get());
+    box.set(-3);
+    assertEquals(-3,box.get());
+  }
+
+
+  @Test
+  void genericBox() {
+    Lens<String> box = null; // TODO créer une boîte contenant "foo"
+    assertEquals("foo", box.get());
+    box.set("bar");
+    assertEquals("bar", box.get());
+    Lens<Lens<Integer>> boxbox = null; // TODO créer une boîte contenant une boîte contenant 0
+    boxbox.get().set(2);
+    assertEquals(2,boxbox.get().get());
+  }
+
+}
\ No newline at end of file

src/test/java/fr/univamu/progav/td6/ListCellLensTest.java

+package fr.univamu.progav.td6;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ListCellLensTest {
+
+  @Test
+  void testGet() {
+    List<Integer> list = new ArrayList<>(List.of(4,3,2,1));
+    Lens<Integer> lens1 = new ListCellLens<>(list, 1);
+    assertEquals(3, lens1.get());
+    list.set(1,5);
+    assertEquals(5, lens1.get());
+  }
+
+  @Test
+  void testSet() {
+    List<Integer> list = new ArrayList<>(List.of(4,3,2,1));
+    Lens<Integer> lens1 = new ListCellLens<>(list, 1);
+    lens1.set(8);
+    assertEquals(8, lens1.get());
+  }
+
+
+  @Test
+  void testSetModifyList() {
+    List<Integer> list = new ArrayList<>(List.of(4,3,2,1));
+    Lens<Integer> lens1 = new ListCellLens<>(list, 1);
+    lens1.set(5);
+    assertEquals(5, lens1.get());
+    assertEquals(5, list.get(1));
+    assertEquals(4, list.get(0));
+    assertEquals(2, list.get(2));
+  }
+
+}
\ No newline at end of file