diff --git a/pom.xml b/pom.xml
index 510dba5feb165de23e1fdb5ebace40ea408731fe..175265c83c59871234b210e59c77eb5a9c6f6fb4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
@@ -14,4 +13,13 @@
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
-</project>
\ No newline at end of file
+ <dependencies>
+ <dependency>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter-engine</artifactId>
+ <version>5.8.2</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+</project>
+
diff --git a/src/main/java/org/petriNet/Arc.java b/src/main/java/org/petriNet/Arc.java
index c9d30fabf32e88fb7b8a77d83719fdaf8b527992..0f04b62b6d812b95dba7600400e04f45c07dae9b 100644
--- a/src/main/java/org/petriNet/Arc.java
+++ b/src/main/java/org/petriNet/Arc.java
@@ -1,36 +1,49 @@
package org.petriNet;
public abstract class Arc {
+
private int id;
private Place place;
private Transition transition;
private int poids;
- public Arc(Place place, Transition transition, int poids, int id) {
+ public Arc(Transition transition, Place place, int poids, int id) {
this.place = place;
this.transition = transition;
- this.poids = poids;
- this.id = id;
+ // verify that the weight is not negative
+ if (poids >= 0) {
+ this.poids = poids;
+ } else {
+ System.out.println("The weight cannot be negative.");
+ }
+ this.id = id; // Assign a unique ID with the generateId method in the ReseauPetri class
}
-
- public abstract void modifierPoids(int poids);
-
public abstract void valider();
- public abstract int getPoids() ;
+ public int getPoids(){
+ return this.poids;
+ } ;
- public abstract int getId();
+ public int getId(){
+ return this.id;
+ };
- public abstract void setId(int id);
-
- public abstract void setPoid(int poids);
+ public void setPoids(int poids){
+ this.poids = poids;
+ };
- public abstract Place getPlace();
+ public Place getPlace(){
+ return this.place;
+ };
- public abstract void setPlace(Place place);
+ public void setPlace(Place place){
+ this.place = place;
+ };
- public abstract Transition getTransition();
+ public Transition getTransition(){
+ return this.transition;
+ };
}
diff --git a/src/main/java/org/petriNet/Arc_ENTRANT.java b/src/main/java/org/petriNet/Arc_ENTRANT.java
index cf43fc20b666957d726d10946d6e5fc55253a9b3..5ef376c2c35384cd767d00707c9dac6b0fab1b0a 100644
--- a/src/main/java/org/petriNet/Arc_ENTRANT.java
+++ b/src/main/java/org/petriNet/Arc_ENTRANT.java
@@ -14,13 +14,8 @@ public abstract class Arc_ENTRANT extends Arc {
private int poids;
private int id;
- public Arc_ENTRANT(Place place, Transition transition, int poids, int id) {
- super(place, transition, poids, id);
- }
-
- @Override
- public void modifierPoids(int poids) {
- this.poids = poids;
+ public Arc_ENTRANT( Transition transition, Place place, int poids, int id) {
+ super(transition, place, poids, id);
}
/**
@@ -29,61 +24,14 @@ public abstract class Arc_ENTRANT extends Arc {
* ceci pour justifier le cahngement par rapport au diagramme de classe soumis
*/
- public void enleverJetons() {
- // On retire le nombre de jetons du poids de l'arc
- this.place.enlever_jeton(this.poids);
- }
-
public boolean verifier_tirable() {
- if (this.place.get_nombre_jetons() >= this.poids) {
- return true;
- }
- return false;
+ return this.getPlace().get_nombre_jetons() >= this.getPoids();
}
-
@Override
public void valider() {
// On retire le nombre de jetons du poids de l'arc
- // prendre en cond la place choisie
- this.place.enlever_jeton(this.poids);
- }
-
-
-
- @Override
- public int getPoids() {
- return this.poids;
- }
-
- @Override
- public int getId() {
- return this.id;
- }
-
- @Override
- public void setId(int id) {
- this.id = id;
- }
-
- @Override
- public void setPoid(int poids) {
- this.poids = poids;
- }
-
- @Override
- public Place getPlace() {
- return this.place;
- }
-
- @Override
- public void setPlace(Place place) {
- this.place = place;
- }
-
- @Override
- public Transition getTransition() {
- return this.transition;
+ this.getPlace().enlever_jeton(this.getPoids());
}
}
\ No newline at end of file
diff --git a/src/main/java/org/petriNet/Arc_SORTANT.java b/src/main/java/org/petriNet/Arc_SORTANT.java
index bd0efc7deb5eb1bb424aa5d3f8a7e30e4bd034f9..ff4cf5406880b6af384018fba15a880483e86638 100644
--- a/src/main/java/org/petriNet/Arc_SORTANT.java
+++ b/src/main/java/org/petriNet/Arc_SORTANT.java
@@ -7,16 +7,10 @@ public class Arc_SORTANT extends Arc {
private int poids;
private int id;
- public Arc_SORTANT(Place place, Transition transition, int poids, int id) {
- super(place, transition, poids, id);
+ public Arc_SORTANT( Transition transition, Place place, int poids, int id) {
+ super(transition, place, poids, id);
}
- @Override
- public void modifierPoids(int poids) {
- this.poids = poids;
- }
-
-
@Override
public void valider() {
@@ -24,52 +18,4 @@ public class Arc_SORTANT extends Arc {
this.place.ajouter_jeton(this.poids);
}
- @Override
- public int getPoids() {
- return this.poids;
- }
-
- @Override
- public int getId() {
- return this.id;
- }
-
- @Override
- public void setId(int id) {
- this.id = id;
- }
-
- @Override
- public void setPoid(int poids) {
- this.poids = poids;
- }
-
- @Override
- public Place getPlace() {
- return this.place;
- }
-
- @Override
- public void setPlace(Place place) {
- this.place = place;
- }
-
- @Override
- public Transition getTransition() {
- return this.transition;
- }
-
- /**
- * Dans la classe Arc_SORTANT, on ajoute les jetons à la place seulement,
- * il n'y a pas de jetons à enlever
- * ceci pour justifier le cahngement par rapport au diagramme de classe soumis
- */
-
-
- public void ajouterJetons() {
- // On ajoute le nombre de jetons du poids de l'arc
- this.place.ajouter_jeton(this.poids);
- }
-
-
}
\ No newline at end of file
diff --git a/src/main/java/org/petriNet/Arc_entrant_simple.java b/src/main/java/org/petriNet/Arc_entrant_simple.java
index b24636a32627073bc7edb52d78f21e616a9f6154..370be3f210b1f5897bf604a8427350b9d91db43d 100644
--- a/src/main/java/org/petriNet/Arc_entrant_simple.java
+++ b/src/main/java/org/petriNet/Arc_entrant_simple.java
@@ -8,8 +8,8 @@ public class Arc_entrant_simple extends Arc_ENTRANT {
int id;
- public Arc_entrant_simple(Place place, Transition transition, int poids, int id) {
- super(place, transition, poids, id);
+ public Arc_entrant_simple( Transition transition, Place place, int poids, int id) {
+ super(transition, place, poids, id);
}
}
diff --git a/src/main/java/org/petriNet/Arc_videur.java b/src/main/java/org/petriNet/Arc_videur.java
index 35549acf1b2fede99d392038a319c266c5e27476..e0193bfc092605d9d7fdd507a2fe890a7dd06fd4 100644
--- a/src/main/java/org/petriNet/Arc_videur.java
+++ b/src/main/java/org/petriNet/Arc_videur.java
@@ -7,8 +7,8 @@ public class Arc_videur extends Arc_ENTRANT {
int poids;
int id;
- public Arc_videur(Place place, Transition transition, int poids, int id) {
- super(place, transition, poids, id);
+ public Arc_videur( Transition transition, Place place, int poids, int id) {
+ super(transition, place, poids, id);
}
// Les arcs «videurs» qui sont actifs dès qu’il y a un jeton dans la place source et qui enlèvent
@@ -30,5 +30,4 @@ public class Arc_videur extends Arc_ENTRANT {
}
-
}
diff --git a/src/main/java/org/petriNet/Arc_zero.java b/src/main/java/org/petriNet/Arc_zero.java
index 3e46166ac4c8f27d83c97262d24bdfb9e217c1db..0bc6433573e9a921d26367ed841ff88967563581 100644
--- a/src/main/java/org/petriNet/Arc_zero.java
+++ b/src/main/java/org/petriNet/Arc_zero.java
@@ -5,21 +5,18 @@ package org.petriNet;
Place place;
Transition transition;
int poids;
- int id;
boolean etat;
+ int id;
- public Arc_zero(Place place, Transition transition, int poids, int id) {
- super(place, transition, poids, id);
+ public Arc_zero( Transition transition, Place place, int poids, int id) {
+ super(transition, place, poids, id);
}
- // Les arcs « zéro » qui ne sont actifs que quand la place source est vide.
+ // Les arcs « zéro » qui ne sont actifs que quand la place source est vide.
@Override
public boolean verifier_tirable() {
- if (this.place.get_nombre_jetons() == 0) {
- return true;
- }
- return false;
+ return this.place.get_nombre_jetons() == 0;
}
}
diff --git a/src/main/java/org/petriNet/MainPetriNet.java b/src/main/java/org/petriNet/MainPetriNet.java
index d5078a636a4f7849febfa0f57ba62712f406e9b7..657fdda4d8b3423b5482588ebbeee075f5cd8a48 100644
--- a/src/main/java/org/petriNet/MainPetriNet.java
+++ b/src/main/java/org/petriNet/MainPetriNet.java
@@ -1,27 +1,25 @@
package org.petriNet;
-import java.util.ArrayList;
-
public class MainPetriNet {
public static void main(String[] args) {
// Create a Petri net
- ReseauPerti reseauPerti = new ReseauPerti();
+ ReseauPetri reseauPetri = new ReseauPetri();
// Create places
- Place p1 = new Place(1,3);
- Place p2 = new Place(2,3);
- Place p3 = new Place(3,3);
+ Place p1 = new Place(1, reseauPetri.generateId(1));
+ Place p2 = new Place(2, reseauPetri.generateId(2));
+ Place p3 = new Place(3, reseauPetri.generateId(3));
// Create transitions with empty Arcs_ENTRANT and Arcs_SORTANT
- Transition t1 = new Transition(1, new ArrayList<Arc_SORTANT>(), new ArrayList<Arc_ENTRANT>());
- Transition t2 = new Transition(2, new ArrayList<Arc_SORTANT>(), new ArrayList<Arc_ENTRANT>());
+ Transition t1 = new Transition("t1", reseauPetri.generateId(2));
+ Transition t2 = new Transition("t2", reseauPetri.generateId(2));
// Create arcs
- Arc_ENTRANT a1 = new Arc_entrant_simple(p1, t1, 1, 1);
- Arc_SORTANT a2 = new Arc_SORTANT(p2, t1, 1, 2);
- Arc_ENTRANT a3 = new Arc_entrant_simple(p2, t2, 1, 3);
- Arc_SORTANT a4 = new Arc_SORTANT(p3, t2, 1, 4);
+ Arc_ENTRANT a1 = new Arc_entrant_simple(t1, p1, 1, reseauPetri.generateId(0));
+ Arc_SORTANT a2 = new Arc_SORTANT(t1, p2, 1, reseauPetri.generateId(0));
+ Arc_ENTRANT a3 = new Arc_entrant_simple(t2, p2, 1, reseauPetri.generateId(0));
+ Arc_SORTANT a4 = new Arc_SORTANT(t2, p3, 1, reseauPetri.generateId(0));
// Add arcs to transitions
t1.ajouterArc_ENTRANT(a1);
@@ -36,22 +34,13 @@ public class MainPetriNet {
a4.setPlace(p3);
// Add places and transitions to the Petri net
- reseauPerti.ajouterPlace(p1);
- reseauPerti.ajouterPlace(p2);
- reseauPerti.ajouterPlace(p3);
- reseauPerti.ajouterTransition(t1);
- reseauPerti.ajouterTransition(t2);
+ reseauPetri.ajouterPlace(p1);
+ reseauPetri.ajouterPlace(p2);
+ reseauPetri.ajouterPlace(p3);
+ reseauPetri.ajouterTransition(t1);
+ reseauPetri.ajouterTransition(t2);
// Display the Petri net
- reseauPerti.afficherEtat();
-
- // Test the tirer method
-// if (t1.est_tirable()) {
-// reseauPerti.tirerTransition(t1);
-// }
-// if (t2.est_tirable()) {
-// reseauPerti.tirerTransition(t2);
-// }
-
+ reseauPetri.afficherEtat();
}
}
\ No newline at end of file
diff --git a/src/main/java/org/petriNet/Place.java b/src/main/java/org/petriNet/Place.java
index 0dd674b0021bbe992c0036f09216654b0d8e0376..af7b421c4f166247ae316f7da6954418e0bbdee6 100644
--- a/src/main/java/org/petriNet/Place.java
+++ b/src/main/java/org/petriNet/Place.java
@@ -1,23 +1,35 @@
package org.petriNet;
public class Place {
+
private int id;
private int nombre_jeton;
- public Place(int id, int nombre_jeton) {
+ public Place(int nombre_jeton, int id) {
this.id = id;
- this.nombre_jeton = nombre_jeton;
+ // VERIFY THAT THE NUMBER OF TOKENS IS NOT NEGATIVE
+ if (nombre_jeton >= 0) {
+ this.nombre_jeton = nombre_jeton;
+ } else {
+ System.out.println("The number of tokens cannot be negative.");
+ }
}
public void ajouter_jeton(int jetons) {
- this.nombre_jeton += jetons;
+ // verify that the number of tokens is not negative
+ if (jetons >= 0) {
+ this.nombre_jeton += jetons;
+ } else {
+ System.out.println("The number of tokens cannot be negative.");
+ }
}
public void enlever_jeton(int jetons) {
- if (this.nombre_jeton > 0) {
+ // verify that the number of tokens is not negative
+ if (jetons >= 0) {
this.nombre_jeton -= jetons;
} else {
- System.out.println("No more tokens to remove.");
+ System.out.println("The number of tokens cannot be negative.");
}
}
@@ -36,4 +48,7 @@ public class Place {
public void setNombre_jeton(int nombre_jeton) {
this.nombre_jeton = nombre_jeton;
}
+
+ // Une fonction pour trouver les arcs entrants d'une place
+
}
diff --git a/src/main/java/org/petriNet/ReseauPerti.java b/src/main/java/org/petriNet/ReseauPerti.java
deleted file mode 100644
index 60e498b02e0ea2f68ffd5d07397d63a7ef83e22a..0000000000000000000000000000000000000000
--- a/src/main/java/org/petriNet/ReseauPerti.java
+++ /dev/null
@@ -1,154 +0,0 @@
-package org.petriNet;
-
-import java.util.*;
-
-public class ReseauPerti implements PetriNetService {
-
- // Creat attributes as Lists of Places, Transitions and Arcs
-
- private List<Place> places;
- private List<Transition> transitions;
- // create a LinkedHashSet to store the arcs in order to have unique ids
- private LinkedHashSet<Arc> arcs;
- private String etat_reseau = "Pas de transition tirée";
-
- // Create a constructor
- public ReseauPerti() {
- // initialiser les listes vide
- this.places = new ArrayList<>();
- this.transitions = new ArrayList<>();
- this.arcs = new LinkedHashSet<>();
- }
-
- // Create getters and setters
- public List<Place> getPlaces() {
- return places;
- }
-
- public void setPlaces(List<Place> places) {
- this.places = places;
- }
-
- public List<Transition> getTransitions() {
- return transitions;
- }
-
- public void setTransitions(List<Transition> transitions) {
- this.transitions = transitions;
- }
-
- public LinkedHashSet<Arc> getArcs() {
- return this.arcs;
- }
-
- public void setArcs(LinkedHashSet arcs) {
- this.arcs = arcs;
- }
-
-
- @Override
- public void ajouterPlace(Place place) {
- // TODO Auto-generated method stub
- this.places.add(place);
- }
-
- @Override
- public void ajouterTransition(Transition transition) {
- // TODO Auto-generated method stub
- this.transitions.add(transition);
- }
-
- @Override
- public void ajouterArc(Arc arc) {
- // TODO Auto-generated method stub
- this.arcs.add(arc);
- }
-
- @Override
- public void tirer_transition(String id) {
-
- // set the state of the network to "Transition en cours de verification"
- this.etat_reseau = "Transition en cours de validation";
-
- // Find the transition with the id
- Transition transition_choisie = null;
- for (Transition transition : this.transitions) {
- if (transition.getId() == Integer.parseInt(id)) {
- transition_choisie = transition;
- }
- }
-
-
- // Check if the transition id is valid
- if (transition_choisie == null) {
- System.out.println("L'id de la transition n'est pas valide");
- return;
- } else {
- // Check if the transition is tirable
- transition_choisie.est_tirable();
- }
-
- // Ask if the user wants to validate the firing of the transition
- Scanner scanner = new Scanner(System.in);
- System.out.println("Voulez-vous valider le tirage de la transition? (O/N)");
- String reponse = scanner.nextLine();
- if (reponse.equals("O")) {
- transition_choisie.tirer();
- }
-
- // set the state of the network to "Pas de transition tirée"
- this.etat_reseau = "Pas de transition tirée";
-
- }
-
- @Override
- public void afficherEtat() {
- // TODO Auto-generated method stub
- if (this.etat_reseau.equals("Pas de transition tirée")) {
- System.out.println("Pas de transition tirée");
- // Ask the user if they want to fire a transition
- Scanner scanner = new Scanner(System.in);
- System.out.println("Voulez-vous tirer une transition? (O/N)");
- String reponse = scanner.nextLine();
- if (reponse.equals("O")) {
- // Show the Petri Net
- afficherReseau();
- // Ask the user for the id of the transition to fire
- System.out.println("Saisir l'id de la transition à tirer: ");
- String id = scanner.nextLine();
- tirer_transition(id);
- }
- } else {
- System.out.println("Transition en cours de validation");
- }
- }
-
-
- @Override
- public void afficherReseau() {
- // TODO Auto-generated method stub
-
- System.out.println(this.etat_reseau);
-
- /**
- * afficher les places, les transitions et les arcs
- * comme un dessin du réseau de petri
- * les places comme des cercles
- * les transitions comme des rectangles
- * les arcs comme des flèches
- * les poinds des arcs à côté des flèches
- * les jetons des points dans les places
- * relier les arcs aux places et aux transitions par des flèches
- */
-
-// // afficher Petri Net
-// System.out.println("Petri Net : ");
-// // afficher les places, les arcs, le poids et les transitions
-// for (Arc arc : arcs) {
-// System.out.println("Arc : " + arc.getPlace().getId() + " -> " + arc.getTransition().getId() + " : " + arc.getPoids());
-// }
-
-
- }
-
-}
diff --git a/src/main/java/org/petriNet/ReseauPetri.java b/src/main/java/org/petriNet/ReseauPetri.java
new file mode 100644
index 0000000000000000000000000000000000000000..743d1794abc0a2edf9909210d6d26b5e1e31d419
--- /dev/null
+++ b/src/main/java/org/petriNet/ReseauPetri.java
@@ -0,0 +1,219 @@
+package org.petriNet;
+
+import java.util.*;
+
+public class ReseauPetri implements PetriNetService {
+
+ // Creat attributes as Lists of Places, Transitions and Arcs
+
+ private LinkedList<Integer> Id_couters;
+ private List<Place> places;
+ private List<Transition> transitions;
+ // create a LinkedHashSet to store the arcs in order to have unique ids
+ private LinkedList<Arc> arcs;
+ private String etat_reseau = "Pas de transition tirée";
+
+ // Create a constructor
+ public ReseauPetri() {
+ // initialiser les listes vide
+ this.places = new ArrayList<>();
+ this.transitions = new ArrayList<>();
+ this.arcs = new LinkedList<>();
+ Id_couters = new LinkedList<>();
+
+ // initialiser les compteurs des ids pour Arcs, Places et Transitions
+ Id_couters.add(0);
+ Id_couters.add(0);
+ Id_couters.add(0);
+ }
+
+ // Create a method to generate unique ids
+ public int generateId(int index) {
+ int id = Id_couters.get(index);
+ Id_couters.set(index, id + 1);
+ return id;
+ }
+
+ // Create getters and setters
+ public List<Place> getPlaces() {
+ return places;
+ }
+
+ public void setPlaces(List<Place> places) {
+ this.places = places;
+ }
+
+ public List<Transition> getTransitions() {
+ return transitions;
+ }
+
+ public void setTransitions(List<Transition> transitions) {
+ this.transitions = transitions;
+ }
+
+ public LinkedList<Arc> getArcs() {
+ return this.arcs;
+ }
+
+ public void setArcs(LinkedList arcs) {
+ this.arcs = arcs;
+ }
+
+
+ @Override
+ public void ajouterPlace(Place place) {
+ // TODO Auto-generated method stub
+ // verify that there is no similar place in the list
+ for (Place place1 : this.places) {
+ if (place1.getId() == place.getId()) {
+ System.out.println("Place already exists");
+ return;
+ }
+ }
+ this.places.add(place);
+ }
+
+ @Override
+ public void ajouterTransition(Transition transition) {
+ // TODO Auto-generated method stub
+ // verify that there is no similar transition in the list
+ for (Transition transition1 : this.transitions) {
+ if (transition1.getId() == transition.getId()) {
+ System.out.println("Transition already exists");
+ return;
+ }
+ }
+ this.transitions.add(transition);
+ }
+
+ @Override
+ public void ajouterArc(Arc arc) {
+ // TODO Auto-generated method stub
+ // verify that there is no similar arc in the list
+ for (Arc arc1 : this.arcs) {
+ if (arc1.getPlace().getId() == arc.getPlace().getId() &&
+ arc1.getTransition().getId() == arc.getTransition().getId() &&
+ arc1.getClass() == arc.getClass()) {
+
+ System.out.println("Arc already exists");
+ return;
+ }
+ }
+ this.arcs.add(arc);
+ }
+
+ @Override
+ public void tirer_transition(String id) {
+
+ // set the state of the network to "Transition en cours de verification"
+ this.etat_reseau = "Transition en cours de validation";
+
+ // Find the transition with the id
+ Transition transition_choisie = null;
+ for (Transition transition : this.transitions) {
+ if (String.valueOf(transition.getId()).equals(id)) {
+ transition_choisie = transition;
+ }
+ }
+
+ // Check if the transition id is valid
+ if (transition_choisie == null) {
+ System.out.println("L'id de la transition n'est pas valide");
+ return;
+ } else {
+ transition_choisie.tirer();
+ }
+
+ // set the state of the network to "Pas de transition tirée"
+ this.etat_reseau = "Pas de transition tirée";
+
+ }
+
+ @Override
+ public void afficherEtat() {
+ // TODO Auto-generated method stub
+ if (this.etat_reseau.equals("Pas de transition tirée")) {
+ System.out.println("Pas de transition tirée");
+ // Ask the user if they want to fire a transition
+ Scanner scanner = new Scanner(System.in);
+ System.out.println("Voulez-vous tirer une transition? (O/N)");
+ String reponse = scanner.nextLine();
+ if (reponse.equals("O")) {
+ // Show the Petri Net
+ afficherReseau();
+ // Ask the user for the id of the transition to fire
+ System.out.println("Saisir l'id de la transition à tirer: ");
+ String id = scanner.nextLine();
+ tirer_transition(id);
+ }
+ } else {
+ System.out.println("Transition en cours de validation");
+ }
+ }
+
+
+ @Override
+ public void afficherReseau() {
+ // TODO Auto-generated method stub
+
+ /**
+ * L'affichage est sous la forme suivante:
+ * Réseau de Petri
+ * 2 places
+ * 1 transition
+ * 2 arcs
+ * Liste des places :
+ * 1 : place avec 4 jetons, 1 arc simple sortant, 0 arc simple entrant
+ * 2 : place avec 0 jetons, 0 arc simple sortant, 1 arc simple entrant
+ * Liste des transitions
+ * 1 : transition, 1 arc entrant, 1 arc sortant
+ * Liste des arcs :
+ * 1 : arc simple poids 1 (place avec 4 jetons vers transition)
+ * 2 : arc simple poids 1 (transition vers place avec 0 jetons)
+ */
+
+ System.out.println("Réseau de Petri");
+ System.out.println(this.places.size() + " places");
+ System.out.println(this.transitions.size() + " transitions");
+ System.out.println(this.arcs.size() + " arcs");
+
+ System.out.println("Liste des places :");
+ // On parcourt la liste des arcs pour afficher les places
+ // une liste pur les arcs entrants et une liste pour les arcs sortants
+ List<Arc> arcs_ENTRANTS = new ArrayList<>();
+ List<Arc> arcs_SORTANTS = new ArrayList<>();
+ for (Place place : this.places) {
+ for (Arc arc : this.arcs) {
+ // we verify getting arc.getPlace() == place
+ if (arc.getPlace().getId() == place.getId()) {
+ // we verify if it's an arc entrant
+ if (arc instanceof Arc_ENTRANT) {
+ arcs_ENTRANTS.add(arc);
+ } else {
+ arcs_SORTANTS.add(arc);
+ }
+ }
+ }
+ System.out.println(place.getId() + " : place avec " + place.get_nombre_jetons() + " jetons, "
+ + arcs_SORTANTS.size() + " arc simple sortant, " + arcs_ENTRANTS.size() + " arc simple entrant");
+ }
+
+ System.out.println("Liste des transitions :");
+ for (Transition transition : this.transitions) {
+ System.out.println(transition.getId() + " : transition " + transition.getNom() + " " + transition.getArcs_ENTRANTS().size()
+ + " arc entrant, " + transition.getArcs_SORTANTS().size() + " arc sortant");
+ }
+
+ System.out.println("Liste des arcs :");
+ for (Arc arc : this.arcs) {
+ if (arc instanceof Arc_ENTRANT) {
+ System.out.println(arc.getId() + " : arc simple poids " + arc.getPoids() + " ("
+ + "Place d'Id " + arc.getPlace().getId() + " vers " + arc.getTransition().getNom() + ")");
+ } else {
+ System.out.println(arc.getId() + " : arc simple poids " + arc.getPoids() + " ("
+ + arc.getTransition().getNom() + " vers " + "Place d'Id " + arc.getPlace().getId() + ")");
+ }
+ }
+ }
+
+}
diff --git a/src/main/java/org/petriNet/Transition.java b/src/main/java/org/petriNet/Transition.java
index e6f9a7323050f12a8411f9f722feb1d391720041..474dc5edf97a0537b75f79451a2d8b5ace0e0f70 100644
--- a/src/main/java/org/petriNet/Transition.java
+++ b/src/main/java/org/petriNet/Transition.java
@@ -2,16 +2,17 @@ package org.petriNet;
import java.util.ArrayList;
import java.util.List;
-import java.util.Scanner;
public class Transition {
+
private int id;
+ String nom;
private List<Arc_SORTANT> arcs_SORTANTS;
private List<Arc_ENTRANT> arcs_ENTRANTS;
- private List<Arc_ENTRANT> arcs_ENTRANTS_TIRABLE = new ArrayList<Arc_ENTRANT>();
- public Transition(int id, List<Arc_SORTANT> arcs_SORTANTS, List<Arc_ENTRANT> arcs_ENTRANTS) {
+ public Transition(String nom, int id) {
this.id = id;
+ this.nom = nom;
this.arcs_SORTANTS = new ArrayList<Arc_SORTANT>();
this.arcs_ENTRANTS = new ArrayList<Arc_ENTRANT>();
}
@@ -22,6 +23,10 @@ public class Transition {
* c'est une différence par rapport au diagramme de classe soumis
*/
+ public String getNom() {
+ return nom;
+ }
+
public int getId() {
return id;
}
@@ -34,87 +39,68 @@ public class Transition {
return arcs_SORTANTS;
}
+ public List<Arc_ENTRANT> getArcs_ENTRANTS() {
+ return arcs_ENTRANTS;
+ }
+
public void setArcs_SORTANTS(List<Arc_SORTANT> arcs_SORTANTS) {
this.arcs_SORTANTS = arcs_SORTANTS;
}
public void ajouterArc_SORTANT(Arc_SORTANT arc_SORTANT) {
+ // verify that the arc doesn't already exist
+ for (Arc_SORTANT arc_SORTANT1 : arcs_SORTANTS) {
+ if (arc_SORTANT1.getPlace().getId() == arc_SORTANT.getPlace().getId() &&
+ arc_SORTANT1.getTransition().getId() == arc_SORTANT.getTransition().getId() &&
+ arc_SORTANT1.getClass() == arc_SORTANT.getClass()) {
+ System.out.println("The arc already exists.");
+ return;
+ }
+ }
this.arcs_SORTANTS.add(arc_SORTANT);
}
public void ajouterArc_ENTRANT(Arc_ENTRANT arc_ENTRANT) {
+ // verify that the arc doesn't already exist
+ for (Arc_ENTRANT arc_ENTRANT1 : arcs_ENTRANTS) {
+ if (arc_ENTRANT1.getPlace().getId() == arc_ENTRANT.getPlace().getId() &&
+ arc_ENTRANT1.getTransition().getId() == arc_ENTRANT.getTransition().getId() &&
+ arc_ENTRANT1.getClass() == arc_ENTRANT.getClass()) {
+ System.out.println("The arc already exists.");
+ return;
+ }
+ }
this.arcs_ENTRANTS.add(arc_ENTRANT);
}
- public void est_tirable() {
-
- // creer liste vide d'arcs
- this.arcs_ENTRANTS_TIRABLE = new ArrayList<Arc_ENTRANT>();
+ public boolean est_tirable() {
- for (Arc_ENTRANT arc_ENTRANT : arcs_ENTRANTS) {
- if (arc_ENTRANT.verifier_tirable()) {
- arcs_ENTRANTS_TIRABLE.add(arc_ENTRANT);
+ for (Arc_ENTRANT arc_ENTRANT : this.arcs_ENTRANTS) {
+ if (!arc_ENTRANT.verifier_tirable()) {
+ System.out.println("La transition n'est pas tirable");
+ return false;
}
}
+ System.out.println("La transition est tirable");
+ return true;
- if(arcs_ENTRANTS_TIRABLE.isEmpty()){
- System.out.println("La transition n'est pas tirable");
- }
- else {
- System.out.println("La transition est tirable");
- }
}
public void tirer(){
- est_tirable();
-
- List<String> arcs_ENTRANTS_TIRABLE_String = Arcs_ENTRANTS_TIRABLE_toString();
-
- // print the list of arcs entrants tirables
- System.out.println("Arcs entrants tirable: " + arcs_ENTRANTS_TIRABLE_String
- + "Saisir l'arc entrant à tirer: ");
- Scanner scanner = new Scanner(System.in);
-
-
- int id;
- Arc_ENTRANT arc_ENTRANT_toTirer;
-
- // Get the input from user of the id of the arc entrant to tirer (java.util.Scanner)
- while (true) {
- System.out.print("Enter the id: ");
- String input = scanner.next();
- try {
- id = Integer.parseInt(input);
- if (arcs_ENTRANTS_TIRABLE_String.contains(String.valueOf(id))) {
- arc_ENTRANT_toTirer = arcs_ENTRANTS_TIRABLE.get(arcs_ENTRANTS_TIRABLE_String.indexOf(String.valueOf(id)));
- break;
- } else {
- System.out.println("Invalid id. Please enter a valid id.");
- }
- } catch (NumberFormatException e) {
- System.out.println("Invalid id. Please enter a valid integer.");
- }
- }
+ boolean tirable = est_tirable();
- // valider l'arc entrant
- arc_ENTRANT_toTirer.valider();
+ if (tirable) {
+ for (Arc_ENTRANT arc_ENTRANT : arcs_ENTRANTS) {
+ arc_ENTRANT.valider();
+ }
- for (Arc_SORTANT arc_SORTANT : arcs_SORTANTS) {
- arc_SORTANT.valider();
+ for (Arc_SORTANT arc_SORTANT : arcs_SORTANTS) {
+ arc_SORTANT.valider();
+ }
+ System.out.println("Transition tirée avec succès");
}
- System.out.println("Transition tirée avec succès");
-
- }
-
- // Add a method to get the list of arcs entrants tirable en String
- public List<String> Arcs_ENTRANTS_TIRABLE_toString() {
- List<String> arcs_ENTRANTS_TIRABLE_String = new ArrayList<String>();
- for (Arc_ENTRANT arc_ENTRANT : arcs_ENTRANTS_TIRABLE) {
- arcs_ENTRANTS_TIRABLE_String.add(String.valueOf(arc_ENTRANT.getId()));
- }
- return arcs_ENTRANTS_TIRABLE_String;
}
}
diff --git a/src/test/java/org/petriNet/ReseauPetriTest.java b/src/test/java/org/petriNet/ReseauPetriTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..389443aa42bc1da020987d261eabd80a91a9b7c2
--- /dev/null
+++ b/src/test/java/org/petriNet/ReseauPetriTest.java
@@ -0,0 +1,289 @@
+package org.petriNet;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.LinkedList;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ReseauPetriTest {
+
+ /**
+ * Les fonctions à tester suivantes n’affichent rien. Elles créent des objets et les retournent à la
+ * fonction de test. C’est la fonction de test qui affiche afin que les testeurs puissent observer les
+ * résultats
+ */
+
+ private ReseauPetri reseauPetri;
+ private List<Place> places;
+ private List<Transition> transitions;
+ private LinkedList<Arc> arcs;
+
+ /**
+ * Créer un reseauPetri vide sans entrée. Résultat attendu : un RdP est créé vide
+ * Créer une transition. Résultat attendu : une transition est créée (sans lien)
+ * Créer une place avec nombres de jetons. Les cas : jetons ≥0, jetons < 0.
+ * Résultat attendu : une place est créée (sans lien), aucune place n’est créée ; Erreur
+ */
+
+ @BeforeEach
+ public void setUp() {
+ reseauPetri = new ReseauPetri();
+ }
+
+ @Test
+ public void testAjouterJeton() {
+ Place place = new Place(2, reseauPetri.generateId(1));
+ place.ajouter_jeton(-2);
+ place.ajouter_jeton(2);
+ assertEquals(4, place.get_nombre_jetons());
+ }
+
+ @Test
+ public void testEnleverJeton() {
+ Place place = new Place(2, reseauPetri.generateId(1));
+ place.enlever_jeton(-2);
+ place.enlever_jeton(2);
+ assertEquals(0, place.get_nombre_jetons());
+ }
+
+ @Test
+ public void testAjouterPlace() {
+ Place place = new Place(2, reseauPetri.generateId(1));
+ reseauPetri.ajouterPlace(place);
+
+ // A test for an existing place
+ reseauPetri.ajouterPlace(place);
+ assertEquals(1, reseauPetri.getPlaces().size());
+ }
+
+ @Test
+ public void testAjouterTransition() {
+ Transition transition = new Transition("transition", reseauPetri.generateId(2));
+ reseauPetri.ajouterTransition(transition);
+ // A test for an existing transition
+ reseauPetri.ajouterTransition(transition);
+ assertEquals(1, reseauPetri.getTransitions().size());
+ }
+
+ @Test
+ public void testAjouterArc() {
+ Place place = new Place(2, reseauPetri.generateId(1));
+ Transition transition = new Transition("transition", reseauPetri.generateId(2));
+ Arc_SORTANT arc_0 = new Arc_SORTANT(transition, place, 1, reseauPetri.generateId(0));
+
+ // A test for a negative weight
+ Arc_SORTANT arc_1 = new Arc_SORTANT(transition, place, -1, reseauPetri.generateId(0));
+ reseauPetri.ajouterArc(arc_0);
+
+ // A test for an existing arc
+ reseauPetri.ajouterArc(arc_0);
+ assertEquals(1, reseauPetri.getArcs().size());
+ }
+
+ @Test
+ public void testAssemblerPetri(){
+
+ ReseauPetri Mutex = new ReseauPetri();
+ Arc arc;
+
+ Place P1 = new Place(0, Mutex.generateId(1));
+ Mutex.ajouterPlace(P1);
+ Mutex.ajouterPlace(P1);
+
+ Transition T1 = new Transition("T1", Mutex.generateId(2));
+ Mutex.ajouterTransition(T1);
+ Mutex.ajouterTransition(T1);
+
+ Place P2 = new Place(1, Mutex.generateId(1));
+ Mutex.ajouterPlace(P2);
+
+ Transition T2 = new Transition("T2", Mutex.generateId(2));
+ Mutex.ajouterTransition(T2);
+
+ Place P3 = new Place(0, Mutex.generateId(1));
+ Mutex.ajouterPlace(P3);
+
+ Transition T3 = new Transition("T3", Mutex.generateId(2));
+ Mutex.ajouterTransition(T3);
+
+ Place P4 = new Place(0, Mutex.generateId(1));
+ Mutex.ajouterPlace(P4);
+
+ Transition T4 = new Transition("T4", Mutex.generateId(2));
+ Mutex.ajouterTransition(T4);
+
+ Place P5 = new Place(1, Mutex.generateId(1));
+ Mutex.ajouterPlace(P5);
+
+ // Creer l'arc entrant simple à T1 de P1
+ arc = new Arc_entrant_simple(T1, P1, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T1.ajouterArc_ENTRANT((Arc_ENTRANT) arc);
+
+ // Creer l'arc sortant de T2 vers P1
+ arc = new Arc_SORTANT(T2, P1, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T2.ajouterArc_SORTANT((Arc_SORTANT) arc);
+
+ // Creer l'arc sortant de T1 vers P2
+ arc = new Arc_SORTANT(T1, P2, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T1.ajouterArc_SORTANT((Arc_SORTANT) arc);
+
+ // Creer l'arc entrant simple à T2 de P2
+ arc = new Arc_entrant_simple(T2, P2, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T2.ajouterArc_ENTRANT((Arc_ENTRANT) arc);
+
+ // Creer l'arc entrant simple à T1 de P3
+ arc = new Arc_entrant_simple(T1, P3, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T1.ajouterArc_ENTRANT((Arc_ENTRANT) arc);
+
+ // Creer l'arc sortant de T2 vers P3
+ arc = new Arc_SORTANT(T2, P3, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T2.ajouterArc_SORTANT((Arc_SORTANT) arc);
+
+ // Creer l'arc entrant simple à T3 de P3
+ arc = new Arc_entrant_simple(T3, P3, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T3.ajouterArc_ENTRANT((Arc_ENTRANT) arc);
+
+ // Creer l'arc sortant de T4 vers P3
+ arc = new Arc_SORTANT(T4, P3, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T4.ajouterArc_SORTANT((Arc_SORTANT) arc);
+
+ // Creer l'arc sortant de T3 à P4
+ arc = new Arc_SORTANT(T3, P4, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T3.ajouterArc_SORTANT((Arc_SORTANT) arc);
+
+ // Creer l'arc entrant à T4 de P4
+ arc = new Arc_entrant_simple(T4, P4, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T4.ajouterArc_ENTRANT((Arc_ENTRANT) arc);
+
+ // Creer l'arc entrant à T3 de P5
+ arc = new Arc_entrant_simple(T3, P5, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T3.ajouterArc_ENTRANT((Arc_ENTRANT) arc);
+
+ // Creer l'arc sortant de T4 vers P5
+ arc = new Arc_SORTANT(T4, P5, 1, Mutex.generateId(0));
+ Mutex.ajouterArc(arc);
+ T4.ajouterArc_SORTANT((Arc_SORTANT) arc);
+
+ Mutex.afficherReseau();
+
+ }
+
+ @Test
+ public void testActiverPetri_1() {
+ ReseauPetri Active = new ReseauPetri();
+
+ // Active has only one Transition
+ Transition T1 = new Transition("T1", Active.generateId(2));
+ Active.ajouterTransition(T1);
+
+ // Tirer T1
+ Active.tirer_transition(String.valueOf(T1.getId()));
+ Active.afficherReseau();
+ }
+
+ @Test
+ public void testActiverPetri_2() {
+ ReseauPetri Active = new ReseauPetri();
+
+ Transition T1 = new Transition("T1", Active.generateId(2));
+
+ // Active has only one Place with 0 jetons
+ Place P1 = new Place(0, Active.generateId(1));
+ Active.ajouterPlace(P1);
+
+ // Creer l'arc entrant simple à T1 de P1
+ Arc_ENTRANT arc = new Arc_entrant_simple(T1, P1, 1, Active.generateId(0));
+ Active.ajouterArc(arc);
+
+ T1.ajouterArc_ENTRANT(arc);
+ Active.ajouterTransition(T1);
+
+ // Tirer T1
+ Active.tirer_transition(String.valueOf(T1.getId()));
+ Active.afficherReseau();
+ }
+
+ @Test
+ public void testActiverPetri_3() {
+ ReseauPetri Active = new ReseauPetri();
+
+ Transition T1 = new Transition("T1", Active.generateId(2));
+
+ // Active has only one Place with 2 jeton
+ Place P1 = new Place(2, Active.generateId(1));
+ Active.ajouterPlace(P1);
+
+ // Creer l'arc entrant simple à T1 de P1
+ Arc_ENTRANT arc = new Arc_entrant_simple(T1, P1, 1, Active.generateId(0));
+ Active.ajouterArc(arc);
+
+ T1.ajouterArc_ENTRANT(arc);
+ Active.ajouterTransition(T1);
+
+ // Tirer T1
+ Active.tirer_transition(String.valueOf(T1.getId()));
+ Active.afficherReseau();
+ }
+
+ @Test
+ public void testActiverPetri_4() {
+ ReseauPetri Active = new ReseauPetri();
+
+ Transition T1 = new Transition("T1", Active.generateId(2));
+
+ // Active has only one Place with 5 jetons
+ Place P1 = new Place(5, Active.generateId(1));
+ Active.ajouterPlace(P1);
+
+ // Creer l'arc entrant simple à T1 de P1
+ Arc_ENTRANT arc = new Arc_entrant_simple(T1, P1, 3, Active.generateId(0));
+ Active.ajouterArc(arc);
+
+ T1.ajouterArc_ENTRANT(arc);
+ Active.ajouterTransition(T1);
+
+ // Tirer T1
+ Active.tirer_transition(String.valueOf(T1.getId()));
+ Active.afficherReseau();
+ }
+
+ @Test
+ public void testActiverPetri_5() {
+ ReseauPetri Active = new ReseauPetri();
+
+ Transition T1 = new Transition("T1", Active.generateId(2));
+
+ // Active has two Places with 0 and 2 jetons
+ Place P1 = new Place(0, Active.generateId(1));
+ Place P2 = new Place(2, Active.generateId(1));
+ Active.ajouterPlace(P1);
+ Active.ajouterPlace(P2);
+
+ // Creer l'arc entrant simple à T1 de P1
+ Arc_ENTRANT arc = new Arc_entrant_simple(T1, P1, 1, Active.generateId(0));
+ Active.ajouterArc(arc);
+ Arc_SORTANT arc_1 = new Arc_SORTANT(T1, P2, 1, Active.generateId(0));
+ Active.ajouterArc(arc_1);
+
+ T1.ajouterArc_ENTRANT(arc);
+ T1.ajouterArc_SORTANT(arc_1);
+ Active.ajouterTransition(T1);
+
+ // Tirer T1
+ Active.tirer_transition(String.valueOf(T1.getId()));
+ Active.afficherReseau();
+ }
+
+}
diff --git a/src/test/java/org/petriNet/TransitionTest.java b/src/test/java/org/petriNet/TransitionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2ab20b59584c33f1452340a6dccba4a9e186432
--- /dev/null
+++ b/src/test/java/org/petriNet/TransitionTest.java
@@ -0,0 +1,14 @@
+package org.petriNet;// src/test/java/org/petriNet/TransitionTest.java
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TransitionTest {
+ private Transition transition;
+ private List<Arc_SORTANT> arcs_SORTANTS;
+ private List<Arc_ENTRANT> arcs_ENTRANTS;
+
+}