From 3ad1ffe03c3f7f862197a544653e030c8489fe90 Mon Sep 17 00:00:00 2001 From: tuanvu Date: Sun, 21 Dec 2025 13:59:07 +0100 Subject: [PATCH] update mermaid --- README.md | 125 +++++++++++++++++- src/impl/DiffusionEpoque.java | 4 +- ...cielle.java => DiffusionSequentielle.java} | 6 +- src/impl/GetValueReq.java | 1 + src/impl/Scheduler.java | 2 +- src/main.java | 6 +- src/test/TestAlgoDiffusionAtom.java | 2 +- src/test/TestAlgoDiffusionEpoq.java | 2 +- src/test/TestAlgoDiffusionSeq.java | 6 +- 9 files changed, 134 insertions(+), 20 deletions(-) rename src/impl/{DiffusionSequencielle.java => DiffusionSequentielle.java} (85%) diff --git a/README.md b/README.md index 22de012..210a595 100644 --- a/README.md +++ b/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{ + <> + +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{ + <> + +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{ + <> + getValue() : Future~Integer~ + } + class ObserverDeCapteurAsync{ + <> + update() : Future~?~ + } + class Canal{ + - scheduler : scheduler + - afficher : ObserverdeCapteur + - capteur : Capteur + +Canal(capteur: Capteur, scheduler: Scheduler, afficher: ObserverdeCapteur) + +update() : Future~?~ + +getValue() : Future~Integer~ + } + + class ObserverDeCapteur{ + <> + update(capteurAsync : CapteurAsync) : void + } + class Afficheur{ + -id : int + +vals : ArrayList~Integer~ + +setId(id : int): void + +update(capteurAsync : CapteurAsync) + } + + class Callable~V~{ + <> + 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, delay : long) : Future~T~ + } ``` ## Stratégies de diffusions : diff --git a/src/impl/DiffusionEpoque.java b/src/impl/DiffusionEpoque.java index e2c8ed2..5e746c1 100644 --- a/src/impl/DiffusionEpoque.java +++ b/src/impl/DiffusionEpoque.java @@ -10,8 +10,8 @@ public class DiffusionEpoque implements AlgoDiffusion { public CapteurImpl capteur; private Future[] futures; - public DiffusionEpoque(CapteurImpl capteur){ - this.capteur = capteur; + public DiffusionEpoque(CapteurImpl c){ + this.capteur = c; this.futures = new Future[capteur.observers.size()]; } diff --git a/src/impl/DiffusionSequencielle.java b/src/impl/DiffusionSequentielle.java similarity index 85% rename from src/impl/DiffusionSequencielle.java rename to src/impl/DiffusionSequentielle.java index 4e20f56..7f1ea75 100644 --- a/src/impl/DiffusionSequencielle.java +++ b/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> futures; private int value; - public DiffusionSequencielle(CapteurImpl capteur){ - this.capteur = capteur; + public DiffusionSequentielle(CapteurImpl c){ + this.capteur = c; this.futures = new ArrayList>(); } diff --git a/src/impl/GetValueReq.java b/src/impl/GetValueReq.java index 2eee629..8fde5eb 100644 --- a/src/impl/GetValueReq.java +++ b/src/impl/GetValueReq.java @@ -11,6 +11,7 @@ public class GetValueReq implements Callable { } //AO2 - concrete MI + @Override public Integer call() { return capteur.getValueDiffusion(); } diff --git a/src/impl/Scheduler.java b/src/impl/Scheduler.java index a9b6ef0..009c85f 100644 --- a/src/impl/Scheduler.java +++ b/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; } diff --git a/src/main.java b/src/main.java index 2002d01..274878e 100644 --- a/src/main.java +++ b/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); } } diff --git a/src/test/TestAlgoDiffusionAtom.java b/src/test/TestAlgoDiffusionAtom.java index 8d3ad83..aad2374 100644 --- a/src/test/TestAlgoDiffusionAtom.java +++ b/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 diff --git a/src/test/TestAlgoDiffusionEpoq.java b/src/test/TestAlgoDiffusionEpoq.java index edbef91..903400b 100644 --- a/src/test/TestAlgoDiffusionEpoq.java +++ b/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); diff --git a/src/test/TestAlgoDiffusionSeq.java b/src/test/TestAlgoDiffusionSeq.java index 06cc8f9..f3218e7 100644 --- a/src/test/TestAlgoDiffusionSeq.java +++ b/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 future = clock.scheduleAtFixedRate(() -> c.tick(), 0, 500, TimeUnit.MILLISECONDS); Thread.sleep(10000);