update mermaid

README.md

@@ -8,12 +8,125 @@
 
 ## Diagramme de classe UML :
 ```mermaid
-graph TD
+classDiagram
-    A[Start] --> B[Push element]
+    Capteur <|.. CapteurImpl
-    B --> C{Heap empty?}
+    AlgoDiffusion <|.. DiffusionAtomique
-    C -- Yes --> D[Insert as root]
+    AlgoDiffusion <|.. DiffusionEpoque
-    C -- No --> E[Bubble up]
+    AlgoDiffusion <|.. DiffusionSequentielle
-    E --> F[Heap property restored]
+    CapteurAsync <|.. Canal
+    ObserverDeCapteurAsync <|.. Canal
+    ObserverDeCapteur <|.. Afficheur
+    Callable <.. UpdateReq
+    Callable <.. GetValueReq
+
+    Canal "1" --> "1" ObserverDeCapteur
+    CapteurImpl "1" o-- "0..*" ObserverDeCapteurAsync
+    CapteurImpl "1" --> "1" AlgoDiffusion
+    Canal "1" --> "1" Capteur
+
+    class Capteur{
+        <<interface>>
+      +attach(o: ObserverDeCapteurAsync):void
+      +tick() :void
+      +getValue():int
+      +getValueDiffusion():int
+    }
+    class CapteurImpl{
+        -value : int
+        -diffusion : AlgoDiffusion
+        #observers : List~ObserverDeCapteurAsync~
+        -lock : boolean
+        -initialTime : long
+      +attach(o: ObserverDeCapteurAsync):void
+      +tick() :void
+      +setAlgoDiffusion( diffusion: AlgoDiffusion) : void 
+      +getValue():int
+      +getValueDiffusion():int
+      +stop() : void
+      +isStop() :void 
+    }
+    class AlgoDiffusion{
+        <<interface>>
+      +execute() : void
+        +getValue() : int
+    }
+    class DiffusionAtomique{
+        +capteur : CapteurImpl
+        -futures : List~Future~?~~
+        -values : Queue~Integer~
+
+        +DiffusionAtomique(c:CapteurImpl)
+        +execute():void
+        +getValue():int
+    }
+    class DiffusionEpoque{
+        +capteur : CapteurImpl
+        -futures : Future~?~[]
+
+        +DiffusionEpoque(c:CapteurImpl)
+        +execute():void
+        +getValue():int
+    }
+    class DiffusionSequentielle{
+        +capteur : CapteurImpl
+        -futures : List~Future~?~~
+        -value : int
+
+        +DiffusionSequentielle(c:CapteurImpl)
+        +execute():void
+        +getValue():int
+    }
+    class CapteurAsync{
+        <<interface>>
+        getValue() : Future~Integer~
+    }
+    class ObserverDeCapteurAsync{
+        <<interface>>
+      update() : Future~?~ 
+    }
+    class Canal{
+        - scheduler : scheduler
+        - afficher : ObserverdeCapteur
+        - capteur : Capteur
+        +Canal(capteur: Capteur, scheduler: Scheduler, afficher: ObserverdeCapteur)
+        +update() : Future~?~
+        +getValue() : Future~Integer~
+    }
+
+    class ObserverDeCapteur{
+        <<interface>>
+      update(capteurAsync : CapteurAsync) : void 
+    }
+    class Afficheur{
+        -id : int
+        +vals : ArrayList~Integer~
+        +setId(id : int): void
+        +update(capteurAsync : CapteurAsync)
+    }
+
+    class Callable~V~{
+        <<interface>>
+      call() : V
+    }
+
+    class GetValueReq{
+        -capteur : Capteur
+        +GetValueReq(capteur : Capteur)
+        +call() : Integer
+    }
+
+    class UpdateReq{
+        -canalProxy : CapteurAsync
+        -afficheur : ObserverdeCapteur
+        +UpdateReq(canalProxy : CapteurAsync, afficheur : ObserverdeCapteur)
+        +call() : Void
+    }
+    class Scheduler{
+        - scheduler : ScheduledExecutorService
+        + Scheduler(nbCanaux : int)
+        + getScheduler(): ScheduledExecutorService
+        + enquete(task : Callable<T>, delay : long) : Future~T~
+    }
 ```
 
 ## Stratégies de diffusions :

src/impl/DiffusionEpoque.java

@@ -10,8 +10,8 @@ public class DiffusionEpoque implements AlgoDiffusion {
     public CapteurImpl capteur;
     private Future<?>[] futures;
 
-    public DiffusionEpoque(CapteurImpl capteur){
+    public DiffusionEpoque(CapteurImpl c){
-        this.capteur = capteur;
+        this.capteur = c;
         this.futures = new Future<?>[capteur.observers.size()];
     }
 

src/impl/DiffusionSequentielle.java

@@ -7,14 +7,14 @@ import java.util.concurrent.Future;
 import interfaces.AlgoDiffusion;
 import interfaces.ObserverDeCapteurAsync;
 
-public class DiffusionSequencielle implements AlgoDiffusion {
+public class DiffusionSequentielle implements AlgoDiffusion {
 
     public CapteurImpl capteur;
     private List<Future<?>> futures;
     private int value;
 
-    public DiffusionSequencielle(CapteurImpl capteur){
+    public DiffusionSequentielle(CapteurImpl c){
-        this.capteur = capteur;
+        this.capteur = c;
         this.futures = new ArrayList<Future<?>>();
     }
 

src/impl/GetValueReq.java

@@ -11,6 +11,7 @@ public class GetValueReq implements Callable<Integer> {
     }
 
     //AO2 - concrete MI
+    @Override
     public Integer call() {
         return capteur.getValueDiffusion();
     }

src/impl/Scheduler.java

@@ -10,7 +10,7 @@ public class Scheduler {
         this.scheduler = Executors.newScheduledThreadPool(nThread);
     }
 
-    public ScheduledExecutorService getScheculer(){
+    public ScheduledExecutorService getScheduler(){
         return this.scheduler;
     }
 

src/main.java

@@ -6,7 +6,7 @@ import impl.Canal;
 import impl.CapteurImpl;
 import impl.DiffusionAtomique;
 import impl.DiffusionEpoque;
-import impl.DiffusionSequencielle;
+import impl.DiffusionSequentielle;
 import impl.Scheduler;
 
 
@@ -19,7 +19,7 @@ public class main {
         CapteurImpl c = new CapteurImpl();
 
         DiffusionAtomique algoAtom = new DiffusionAtomique(c);
-        DiffusionSequencielle algoSeq = new DiffusionSequencielle(c);
+        DiffusionSequentielle algoSeq = new DiffusionSequentielle(c);
         DiffusionEpoque algoEpoq = new DiffusionEpoque(c);
         //algoEpoq.capteur = c;
 
@@ -32,7 +32,7 @@ public class main {
             c.attach(canal);
         }
          
-        ScheduledExecutorService clock =  scheduler.getScheculer();
+        ScheduledExecutorService clock =  scheduler.getScheduler();
         clock.scheduleAtFixedRate(() -> c.tick(), 0, 500, TimeUnit.MILLISECONDS);
     }
 }

src/test/TestAlgoDiffusionAtom.java

@@ -58,7 +58,7 @@ public class TestAlgoDiffusionAtom {
             c.attach(canal);
         }
          
-        ScheduledExecutorService clock =  scheduler.getScheculer();
+        ScheduledExecutorService clock =  scheduler.getScheduler();
         ScheduledFuture<?> future = clock.scheduleAtFixedRate(() -> c.tick(), 0, 500, TimeUnit.MILLISECONDS);
 
         for(int i = TEST_TIME/6; i>0; i--){ //attend que le capteur génère des valeurs

src/test/TestAlgoDiffusionEpoq.java

@@ -58,7 +58,7 @@ public class TestAlgoDiffusionEpoq {
         DiffusionEpoque algo = new DiffusionEpoque(c);
         c.setAlgoDiffusion(algo);
          
-        ScheduledExecutorService clock =  scheduler.getScheculer();
+        ScheduledExecutorService clock =  scheduler.getScheduler();
         ScheduledFuture<?> future = clock.scheduleAtFixedRate(() -> c.tick(), 0, 500, TimeUnit.MILLISECONDS);
 
         Thread.sleep(10000);

src/test/TestAlgoDiffusionSeq.java

@@ -13,7 +13,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 import impl.Afficheur;
 import impl.Canal;
 import impl.CapteurImpl;
-import impl.DiffusionSequencielle;
+import impl.DiffusionSequentielle;
 import impl.Scheduler;
 
 public class TestAlgoDiffusionSeq {
@@ -47,7 +47,7 @@ public class TestAlgoDiffusionSeq {
         Scheduler scheduler = new Scheduler(NB_CANAUX);
         CapteurImpl c = new CapteurImpl();
 
-        DiffusionSequencielle algo = new DiffusionSequencielle(c);
+        DiffusionSequentielle algo = new DiffusionSequentielle(c);
         c.setAlgoDiffusion(algo);
 
         for(int i = 0; i<NB_CANAUX; i++){
@@ -58,7 +58,7 @@ public class TestAlgoDiffusionSeq {
             c.attach(canal);
         }
          
-        ScheduledExecutorService clock =  scheduler.getScheculer();
+        ScheduledExecutorService clock =  scheduler.getScheduler();
         ScheduledFuture<?> future = clock.scheduleAtFixedRate(() -> c.tick(), 0, 500, TimeUnit.MILLISECONDS);
 
         Thread.sleep(10000);