update mermaid

README.md

@@ -8,12 +8,125 @@
 
 ## Diagramme de classe UML :
 ```mermaid
-graph TD
-    A[Start] --> B[Push element]
-    B --> C{Heap empty?}
-    C -- Yes --> D[Insert as root]
-    C -- No --> E[Bubble up]
-    E --> F[Heap property restored]
+classDiagram
+    Capteur <|.. CapteurImpl
+    AlgoDiffusion <|.. DiffusionAtomique
+    AlgoDiffusion <|.. DiffusionEpoque
+    AlgoDiffusion <|.. DiffusionSequentielle
+    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 :