boudjeml/FIProjetIHM2022
1
2
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

$

Browse Source
This commit is contained in:
pro.boooooo
2022-11-15 20:03:04 +01:00
parent dd958e5067
commit f236e39d7c
102 changed files with 29019 additions and 4400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
src/API/AbstractChangementFactory.java
View File

@@ -1,55 +1,55 @@
package API;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des changements.
*/
public interface AbstractChangementFactory {
/**
* permet de récupérer une usine abstraite pour les groupes qui fonctionne en tandem avec cette usine abstraite
*
* @return cette usine abstraite pour les groupes
*/
public AbstractGroupeFactory getGroupeFactory();
/**
* permet de récupérer les changements
*
* @return l'ensemble de tous les changements en attente
* <p>
* NB. Attention. C'était Iterator<Changement> dans la version beta.
*/
public Set<Changement> getAllChangements();
/**
* permet de mettre en oeuvre un changement connu de l'usine abstraite.
* En cas de succès, le changement est oublié (détruit).
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void applyChangement(Changement c);
/**
* permet de supprimer un changement connu de l'usine abstraite.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void deleteChangement(Changement c);
/**
* permet d'ajouter un nouveau changement.
*
* @param A groupe actuel
* @param B groupe demandé
* @param e étudiant concerné par le changement
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
*/
public void createChangement(Groupe A, Etudiant e, Groupe B);
}
package API;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des changements.
*/
public interface AbstractChangementFactory {
/**
* permet de récupérer une usine abstraite pour les groupes qui fonctionne en tandem avec cette usine abstraite
*
* @return cette usine abstraite pour les groupes
*/
public AbstractGroupeFactory getGroupeFactory();
/**
* permet de récupérer les changements
*
* @return l'ensemble de tous les changements en attente
* <p>
* NB. Attention. C'était Iterator<Changement> dans la version beta.
*/
public Set<Changement> getAllChangements();
/**
* permet de mettre en oeuvre un changement connu de l'usine abstraite.
* En cas de succès, le changement est oublié (détruit).
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void applyChangement(Changement c);
/**
* permet de supprimer un changement connu de l'usine abstraite.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void deleteChangement(Changement c);
/**
* permet d'ajouter un nouveau changement.
*
* @param A groupe actuel
* @param B groupe demandé
* @param e étudiant concerné par le changement
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
*/
public void createChangement(Groupe A, Etudiant e, Groupe B);
}

224
src/API/AbstractGroupeFactory.java
View File

@@ -1,112 +1,112 @@
package API;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des groupes.
*/
public interface AbstractGroupeFactory {
/**
* permet de récupérer le Groupe qui contient les étudiants de toute la promotion
*
* @return la promo.
*/
public Groupe getPromotion();
/**
* Test si le groupe g est connu de l'usine (connu maintenant).
* Si la réponse est true, les méthodes avec ce groupe en paramètre devraient bien fonctionner.
* Si la réponse est false, le comportement n'est pas garanti.
*/
public Boolean knows(Groupe g);
/**
* permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
* Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException si le groupe contient des groupes
* @throws java.lang.IllegalArgumentException si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
*/
public void deleteGroupe(Groupe g);
/**
* permet d'ajouter un groupe vide de type FREE comme sous-groupe d'un groupe donné.
*
* @param pere le groupe père du groupe à créer
* @param name le nom du groupe à créer
* @param min,max bornes indicatives sur la taille du groupe à créer
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou si il n'y a pas 0 < min <= max
*/
public void createGroupe(Groupe pere, String name, int min, int max);
/**
* permet de créer une partition automatiquement sous un groupe donné.
*
* @param pere le groupe père du groupe à partitionner
* @param name le nom des groupe à créer (on ajoutera à la suite un numéro ou une lettre pour distinguer chaque groupe)
* @param n le nombre de partitions
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou n négatif ou nul
* <p>
* NB. doit créer une "copie" de pere
* sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
* les valeurs min et max de ces n groupes sont
* min = 0 et
* max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
*/
public void createPartition(Groupe pere, String name, int n);
/**
* permet d'ajouter un étudiant à un groupe.
*
* @param g le groupe dans lequel il faut ajouter l'étudiant
* @param e l'étudiant à ajouter
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
* @throws java.lang.IllegalStateException le père de g ne contient pas e
*/
public void addToGroupe(Groupe g, Etudiant e);
/**
* permet d'enlever un étudiant d'un groupe.
*
* @param g le groupe dans lequel il faut enlever l'étudiant
* @param e l'étudiant à enlever
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException g ne contient pas e
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
*/
public void dropFromGroupe(Groupe g, Etudiant e);
/**
* permet de retrouver un étudiant à partir d'un String.
* <p>
* NB. dans une version simple il doit s'agir du nom exact.
* dans une version un peu plus complexe, il s'agit des premières lettres du nom
* dans une version avancée, on peut autoriser une expression régulière plus ou moins complexe qui est générée si la première recherche n'a pas renvoyé de candidat.
*
* @param String nomEtu le nom approximmatif de l'étudiant
* @return Set<Etudiant> l'ensemble des étudiants connus de la factory ayant un nom "proche" de ce string au sens de la remarque ci-dessus.
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Etudiant> getEtudiants(String nomEtu);
/**
* permet de retrouver les groupes d'un étudiant.
*
* @param Etu un étudiant
* @return Etudiant l'étudiant connu de la factory ayant cet identifiant
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Groupe> getGroupesOfEtudiant(Etudiant etu);
}
package API;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des groupes.
*/
public interface AbstractGroupeFactory {
/**
* permet de récupérer le Groupe qui contient les étudiants de toute la promotion
*
* @return la promo.
*/
public Groupe getPromotion();
/**
* Test si le groupe g est connu de l'usine (connu maintenant).
* Si la réponse est true, les méthodes avec ce groupe en paramètre devraient bien fonctionner.
* Si la réponse est false, le comportement n'est pas garanti.
*/
public Boolean knows(Groupe g);
/**
* permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
* Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException si le groupe contient des groupes
* @throws java.lang.IllegalArgumentException si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
*/
public void deleteGroupe(Groupe g);
/**
* permet d'ajouter un groupe vide de type FREE comme sous-groupe d'un groupe donné.
*
* @param pere le groupe père du groupe à créer
* @param name le nom du groupe à créer
* @param min,max bornes indicatives sur la taille du groupe à créer
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou si il n'y a pas 0 < min <= max
*/
public void createGroupe(Groupe pere, String name, int min, int max);
/**
* permet de créer une partition automatiquement sous un groupe donné.
*
* @param pere le groupe père du groupe à partitionner
* @param name le nom des groupe à créer (on ajoutera à la suite un numéro ou une lettre pour distinguer chaque groupe)
* @param n le nombre de partitions
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou n négatif ou nul
* <p>
* NB. doit créer une "copie" de pere
* sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
* les valeurs min et max de ces n groupes sont
* min = 0 et
* max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
*/
public void createPartition(Groupe pere, String name, int n);
/**
* permet d'ajouter un étudiant à un groupe.
*
* @param g le groupe dans lequel il faut ajouter l'étudiant
* @param e l'étudiant à ajouter
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
* @throws java.lang.IllegalStateException le père de g ne contient pas e
*/
public void addToGroupe(Groupe g, Etudiant e);
/**
* permet d'enlever un étudiant d'un groupe.
*
* @param g le groupe dans lequel il faut enlever l'étudiant
* @param e l'étudiant à enlever
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException g ne contient pas e
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
*/
public void dropFromGroupe(Groupe g, Etudiant e);
/**
* permet de retrouver un étudiant à partir d'un String.
* <p>
* NB. dans une version simple il doit s'agir du nom exact.
* dans une version un peu plus complexe, il s'agit des premières lettres du nom
* dans une version avancée, on peut autoriser une expression régulière plus ou moins complexe qui est générée si la première recherche n'a pas renvoyé de candidat.
*
* @param String nomEtu le nom approximmatif de l'étudiant
* @return Set<Etudiant> l'ensemble des étudiants connus de la factory ayant un nom "proche" de ce string au sens de la remarque ci-dessus.
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Etudiant> getEtudiants(String nomEtu);
/**
* permet de retrouver les groupes d'un étudiant.
*
* @param Etu un étudiant
* @return Etudiant l'étudiant connu de la factory ayant cet identifiant
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Groupe> getGroupesOfEtudiant(Etudiant etu);
}

104
src/API/Changement.java
View File

@@ -1,52 +1,52 @@
package API;
import java.util.*;
/**
* Une demande de changement de groupe
* concerne un étudiant, qui est dans un groupe A et veut aller dans un groupe B.
*/
public interface Changement extends MonPrint {
/**
* permet de récupérer l'identifiant du changement (référence interne sans intérêt irl).
*
* @return l'identifiant.
*/
public int getId();
/**
* permet de récupérer le groupe de depart
*
* @return ce groupe.
*/
public Groupe getA();
/**
* permet de récupérer le groupe d'arrivée
*
* @return ce groupe.
*/
public Groupe getB();
/**
* permet de récupérer l'étudiant demandant le changement
*
* @return cet étudiant
*/
public Etudiant getEtu();
/**
* @see MonPrint
* NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
* <p>
* NB2. On ne peut pas utiliser le toString de Objects
* https://stackoverflow.com/questions/24016962/java8-why-is-it-forbidden-to-define-a-default-method-for-a-method-from-java-lan
*/
public default String monPrint() {
StringBuilder sb = new StringBuilder();
sb.append("Changement de " + this.getEtu().monPrint() + " depuis le groupe " + this.getA().getName() + " vers le groupe " + this.getB().getName());
return sb.toString();
}
}
package API;
import java.util.*;
/**
* Une demande de changement de groupe
* concerne un étudiant, qui est dans un groupe A et veut aller dans un groupe B.
*/
public interface Changement extends MonPrint {
/**
* permet de récupérer l'identifiant du changement (référence interne sans intérêt irl).
*
* @return l'identifiant.
*/
public int getId();
/**
* permet de récupérer le groupe de depart
*
* @return ce groupe.
*/
public Groupe getA();
/**
* permet de récupérer le groupe d'arrivée
*
* @return ce groupe.
*/
public Groupe getB();
/**
* permet de récupérer l'étudiant demandant le changement
*
* @return cet étudiant
*/
public Etudiant getEtu();
/**
* @see MonPrint
* NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
* <p>
* NB2. On ne peut pas utiliser le toString de Objects
* https://stackoverflow.com/questions/24016962/java8-why-is-it-forbidden-to-define-a-default-method-for-a-method-from-java-lan
*/
public default String monPrint() {
StringBuilder sb = new StringBuilder();
sb.append("Changement de " + this.getEtu().monPrint() + " depuis le groupe " + this.getA().getName() + " vers le groupe " + this.getB().getName());
return sb.toString();
}
}

88
src/API/Etudiant.java
View File

@@ -1,44 +1,44 @@
package API;
/**
* Un étudiant
*/
public interface Etudiant extends MonPrint {
/**
* permet de récupérer l'identifiant de l'étudiant.
*
* @return l'identifiant.
*/
public int getId();
/**
* permet de récupérer
*
* @return le nom de l'étudiant.
*/
public String getNom();
/**
* permet de récupérer
*
* @return le prénom de l'étudiant
*/
public String getPrenom();
/**
* Ajout de l'equipe pour recuperer son groupe
*
* @return Le groupe en entier
* */
public int getGroupe();
/**
* @see MonPrint
* NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
*/
public default String monPrint() {
return String.format("Nom " + getNom() + " Prenom " + getPrenom() + " Groupe " + getGroupe() + " (id=" + getId() + ")");
}
}
package API;
/**
* Un étudiant
*/
public interface Etudiant extends MonPrint {
/**
* permet de récupérer l'identifiant de l'étudiant.
*
* @return l'identifiant.
*/
public int getId();
/**
* permet de récupérer
*
* @return le nom de l'étudiant.
*/
public String getNom();
/**
* permet de récupérer
*
* @return le prénom de l'étudiant
*/
public String getPrenom();
/**
* Ajout de l'equipe pour recuperer son groupe
*
* @return Le groupe en entier
* */
public int getGroupe();
/**
* @see MonPrint
* NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
*/
public default String monPrint() {
return String.format("Nom " + getNom() + " Prenom " + getPrenom() + " Groupe " + getGroupe() + " (id=" + getId() + ")");
}
}

262
src/API/Groupe.java
View File

@@ -1,131 +1,131 @@
package API;
import java.util.*;
/**
* Un groupe
*/
public interface Groupe extends MonPrint {
/**
* Ajoute un étudiant. Se comporte comme add de l'interface Set.
*
* @return true iff e est ajouté
*/
public boolean addEtudiant(Etudiant e);
/**
* Enlève un étudiant. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
boolean removeEtudiant(Etudiant e);
/**
* Ajoute un sous-groupe. Se comporte comme add de l'interface Set.
* vérifie que le groupe passé en argument a bien renseigné this comme son père.
*
* @return true iff g est ajouté
*/
public boolean addSousGroupe(Groupe g);
/**
* Enlève un groupe. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
public boolean removeSousGroupe(Groupe g);
/**
* permet de récupérer l'identifiant d'un groupe (référence interne sans intérêt irl).
*
* @return l'identifiant.
*/
public int getId();
/**
* permet de récupérer le nom d'un groupe (utile irl).
*
* @return le nom.
*/
public String getName();
/**
* permet de récupérer le nombre minimum d'étudiants souhaités dans le groupe.
*
* @return le minimum souhaité
*/
public int getMin();
/**
* permet de récupérer le nombre maximum d'étudiants souhaités dans un groupe.
*
* @return le maximum souhaité
*/
public int getMax();
/**
* permet de récupérer le nombre d'étudiants dans ce groupe.
*
* @return le nombre de places prises (pas forcément limité entre Min et Max, mais c'est le but)
*/
public int getSize();
/**
* permet de récupérer la nature du groupe
*
* @return le type du groupe
*/
public TypeGroupe getType();
/**
* permet de récupérer le groupe père
* un groupe racine devrait retourner lui-même
*
* @return le père
*/
public Groupe getPointPoint();
/**
* Potentiellement "vide"
*
* @return l'ensemble des sous-groupes.
*/
public Set<Groupe> getSousGroupes();
/**
* Potentiellement "vide"
*
* @return l'ensemble des étudiants.
*/
public Set<Etudiant> getEtudiants();
/**
* @see MonPrint
* NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
* <p>
* NB2. On ne peut pas utiliser le toString de Objects
* https://stackoverflow.com/questions/24016962/java8-why-is-it-forbidden-to-define-a-default-method-for-a-method-from-java-lan
*/
public default String monPrint() {
StringBuilder sb = new StringBuilder();
sb.append("Groupe " + getName() + " (" + getType() + ", capacité " + getMin() + " à " + getMax() + ", id " + getId() + ")");
sb.append("\n");
// NB. getEtudiants() retourne un Set qui étend Iterable
// On peut utiliser les mécanismes de boucle "moderne" de puis la version 8
// pour se faciliter la vie quand le traitement est assez simple
// voir https://docs.oracle.com/javase/8/docs/technotes/guides/language/foreach.html
sb.append(" ** Étudiants **\n");
for (Etudiant s : getEtudiants()) {
sb.append("\t _ " + s.monPrint());
sb.append("\n");
}
sb.append(" ** Sous Groupes **\n");
for (Groupe g : getSousGroupes()) {
sb.append("\t _ " + g.getName() + " (" + g.getType() + ", capacité " + g.getMin() + " à " + g.getMax() + ", id " + g.getId() + ")");
sb.append("\n");
}
return sb.toString();
}
}
package API;
import java.util.*;
/**
* Un groupe
*/
public interface Groupe extends MonPrint {
/**
* Ajoute un étudiant. Se comporte comme add de l'interface Set.
*
* @return true iff e est ajouté
*/
public boolean addEtudiant(Etudiant e);
/**
* Enlève un étudiant. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
boolean removeEtudiant(Etudiant e);
/**
* Ajoute un sous-groupe. Se comporte comme add de l'interface Set.
* vérifie que le groupe passé en argument a bien renseigné this comme son père.
*
* @return true iff g est ajouté
*/
public boolean addSousGroupe(Groupe g);
/**
* Enlève un groupe. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
public boolean removeSousGroupe(Groupe g);
/**
* permet de récupérer l'identifiant d'un groupe (référence interne sans intérêt irl).
*
* @return l'identifiant.
*/
public int getId();
/**
* permet de récupérer le nom d'un groupe (utile irl).
*
* @return le nom.
*/
public String getName();
/**
* permet de récupérer le nombre minimum d'étudiants souhaités dans le groupe.
*
* @return le minimum souhaité
*/
public int getMin();
/**
* permet de récupérer le nombre maximum d'étudiants souhaités dans un groupe.
*
* @return le maximum souhaité
*/
public int getMax();
/**
* permet de récupérer le nombre d'étudiants dans ce groupe.
*
* @return le nombre de places prises (pas forcément limité entre Min et Max, mais c'est le but)
*/
public int getSize();
/**
* permet de récupérer la nature du groupe
*
* @return le type du groupe
*/
public TypeGroupe getType();
/**
* permet de récupérer le groupe père
* un groupe racine devrait retourner lui-même
*
* @return le père
*/
public Groupe getPointPoint();
/**
* Potentiellement "vide"
*
* @return l'ensemble des sous-groupes.
*/
public Set<Groupe> getSousGroupes();
/**
* Potentiellement "vide"
*
* @return l'ensemble des étudiants.
*/
public Set<Etudiant> getEtudiants();
/**
* @see MonPrint
* NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
* <p>
* NB2. On ne peut pas utiliser le toString de Objects
* https://stackoverflow.com/questions/24016962/java8-why-is-it-forbidden-to-define-a-default-method-for-a-method-from-java-lan
*/
public default String monPrint() {
StringBuilder sb = new StringBuilder();
sb.append("Groupe " + getName() + " (" + getType() + ", capacité " + getMin() + " à " + getMax() + ", id " + getId() + ")");
sb.append("\n");
// NB. getEtudiants() retourne un Set qui étend Iterable
// On peut utiliser les mécanismes de boucle "moderne" de puis la version 8
// pour se faciliter la vie quand le traitement est assez simple
// voir https://docs.oracle.com/javase/8/docs/technotes/guides/language/foreach.html
sb.append(" ** Étudiants **\n");
for (Etudiant s : getEtudiants()) {
sb.append("\t _ " + s.monPrint());
sb.append("\n");
}
sb.append(" ** Sous Groupes **\n");
for (Groupe g : getSousGroupes()) {
sb.append("\t _ " + g.getName() + " (" + g.getType() + ", capacité " + g.getMin() + " à " + g.getMax() + ", id " + g.getId() + ")");
sb.append("\n");
}
return sb.toString();
}
}

26
src/API/MonPrint.java
View File

@@ -1,13 +1,13 @@
package API;
/**
* Toutes nos interfaces vont étendre cette interface.
*/
public interface MonPrint {
/**
* Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint().
* Toutes nos interfaces vont étendre cette interface.
*/
public String monPrint();
}
package API;
/**
* Toutes nos interfaces vont étendre cette interface.
*/
public interface MonPrint {
/**
* Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint().
* Toutes nos interfaces vont étendre cette interface.
*/
public String monPrint();
}

22
src/API/TypeGroupe.java
View File

@@ -1,11 +1,11 @@
package API;
public enum TypeGroupe {
ROOT("Tous les étudiants"), PARTITION("partition"), FREE("libre");
private final String name;
private TypeGroupe(String s) {
name = s;
}
}
package API;
public enum TypeGroupe {
ROOT("Tous les étudiants"), PARTITION("partition"), FREE("libre");
private final String name;
private TypeGroupe(String s) {
name = s;
}
}

210
src/MNP/AbstractChangementFactoryNP.java
View File

@@ -1,105 +1,105 @@
package MNP;
import API.*;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des changements.
*
*/
public class AbstractChangementFactoryNP implements AbstractChangementFactory {
// l'usine à groupe travaillant en tandem avec cette usine.
private AbstractGroupeFactory agf;
// On utilise une table de hachage pour retrouver facilement un changement (à partir de son id).
// Si il y a beaucoup de changements c'est plus rapide que de parcourir toute une liste.
private HashMap<Integer,Changement> brain;
public AbstractChangementFactoryNP(AbstractGroupeFactory agf){
Objects.requireNonNull(agf,"On ne peut pas créer une usine à changement dont l'usine à groupe parternaire est null");
this.agf=agf;
this.brain=new HashMap<Integer,Changement>();
}
/**
* permet de récupérer l'usine abstraite pour les groupes qui fonctionne en tandem avec cette usine abstraite
* @return cette usine abstraite pour les groupes
*/
public AbstractGroupeFactory getGroupeFactory(){
return this.agf;
}
/**
* permet de récupérer les changements
* @return l'ensemble de tous les changements en attente
*/
public Set<Changement> getAllChangements(){
// la méthode value() d'un hashmap retourne la collection des valeurs.
// Il faut transformer la collection en Set.
// Un constructeur de HashSet permet de faire cette opération.
Set<Changement> out = new HashSet<>(this.brain.values());
return out;
}
/**
* permet de mettre en oeuvre un changement connu de l'usine abstraite.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException si le changement n'a pas de sens en l'état actuel (e.g. étudiant pas dans le groupe de départ a, groupe b inconnu, groupe a inconnu, etc).
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void applyChangement(Changement c){
Objects.requireNonNull(c,"On ne peut pas appliquer un changement qui est null");
Etudiant e = c.getEtu();
Groupe a = c.getA();
Groupe b = c.getB();
if (!agf.knows(a)) throw new IllegalStateException("Le groupe de départ du changement est inconnu. Impossible à mettre en oeuvre.");
if (!agf.knows(b)) throw new IllegalStateException("Le groupe d'arrivée du changement est inconnu. Impossible à mettre en oeuvre.");
// pas encore implanté.
// if(!agf.getGroupesOfEtudiant(e).contains(a)) throw new IllegalStateException("Le groupe de départ ne contient pas l'étudiant. Impossible à mettre en oeuvre.");
agf.dropFromGroupe(a,e);
agf.addToGroupe(b,e);
// En cas de succès, on enlève le changement du cerveau
this.brain.remove(Integer.valueOf(c.getId()));
}
/**
* permet de supprimer un changement connu de l'usine abstraite.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void deleteChangement(Changement c){
Objects.requireNonNull(c,"On ne peut pas demander la suppression d'un changement qui est null");
this.brain.remove(Integer.valueOf(c.getId()));
}
/**
* permet d'ajouter un nouveau changement.
*
* @param A groupe actuel
* @param B groupe demandé
* @param e étudiant concerné par le changement
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
*
*/
public void createChangement(Groupe A, Etudiant e, Groupe B){
Objects.requireNonNull(A,"Le groupe d'origine ne peut pas être null");
Objects.requireNonNull(B,"Le groupe d'arrivée ne peut pas être null");
Objects.requireNonNull(e,"L'étudiant ne peut pas être null");
Changement c = new ChangementNP(A,e,B);
this.brain.put(Integer.valueOf(c.getId()),c);
}
}
package MNP;
import API.*;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des changements.
*
*/
public class AbstractChangementFactoryNP implements AbstractChangementFactory {
// l'usine à groupe travaillant en tandem avec cette usine.
private AbstractGroupeFactory agf;
// On utilise une table de hachage pour retrouver facilement un changement (à partir de son id).
// Si il y a beaucoup de changements c'est plus rapide que de parcourir toute une liste.
private HashMap<Integer,Changement> brain;
public AbstractChangementFactoryNP(AbstractGroupeFactory agf){
Objects.requireNonNull(agf,"On ne peut pas créer une usine à changement dont l'usine à groupe parternaire est null");
this.agf=agf;
this.brain=new HashMap<Integer,Changement>();
}
/**
* permet de récupérer l'usine abstraite pour les groupes qui fonctionne en tandem avec cette usine abstraite
* @return cette usine abstraite pour les groupes
*/
public AbstractGroupeFactory getGroupeFactory(){
return this.agf;
}
/**
* permet de récupérer les changements
* @return l'ensemble de tous les changements en attente
*/
public Set<Changement> getAllChangements(){
// la méthode value() d'un hashmap retourne la collection des valeurs.
// Il faut transformer la collection en Set.
// Un constructeur de HashSet permet de faire cette opération.
Set<Changement> out = new HashSet<>(this.brain.values());
return out;
}
/**
* permet de mettre en oeuvre un changement connu de l'usine abstraite.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException si le changement n'a pas de sens en l'état actuel (e.g. étudiant pas dans le groupe de départ a, groupe b inconnu, groupe a inconnu, etc).
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void applyChangement(Changement c){
Objects.requireNonNull(c,"On ne peut pas appliquer un changement qui est null");
Etudiant e = c.getEtu();
Groupe a = c.getA();
Groupe b = c.getB();
if (!agf.knows(a)) throw new IllegalStateException("Le groupe de départ du changement est inconnu. Impossible à mettre en oeuvre.");
if (!agf.knows(b)) throw new IllegalStateException("Le groupe d'arrivée du changement est inconnu. Impossible à mettre en oeuvre.");
// pas encore implanté.
// if(!agf.getGroupesOfEtudiant(e).contains(a)) throw new IllegalStateException("Le groupe de départ ne contient pas l'étudiant. Impossible à mettre en oeuvre.");
agf.dropFromGroupe(a,e);
agf.addToGroupe(b,e);
// En cas de succès, on enlève le changement du cerveau
this.brain.remove(Integer.valueOf(c.getId()));
}
/**
* permet de supprimer un changement connu de l'usine abstraite.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
*/
public void deleteChangement(Changement c){
Objects.requireNonNull(c,"On ne peut pas demander la suppression d'un changement qui est null");
this.brain.remove(Integer.valueOf(c.getId()));
}
/**
* permet d'ajouter un nouveau changement.
*
* @param A groupe actuel
* @param B groupe demandé
* @param e étudiant concerné par le changement
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
*
*/
public void createChangement(Groupe A, Etudiant e, Groupe B){
Objects.requireNonNull(A,"Le groupe d'origine ne peut pas être null");
Objects.requireNonNull(B,"Le groupe d'arrivée ne peut pas être null");
Objects.requireNonNull(e,"L'étudiant ne peut pas être null");
Changement c = new ChangementNP(A,e,B);
this.brain.put(Integer.valueOf(c.getId()),c);
}
}

452
src/MNP/AbstractGroupeFactoryNP.java
View File

@@ -1,226 +1,226 @@
package MNP;
import API.*;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des groupes.
*
*/
public class AbstractGroupeFactoryNP implements AbstractGroupeFactory {
// la racine (promotion)
private Groupe promo;
// On utilise une table de hachage pour retrouver facilement un groupe (à partir de son id).
// Si il y a beaucoup de groupes c'est plus rapide que de parcourir toute une liste.
private HashMap<Integer,Groupe> brain;
/**
* Le constructeur fabrique le groupe promotion vide.
* Il faut ensuite y ajouter les étudiants.
*/
public AbstractGroupeFactoryNP(int id, String name, int min, int max){
Objects.requireNonNull(name,"On ne peut pas créer une promotion dont le nom est null");
this.promo=new GroupeNP(id, name,min,max);
this.brain=new HashMap<Integer,Groupe>();
this.brain.put(id,this.promo);
}
/**
* Test plutôt optimiste. Si la clé est identique alors on fait comme si c'était le bon groupe.
*/
public Boolean knows(Groupe g){
return this.brain.containsKey(Integer.valueOf(g.getId()));
}
/**
* permet de récupérer le Groupe qui contient les étudiants de toute la promotion
* @return la promo.
*/
public Groupe getPromotion(){
return this.promo;
}
/**
* permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
* Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException si le groupe contient des groupes
* @throws java.lang.IllegalArgumentException si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
*/
public void deleteGroupe(Groupe g){
Objects.requireNonNull(g,"On ne peut pas enlever un groupe null car null n'est pas un groupe autorisé");
if (!this.knows(g)){
throw new IllegalArgumentException("Impossible d'enlever un groupe inconnu");
}
if (this.getPromotion().equals(g)){
throw new IllegalArgumentException("Impossible de détruire le groupe de toute la promotion");
}
if (g.getSize()>0){
throw new IllegalStateException("Impossible de détruire un groupe contenant un groupe");
}
g.getPointPoint().removeSousGroupe(g);
this.brain.remove(Integer.valueOf(g.getId()));
}
/**
* permet d'ajouter un groupe vide de type FREE comme sous-groupe d'un groupe donné.
* @param pere le groupe père du groupe à créer
* @param name le nom du groupe à créer
* @param min,max bornes indicatives sur la taille du groupe à créer
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou si il n'y a pas 0 < min <= max
*/
public void createGroupe(Groupe pere, String name, int min, int max){
Objects.requireNonNull(pere,"Le groupe pere ne peut pas être null");
Objects.requireNonNull(name,"Le nouveau groupe ne peut pas avoir null comme nom");
if (!this.knows(pere)){
throw new IllegalArgumentException("Interdit d'ajouter un fils à un groupe inconnu");
}
if (pere.getType().equals(TypeGroupe.PARTITION)){
throw new IllegalArgumentException("Impossible d'ajouter un groupe à une parition. Il faut utiliser createPartition pour créer une partition");
}
if ( min <= 0 || max < min){
throw new IllegalArgumentException("Il faut que 0 < min <= max");
}
Groupe g = new GroupeNP(pere,name,min,max);
pere.addSousGroupe(g);
this.brain.put(Integer.valueOf(g.getId()),g);
}
/**
* permet de créer une partition automatiquement sous un groupe donné.
*
* @param pere le groupe père du groupe à partitionner
* @param name le nom des groupe à créer (on ajoute à la suite un numéro de 1 à n pour distinguer chaque groupe formant la partition)
* @param n le nombre de partitions
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou n négatif ou nul
*
* NB. doit créer une "copie" de pere
* sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
* les valeurs min et max de ces n groupes sont
* min = 0 et
* max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
*/
public void createPartition(Groupe pere, String name, int n){
Objects.requireNonNull(pere,"Le groupe pere ne peut pas être null");
Objects.requireNonNull(name,"Le nouveau groupe ne peut pas avoir null comme nom");
if (!this.knows(pere)){
throw new IllegalArgumentException("Impossible de partitionner ce groupe inconnu");
}
if (pere.getType().equals(TypeGroupe.PARTITION)){
throw new IllegalArgumentException("Impossible de créer une partition à ce niveau. Il faut soit repartitionner le groupe au dessus, soit partitionner une partition en dessous.");
}
if ( n <= 0){
throw new IllegalArgumentException("Le nombre de partitions doit être strictement positif");
}
//Création de la racine de la partition.
Groupe copiePereRacinePartition = new GroupeNP(pere);
pere.addSousGroupe(copiePereRacinePartition);
this.brain.put(Integer.valueOf(copiePereRacinePartition.getId()),copiePereRacinePartition);
// création des sous-groupes
int min = 0;
int max = ((int) Math.floor(pere.getSize()/n))+1;
List<Groupe> groupes = new ArrayList<Groupe>(n);
for(int i = 0; i<n; i++){
Groupe g = new GroupeNP(copiePereRacinePartition,name+"_"+i,min,max);
groupes.add(i,g);// ajout dans le tableau des groupes
copiePereRacinePartition.addSousGroupe(g);
this.brain.put(Integer.valueOf(g.getId()),g);
}
// Partage des étudiants (on ne prête pas attention aux min et max)
int i=0;
for (Etudiant s: pere.getEtudiants()){
copiePereRacinePartition.addEtudiant(s);
groupes.get(i).addEtudiant(s);
i = (i+1) %n;
}
}
/**
* permet d'ajouter un étudiant à un groupe.
*
* @param g le groupe dans lequel il faut ajouter l'étudiant
* @param e l'étudiant à ajouter
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
* @throws java.lang.IllegalStateException le père de g ne contient pas e
*/
public void addToGroupe(Groupe g, Etudiant e){
Objects.requireNonNull(g,"Le groupe ne peut pas être null");
Objects.requireNonNull(e,"L'étudiant ne peut pas être null");
if (!this.knows(g)){
throw new IllegalArgumentException("Impossible d'ajouter l'étudiant car le est groupe inconnu");
}
g.addEtudiant(e);
}
/**
* permet d'enlever un étudiant d'un groupe.
*
* @param g le groupe dans lequel il faut enlever l'étudiant
* @param e l'étudiant à enlever
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException g ne contient pas e
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
*/
public void dropFromGroupe(Groupe g, Etudiant e){
Objects.requireNonNull(g,"Le groupe ne peut pas être null");
Objects.requireNonNull(e,"L'étudiant ne peut pas être null");
if (!this.knows(g)){
throw new IllegalArgumentException("Impossible d'ajouter l'étudiant car le est groupe inconnu");
}
g.removeEtudiant(e);
}
/**
* permet de retrouver un étudiant à partir d'un String.
*
* NB. dans une version simple il doit s'agir du nom exact.
* dans une version un peu plus complexe, il s'agit des premières lettres du nom
* dans une version avancée, on peut autoriser une expression régulière plus ou moins complexe qui est générée si la première recherche n'a pas renvoyé de candidat.
*
* @param String nomEtu le nom approximmatif de l'étudiant
* @return Set<Etudiant> l'ensemble des étudiants connus de la factory ayant un nom "proche" de ce string au sens de la remarque ci-dessus.
*
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Etudiant> getEtudiants(String nomEtu){
// on cherche bêtement dans la promo.
Set<Etudiant> out = new LinkedHashSet<Etudiant>();
for (Etudiant e : getPromotion().getEtudiants()){
if (e.getNom().equals(nomEtu)){
out.add(e);
break;
}
}
return out;
}
/**
* permet de retrouver les groupes d'un étudiant.
*
* @param Etu un étudiant
* @return Etudiant l'étudiant connu de la factory ayant cet identifiant
*
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Groupe> getGroupesOfEtudiant(Etudiant etu){
throw new UnsupportedOperationException("pas encore implanté");
}
}
package MNP;
import API.*;
import java.util.*;
/**
* Usine abstraite gérant l'ensemble des groupes.
*
*/
public class AbstractGroupeFactoryNP implements AbstractGroupeFactory {
// la racine (promotion)
private Groupe promo;
// On utilise une table de hachage pour retrouver facilement un groupe (à partir de son id).
// Si il y a beaucoup de groupes c'est plus rapide que de parcourir toute une liste.
private HashMap<Integer,Groupe> brain;
/**
* Le constructeur fabrique le groupe promotion vide.
* Il faut ensuite y ajouter les étudiants.
*/
public AbstractGroupeFactoryNP(int id, String name, int min, int max){
Objects.requireNonNull(name,"On ne peut pas créer une promotion dont le nom est null");
this.promo=new GroupeNP(id, name,min,max);
this.brain=new HashMap<Integer,Groupe>();
this.brain.put(id,this.promo);
}
/**
* Test plutôt optimiste. Si la clé est identique alors on fait comme si c'était le bon groupe.
*/
public Boolean knows(Groupe g){
return this.brain.containsKey(Integer.valueOf(g.getId()));
}
/**
* permet de récupérer le Groupe qui contient les étudiants de toute la promotion
* @return la promo.
*/
public Groupe getPromotion(){
return this.promo;
}
/**
* permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
* Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException si le groupe contient des groupes
* @throws java.lang.IllegalArgumentException si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
*/
public void deleteGroupe(Groupe g){
Objects.requireNonNull(g,"On ne peut pas enlever un groupe null car null n'est pas un groupe autorisé");
if (!this.knows(g)){
throw new IllegalArgumentException("Impossible d'enlever un groupe inconnu");
}
if (this.getPromotion().equals(g)){
throw new IllegalArgumentException("Impossible de détruire le groupe de toute la promotion");
}
if (g.getSize()>0){
throw new IllegalStateException("Impossible de détruire un groupe contenant un groupe");
}
g.getPointPoint().removeSousGroupe(g);
this.brain.remove(Integer.valueOf(g.getId()));
}
/**
* permet d'ajouter un groupe vide de type FREE comme sous-groupe d'un groupe donné.
* @param pere le groupe père du groupe à créer
* @param name le nom du groupe à créer
* @param min,max bornes indicatives sur la taille du groupe à créer
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou si il n'y a pas 0 < min <= max
*/
public void createGroupe(Groupe pere, String name, int min, int max){
Objects.requireNonNull(pere,"Le groupe pere ne peut pas être null");
Objects.requireNonNull(name,"Le nouveau groupe ne peut pas avoir null comme nom");
if (!this.knows(pere)){
throw new IllegalArgumentException("Interdit d'ajouter un fils à un groupe inconnu");
}
if (pere.getType().equals(TypeGroupe.PARTITION)){
throw new IllegalArgumentException("Impossible d'ajouter un groupe à une parition. Il faut utiliser createPartition pour créer une partition");
}
if ( min <= 0 || max < min){
throw new IllegalArgumentException("Il faut que 0 < min <= max");
}
Groupe g = new GroupeNP(pere,name,min,max);
pere.addSousGroupe(g);
this.brain.put(Integer.valueOf(g.getId()),g);
}
/**
* permet de créer une partition automatiquement sous un groupe donné.
*
* @param pere le groupe père du groupe à partitionner
* @param name le nom des groupe à créer (on ajoute à la suite un numéro de 1 à n pour distinguer chaque groupe formant la partition)
* @param n le nombre de partitions
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
* ou n négatif ou nul
*
* NB. doit créer une "copie" de pere
* sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
* les valeurs min et max de ces n groupes sont
* min = 0 et
* max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
*/
public void createPartition(Groupe pere, String name, int n){
Objects.requireNonNull(pere,"Le groupe pere ne peut pas être null");
Objects.requireNonNull(name,"Le nouveau groupe ne peut pas avoir null comme nom");
if (!this.knows(pere)){
throw new IllegalArgumentException("Impossible de partitionner ce groupe inconnu");
}
if (pere.getType().equals(TypeGroupe.PARTITION)){
throw new IllegalArgumentException("Impossible de créer une partition à ce niveau. Il faut soit repartitionner le groupe au dessus, soit partitionner une partition en dessous.");
}
if ( n <= 0){
throw new IllegalArgumentException("Le nombre de partitions doit être strictement positif");
}
//Création de la racine de la partition.
Groupe copiePereRacinePartition = new GroupeNP(pere);
pere.addSousGroupe(copiePereRacinePartition);
this.brain.put(Integer.valueOf(copiePereRacinePartition.getId()),copiePereRacinePartition);
// création des sous-groupes
int min = 0;
int max = ((int) Math.floor(pere.getSize()/n))+1;
List<Groupe> groupes = new ArrayList<Groupe>(n);
for(int i = 0; i<n; i++){
Groupe g = new GroupeNP(copiePereRacinePartition,name+"_"+i,min,max);
groupes.add(i,g);// ajout dans le tableau des groupes
copiePereRacinePartition.addSousGroupe(g);
this.brain.put(Integer.valueOf(g.getId()),g);
}
// Partage des étudiants (on ne prête pas attention aux min et max)
int i=0;
for (Etudiant s: pere.getEtudiants()){
copiePereRacinePartition.addEtudiant(s);
groupes.get(i).addEtudiant(s);
i = (i+1) %n;
}
}
/**
* permet d'ajouter un étudiant à un groupe.
*
* @param g le groupe dans lequel il faut ajouter l'étudiant
* @param e l'étudiant à ajouter
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
* @throws java.lang.IllegalStateException le père de g ne contient pas e
*/
public void addToGroupe(Groupe g, Etudiant e){
Objects.requireNonNull(g,"Le groupe ne peut pas être null");
Objects.requireNonNull(e,"L'étudiant ne peut pas être null");
if (!this.knows(g)){
throw new IllegalArgumentException("Impossible d'ajouter l'étudiant car le est groupe inconnu");
}
g.addEtudiant(e);
}
/**
* permet d'enlever un étudiant d'un groupe.
*
* @param g le groupe dans lequel il faut enlever l'étudiant
* @param e l'étudiant à enlever
*
* @throws java.lang.NullPointerException si un argument est null
* @throws java.lang.IllegalStateException g ne contient pas e
* @throws java.lang.IllegalArgumentException la factory ne connaît pas g
*/
public void dropFromGroupe(Groupe g, Etudiant e){
Objects.requireNonNull(g,"Le groupe ne peut pas être null");
Objects.requireNonNull(e,"L'étudiant ne peut pas être null");
if (!this.knows(g)){
throw new IllegalArgumentException("Impossible d'ajouter l'étudiant car le est groupe inconnu");
}
g.removeEtudiant(e);
}
/**
* permet de retrouver un étudiant à partir d'un String.
*
* NB. dans une version simple il doit s'agir du nom exact.
* dans une version un peu plus complexe, il s'agit des premières lettres du nom
* dans une version avancée, on peut autoriser une expression régulière plus ou moins complexe qui est générée si la première recherche n'a pas renvoyé de candidat.
*
* @param String nomEtu le nom approximmatif de l'étudiant
* @return Set<Etudiant> l'ensemble des étudiants connus de la factory ayant un nom "proche" de ce string au sens de la remarque ci-dessus.
*
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Etudiant> getEtudiants(String nomEtu){
// on cherche bêtement dans la promo.
Set<Etudiant> out = new LinkedHashSet<Etudiant>();
for (Etudiant e : getPromotion().getEtudiants()){
if (e.getNom().equals(nomEtu)){
out.add(e);
break;
}
}
return out;
}
/**
* permet de retrouver les groupes d'un étudiant.
*
* @param Etu un étudiant
* @return Etudiant l'étudiant connu de la factory ayant cet identifiant
*
* @throws java.lang.NullPointerException si le String est null.
*/
public Set<Groupe> getGroupesOfEtudiant(Etudiant etu){
throw new UnsupportedOperationException("pas encore implanté");
}
}

128
src/MNP/ChangementNP.java
View File

@@ -1,64 +1,64 @@
package MNP;
import API.*;
import java.util.*;
/**
* Une demande de changement de groupe
* concerne un étudiant, qui est dans un groupe A et veut aller dans un groupe B.
*
* Implémentation non persistante fournie avec l'API.
*/
public class ChangementNP implements Changement {
//auto-incrément des changements
private static int nextId=0;
private int id;
private Groupe a,b;
private Etudiant e;
public ChangementNP(Groupe a, Etudiant e, Groupe b){
Objects.requireNonNull(a,"On ne peut pas créer un changement avec un groupe à quitter null");
Objects.requireNonNull(b,"On ne peut pas créer un changement avec un groupe à rejoindre null");
Objects.requireNonNull(e,"On ne peut pas créer un changement concernant un étudiant null");
this.id=++this.nextId;
this.a=a;
this.b=b;
this.e=e;
}
/**
* permet de récupérer l'identifiant du changement (référence interne sans intérêt irl).
* @return l'identifiant.
*/
public int getId(){
return this.id;
}
/**
* permet de récupérer le groupe de depart
* @return ce groupe.
*/
public Groupe getA(){
return this.a;
}
/**
* permet de récupérer le groupe d'arrivée
* @return ce groupe.
*/
public Groupe getB(){
return this.b;
}
/**
* permet de récupérer l'étudiant demandant le changement
* @return cet étudiant
*/
public Etudiant getEtu(){
return this.e;
}
}
package MNP;
import API.*;
import java.util.*;
/**
* Une demande de changement de groupe
* concerne un étudiant, qui est dans un groupe A et veut aller dans un groupe B.
*
* Implémentation non persistante fournie avec l'API.
*/
public class ChangementNP implements Changement {
//auto-incrément des changements
private static int nextId=0;
private int id;
private Groupe a,b;
private Etudiant e;
public ChangementNP(Groupe a, Etudiant e, Groupe b){
Objects.requireNonNull(a,"On ne peut pas créer un changement avec un groupe à quitter null");
Objects.requireNonNull(b,"On ne peut pas créer un changement avec un groupe à rejoindre null");
Objects.requireNonNull(e,"On ne peut pas créer un changement concernant un étudiant null");
this.id=++this.nextId;
this.a=a;
this.b=b;
this.e=e;
}
/**
* permet de récupérer l'identifiant du changement (référence interne sans intérêt irl).
* @return l'identifiant.
*/
public int getId(){
return this.id;
}
/**
* permet de récupérer le groupe de depart
* @return ce groupe.
*/
public Groupe getA(){
return this.a;
}
/**
* permet de récupérer le groupe d'arrivée
* @return ce groupe.
*/
public Groupe getB(){
return this.b;
}
/**
* permet de récupérer l'étudiant demandant le changement
* @return cet étudiant
*/
public Etudiant getEtu(){
return this.e;
}
}

120
src/MNP/EtudiantNP.java
View File

@@ -1,60 +1,60 @@
package MNP;
import API.*;
import java.util.*;
/**
* Un étudiant
*/
public class EtudiantNP implements Etudiant{
private static int nextId=0;
private int id, groupe;
private String nom, prenom;
/**
* Constructeur. (modification apporter par le groupe pour accueillir un nouveau parametre : groupe)
*/
public EtudiantNP(String nom, String prenom, int groupe){
Objects.requireNonNull(nom,"On ne peut pas créer un étudiant avec un nom null");
Objects.requireNonNull(prenom,"On ne peut pas créer un étudiant avec un nom null");
// auto incrément de l'id
this.id=++this.nextId;
this.groupe = groupe;
this.nom=nom;
this.prenom=prenom;
}
/**
* permet de récupérer l'identifiant de l'étudiant.
* @return l'identifiant.
*/
public int getId(){
return this.id;
}
/**
* permet de récupérer
* @return le nom de l'étudiant.
*/
public String getNom(){
return this.nom;
}
/**
* permet de récupérer
* @return le prénom de l'étudiant
*/
public String getPrenom(){
return this.prenom;
}
/**
* Ajout de l'equipe pour recuperer son groupe
*
* @return Le groupe en entier
* */
public int getGroupe() {
return this.groupe;
}
}
package MNP;
import API.*;
import java.util.*;
/**
* Un étudiant
*/
public class EtudiantNP implements Etudiant{
private static int nextId=0;
private int id, groupe;
private String nom, prenom;
/**
* Constructeur. (modification apporter par le groupe pour accueillir un nouveau parametre : groupe)
*/
public EtudiantNP(String nom, String prenom, int groupe){
Objects.requireNonNull(nom,"On ne peut pas créer un étudiant avec un nom null");
Objects.requireNonNull(prenom,"On ne peut pas créer un étudiant avec un nom null");
// auto incrément de l'id
this.id=++this.nextId;
this.groupe = groupe;
this.nom=nom;
this.prenom=prenom;
}
/**
* permet de récupérer l'identifiant de l'étudiant.
* @return l'identifiant.
*/
public int getId(){
return this.id;
}
/**
* permet de récupérer
* @return le nom de l'étudiant.
*/
public String getNom(){
return this.nom;
}
/**
* permet de récupérer
* @return le prénom de l'étudiant
*/
public String getPrenom(){
return this.prenom;
}
/**
* Ajout de l'equipe pour recuperer son groupe
*
* @return Le groupe en entier
* */
public int getGroupe() {
return this.groupe;
}
}

386
src/MNP/GroupeNP.java
View File

@@ -1,193 +1,193 @@
package MNP;
import API.*;
import java.util.*;
/**
* Un groupe
*/
public class GroupeNP implements Groupe {
//auto-incrément des groupes. (NB. inutile, mais ça fair un exemple d'attribut statique).
private static int nextId=0;
// attributs naturels induits par getter de l'interface Groupe
private int id;
private String name;
private int min,max;
private TypeGroupe type;
private Groupe pointPoint;
// On utilise une interface set pour les sous-groupes et pour les membres (ce sont bien des ensembles en pratique).
private Set<Groupe> sousGroupes;
private Set<Etudiant> membresDuGroupe;
/**
* Nouveau groupe vide de type ROOT sans étudiants, sans sous-Groupe
*/
public GroupeNP(int id, String name, int min, int max){
Objects.requireNonNull(name,"On ne peut pas créer un groupe dont le nom est null");
this.id=id;
this.name=name;
this.min=min;
this.max=max;
this.type=TypeGroupe.ROOT;
this.pointPoint=this;
this.sousGroupes=new LinkedHashSet<Groupe>();
this.membresDuGroupe=new LinkedHashSet<Etudiant>();
}
/**
* Nouveau groupe vide de type FREE sans étudiants, sans sous-Groupe
*/
public GroupeNP(Groupe pere, String name, int min, int max){
Objects.requireNonNull(pere,"On ne peut pas créer un groupe dont le père est null");
Objects.requireNonNull(name,"On ne peut pas créer un groupe dont le nom est null");
this.id=++this.nextId;
this.name=name;
this.min=min;
this.max=max;
this.type=TypeGroupe.FREE;
this.pointPoint=pere;
this.sousGroupes=new LinkedHashSet<Groupe>();
this.membresDuGroupe=new LinkedHashSet<Etudiant>();
}
/**
* Nouveau groupe de type PARTITION dupliquant le groupe passé en paramètre (pour servir de racine à une partition de ce groupe de type FREE passé en paramètre).
*
*/
public GroupeNP(Groupe pere){
Objects.requireNonNull(pere,"On ne peut pas créer un groupe dont le père est null");
this.id=++this.nextId;
this.name=pere.getName()+"_PARTITION_"+ this.id;
this.min=pere.getMin();
this.max=pere.getMax();
this.type=TypeGroupe.PARTITION;
this.pointPoint=pere;
this.sousGroupes= new LinkedHashSet<Groupe>();
this.membresDuGroupe= pere.getEtudiants();
}
/**
* Ajoute un étudiant. Se comporte comme add de l'interface Set.
*
* @return true iff e est ajouté
*/
public boolean addEtudiant(Etudiant e){
Objects.requireNonNull(e,"On ne peut pas ajouter un Étudiant qui est null");
return this.membresDuGroupe.add(e);
}
/**
* Enlève un étudiant. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
public boolean removeEtudiant(Etudiant e){
Objects.requireNonNull(e,"On ne peut pas enlever un Étudiant qui est null");
return this.membresDuGroupe.remove(e);
}
/**
* Ajoute un sous-groupe. Se comporte comme add de l'interface Set.
* vérifie que le groupe passé en argument a bien renseigné this comme son père.
*
* @return true iff g est ajouté
*/
public boolean addSousGroupe(Groupe g){
Objects.requireNonNull(g,"On ne peut pas ajouter un sous-groupe qui est null");
if (this.equals(g.getPointPoint()))
return this.sousGroupes.add(g);
else throw new IllegalArgumentException("on ne peut pas ajouter un sous-groupe ont le père n'est pas this");
}
/**
* Enlève un groupe. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
public boolean removeSousGroupe(Groupe g){
Objects.requireNonNull(g,"On ne peut pas enlever un Étudiant qui est null");
return this.sousGroupes.remove(g);
}
/**
* permet de récupérer l'identifiant d'un groupe (référence interne sans intérêt irl).
* @return l'identifiant.
*/
public int getId(){
return this.id;
}
/**
* permet de récupérer le nom d'un groupe (utile irl).
* @return le nom.
*/
public String getName(){
return this.name;
}
/**
* permet de récupérer le nombre minimum d'étudiants souhaités dans le groupe.
* @return le minimum souhaité
*/
public int getMin(){
return this.min;
}
/**
* permet de récupérer le nombre maximum d'étudiants souhaités dans un groupe.
* @return le maximum souhaité
*/
public int getMax(){
return this.max;
}
/**
* permet de récupérer le nombre d'étudiants dans ce groupe.
* @return le nombre de places prises (pas forcément limité entre Min et Max, mais c'est le but)
*/
public int getSize(){
return this.membresDuGroupe.size();
}
/**
* permet de récupérer la nature du groupe
* @return le type du groupe
*/
public TypeGroupe getType(){
return type;
}
/**
* permet de récupérer le groupe père
* un groupe racine devrait retourner lui-même
*
* @return le père
*/
public Groupe getPointPoint(){
return this.pointPoint;
}
/**
* Potentiellement "vide"
* Attention nous renvoyons l'ensemble sans le copier
*
* @return l'ensemble des sous-groupes.
*/
public Set<Groupe> getSousGroupes(){
return this.sousGroupes;
}
/**
* Potentiellement "vide"
* Attention nous renvoyons l'ensemble sans le copier
*
* @return l'ensemble des étudiants.
*/
public Set<Etudiant> getEtudiants(){
return this.membresDuGroupe;
}
}
package MNP;
import API.*;
import java.util.*;
/**
* Un groupe
*/
public class GroupeNP implements Groupe {
//auto-incrément des groupes. (NB. inutile, mais ça fair un exemple d'attribut statique).
private static int nextId=0;
// attributs naturels induits par getter de l'interface Groupe
private int id;
private String name;
private int min,max;
private TypeGroupe type;
private Groupe pointPoint;
// On utilise une interface set pour les sous-groupes et pour les membres (ce sont bien des ensembles en pratique).
private Set<Groupe> sousGroupes;
private Set<Etudiant> membresDuGroupe;
/**
* Nouveau groupe vide de type ROOT sans étudiants, sans sous-Groupe
*/
public GroupeNP(int id, String name, int min, int max){
Objects.requireNonNull(name,"On ne peut pas créer un groupe dont le nom est null");
this.id=id;
this.name=name;
this.min=min;
this.max=max;
this.type=TypeGroupe.ROOT;
this.pointPoint=this;
this.sousGroupes=new LinkedHashSet<Groupe>();
this.membresDuGroupe=new LinkedHashSet<Etudiant>();
}
/**
* Nouveau groupe vide de type FREE sans étudiants, sans sous-Groupe
*/
public GroupeNP(Groupe pere, String name, int min, int max){
Objects.requireNonNull(pere,"On ne peut pas créer un groupe dont le père est null");
Objects.requireNonNull(name,"On ne peut pas créer un groupe dont le nom est null");
this.id=++this.nextId;
this.name=name;
this.min=min;
this.max=max;
this.type=TypeGroupe.FREE;
this.pointPoint=pere;
this.sousGroupes=new LinkedHashSet<Groupe>();
this.membresDuGroupe=new LinkedHashSet<Etudiant>();
}
/**
* Nouveau groupe de type PARTITION dupliquant le groupe passé en paramètre (pour servir de racine à une partition de ce groupe de type FREE passé en paramètre).
*
*/
public GroupeNP(Groupe pere){
Objects.requireNonNull(pere,"On ne peut pas créer un groupe dont le père est null");
this.id=++this.nextId;
this.name=pere.getName()+"_PARTITION_"+ this.id;
this.min=pere.getMin();
this.max=pere.getMax();
this.type=TypeGroupe.PARTITION;
this.pointPoint=pere;
this.sousGroupes= new LinkedHashSet<Groupe>();
this.membresDuGroupe= pere.getEtudiants();
}
/**
* Ajoute un étudiant. Se comporte comme add de l'interface Set.
*
* @return true iff e est ajouté
*/
public boolean addEtudiant(Etudiant e){
Objects.requireNonNull(e,"On ne peut pas ajouter un Étudiant qui est null");
return this.membresDuGroupe.add(e);
}
/**
* Enlève un étudiant. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
public boolean removeEtudiant(Etudiant e){
Objects.requireNonNull(e,"On ne peut pas enlever un Étudiant qui est null");
return this.membresDuGroupe.remove(e);
}
/**
* Ajoute un sous-groupe. Se comporte comme add de l'interface Set.
* vérifie que le groupe passé en argument a bien renseigné this comme son père.
*
* @return true iff g est ajouté
*/
public boolean addSousGroupe(Groupe g){
Objects.requireNonNull(g,"On ne peut pas ajouter un sous-groupe qui est null");
if (this.equals(g.getPointPoint()))
return this.sousGroupes.add(g);
else throw new IllegalArgumentException("on ne peut pas ajouter un sous-groupe ont le père n'est pas this");
}
/**
* Enlève un groupe. Se comporte comme remove de l'interface Set.
*
* @return true iff e est enlevé
*/
public boolean removeSousGroupe(Groupe g){
Objects.requireNonNull(g,"On ne peut pas enlever un Étudiant qui est null");
return this.sousGroupes.remove(g);
}
/**
* permet de récupérer l'identifiant d'un groupe (référence interne sans intérêt irl).
* @return l'identifiant.
*/
public int getId(){
return this.id;
}
/**
* permet de récupérer le nom d'un groupe (utile irl).
* @return le nom.
*/
public String getName(){
return this.name;
}
/**
* permet de récupérer le nombre minimum d'étudiants souhaités dans le groupe.
* @return le minimum souhaité
*/
public int getMin(){
return this.min;
}
/**
* permet de récupérer le nombre maximum d'étudiants souhaités dans un groupe.
* @return le maximum souhaité
*/
public int getMax(){
return this.max;
}
/**
* permet de récupérer le nombre d'étudiants dans ce groupe.
* @return le nombre de places prises (pas forcément limité entre Min et Max, mais c'est le but)
*/
public int getSize(){
return this.membresDuGroupe.size();
}
/**
* permet de récupérer la nature du groupe
* @return le type du groupe
*/
public TypeGroupe getType(){
return type;
}
/**
* permet de récupérer le groupe père
* un groupe racine devrait retourner lui-même
*
* @return le père
*/
public Groupe getPointPoint(){
return this.pointPoint;
}
/**
* Potentiellement "vide"
* Attention nous renvoyons l'ensemble sans le copier
*
* @return l'ensemble des sous-groupes.
*/
public Set<Groupe> getSousGroupes(){
return this.sousGroupes;
}
/**
* Potentiellement "vide"
* Attention nous renvoyons l'ensemble sans le copier
*
* @return l'ensemble des étudiants.
*/
public Set<Etudiant> getEtudiants(){
return this.membresDuGroupe;
}
}

358
src/Test/BDatabase.java
View File

@@ -1,180 +1,180 @@
package Test;
/* [BPakage.BDatabase]
* Desc: To create Operationnal Database Link fast :)
* GitHub: https://github.com/lalBi94
* Created by: Bilal Boudjemline
* 28/09/2022 at 20:35
* */
import java.sql.*;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import org.mariadb.jdbc.*;
import javax.crypto.spec.PSource;
/**
* <p>Methodes pour les interaction avec une base de donnees</p>
*
* @author <a href="https://github.com/lalBi94">Bilal Boudjemline</a>
*/
public class BDatabase {
private final String db_host;
private final String db_name;
private final String db_user;
private final String db_password;
protected Connection sharedObject;
private boolean status;
public BDatabase() {
this.db_host = "jdbc:mariadb://dwarves.iut-fbleau.fr/";
this.db_name = "brinet";
this.db_user = "brinet";
this.db_password = "Aignan41!";
try {
Class.forName("org.mariadb.jdbc.Driver");
} catch(ClassNotFoundException e) {
e.printStackTrace();
}
try {
this.sharedObject = DriverManager.getConnection(this.db_host + this.db_name, this.db_user, this.db_password);
this.status = true;
} catch (SQLException e) {
System.out.println("Erreur de liaison avec la base de donnees.");
}
}
/**
* Recuperer les informations d'un requete de type SELECT.
*
* @param request Le SELECT a faire (il y aura plus d'argument prochainement)
* @return Les resultats engendre par la requete
*/
public ArrayList<String> fetchAll(String request) {
try {
ArrayList<String> toReturn = new ArrayList<String>();
ResultSet rs = this.sharedObject.prepareStatement(request).executeQuery();
for(int i = 0; rs.next(); i++) {
toReturn.add(i, String.valueOf(rs.getString(1)));
}
return toReturn;
} catch(SQLException e) {
System.out.println("Erreur de la requete : " + e);
return null;
}
}
/**
* Insert une ligne dans une table.
*
* @param table La table
* @param col Tableau qui contient les colonnes d'affectation
* @param value Valeur des colonnes
* @return Retourne true si ca a reussit et false dans le cas inverse
*/
public boolean insertRow(String table, String[] col, String[] value) {
StringBuilder collumns = new StringBuilder();
StringBuilder values = new StringBuilder();
Iterator<String> iteCol = Arrays.stream(col).iterator();
Iterator<String> iteVal = Arrays.stream(value).iterator();
collumns.append("(");
while(iteCol.hasNext()) {
collumns.append(iteCol.next()).append(", ");
}
collumns.setLength(collumns.length()-2);
collumns.append(")");
values.append("(");
while(iteVal.hasNext()) {
values.append("\"").append(iteVal.next()).append("\"").append(", ");
}
values.setLength(values.length()-2);
values.append(")");
String request = "INSERT INTO " + table + collumns + " VALUES" + values + ";";
System.out.println(request);
try {
this.sharedObject.prepareStatement(request).executeQuery();
System.out.println("Succes: " + request);
return true;
} catch(SQLException e) {
return false;
}
}
/**
* Faire des requetes de type UPDATE SET (il y aura plus d'argument prochainement).
*
* @param request La requete
* @return Si oui ou non ca a fonctionne
*/
public boolean updateRow(String request) {
try {
this.sharedObject.prepareStatement(request).executeQuery();
System.out.println("Succes: " + request);
return true;
} catch(SQLException e) {
return false;
}
}
/**
* Recuperer l'objet Connection pour pouvoir utiliser ses methodes.
*
* @return L 'objet Connection.
*/
public Connection getSharedObject() {
return this.sharedObject;
}
/**
* Recuperer l'utilisateur courant.
*
* @return L 'utilisateur.
*/
public String getUser() {
return this.db_user;
}
/**
* Recuperer l'hote courant.
*
* @return L 'hote.
*/
public String getHost() {
return this.db_host;
}
/**
* Recuperer le nom de la base de donnees.
*
* @return Le nom de la base de donnees.
*/
public String getDatabaseName() {
return this.db_name;
}
/**
* Recuperer le status de connection.
*
* @return Le status de connection.
*/
public boolean getStatus() {
return this.status;
}
@Override
public String toString() {
return this.db_host + "\n" + this.db_name + "\n" + this.db_user + "\n";
}
package Test;
/* [BPakage.BDatabase]
* Desc: To create Operationnal Database Link fast :)
* GitHub: https://github.com/lalBi94
* Created by: Bilal Boudjemline
* 28/09/2022 at 20:35
* */
import java.sql.*;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import org.mariadb.jdbc.*;
import javax.crypto.spec.PSource;
/**
* <p>Methodes pour les interaction avec une base de donnees</p>
*
* @author <a href="https://github.com/lalBi94">Bilal Boudjemline</a>
*/
public class BDatabase {
private final String db_host;
private final String db_name;
private final String db_user;
private final String db_password;
protected Connection sharedObject;
private boolean status;
public BDatabase() {
this.db_host = "jdbc:mariadb://dwarves.iut-fbleau.fr/";
this.db_name = "brinet";
this.db_user = "brinet";
this.db_password = "Aignan41!";
try {
Class.forName("org.mariadb.jdbc.Driver");
} catch(ClassNotFoundException e) {
e.printStackTrace();
}
try {
this.sharedObject = DriverManager.getConnection(this.db_host + this.db_name, this.db_user, this.db_password);
this.status = true;
} catch (SQLException e) {
System.out.println("Erreur de liaison avec la base de donnees.");
}
}
/**
* Recuperer les informations d'un requete de type SELECT.
*
* @param request Le SELECT a faire (il y aura plus d'argument prochainement)
* @return Les resultats engendre par la requete
*/
public ArrayList<String> fetchAll(String request) {
try {
ArrayList<String> toReturn = new ArrayList<String>();
ResultSet rs = this.sharedObject.prepareStatement(request).executeQuery();
for(int i = 0; rs.next(); i++) {
toReturn.add(i, String.valueOf(rs.getString(1)));
}
return toReturn;
} catch(SQLException e) {
System.out.println("Erreur de la requete : " + e);
return null;
}
}
/**
* Insert une ligne dans une table.
*
* @param table La table
* @param col Tableau qui contient les colonnes d'affectation
* @param value Valeur des colonnes
* @return Retourne true si ca a reussit et false dans le cas inverse
*/
public boolean insertRow(String table, String[] col, String[] value) {
StringBuilder collumns = new StringBuilder();
StringBuilder values = new StringBuilder();
Iterator<String> iteCol = Arrays.stream(col).iterator();
Iterator<String> iteVal = Arrays.stream(value).iterator();
collumns.append("(");
while(iteCol.hasNext()) {
collumns.append(iteCol.next()).append(", ");
}
collumns.setLength(collumns.length()-2);
collumns.append(")");
values.append("(");
while(iteVal.hasNext()) {
values.append("\"").append(iteVal.next()).append("\"").append(", ");
}
values.setLength(values.length()-2);
values.append(")");
String request = "INSERT INTO " + table + collumns + " VALUES" + values + ";";
System.out.println(request);
try {
this.sharedObject.prepareStatement(request).executeQuery();
System.out.println("Succes: " + request);
return true;
} catch(SQLException e) {
return false;
}
}
/**
* Faire des requetes de type UPDATE SET (il y aura plus d'argument prochainement).
*
* @param request La requete
* @return Si oui ou non ca a fonctionne
*/
public boolean updateRow(String request) {
try {
this.sharedObject.prepareStatement(request).executeQuery();
System.out.println("Succes: " + request);
return true;
} catch(SQLException e) {
return false;
}
}
/**
* Recuperer l'objet Connection pour pouvoir utiliser ses methodes.
*
* @return L 'objet Connection.
*/
public Connection getSharedObject() {
return this.sharedObject;
}
/**
* Recuperer l'utilisateur courant.
*
* @return L 'utilisateur.
*/
public String getUser() {
return this.db_user;
}
/**
* Recuperer l'hote courant.
*
* @return L 'hote.
*/
public String getHost() {
return this.db_host;
}
/**
* Recuperer le nom de la base de donnees.
*
* @return Le nom de la base de donnees.
*/
public String getDatabaseName() {
return this.db_name;
}
/**
* Recuperer le status de connection.
*
* @return Le status de connection.
*/
public boolean getStatus() {
return this.status;
}
@Override
public String toString() {
return this.db_host + "\n" + this.db_name + "\n" + this.db_user + "\n";
}
}

346
src/Test/BFrame.java
View File

@@ -1,174 +1,174 @@
package Test;
/* [BPackage.BFrame]
* Desc: To create Operationnal JFrame with utils methods fast :)
* GitHub: https://github.com/lalBi94
* Created by: Bilal Boudjemline
* 28/09/2022 at 20:35
* */
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.ImageIcon;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.event.WindowEvent;
/**
* <p>Pour creer une fenetre rapidement avec les methodes simplifier</p>
*
* @author <a href="https://github.com/lalBi94">Bilal Boudjemline</a>
*/
public class BFrame extends JFrame {
private final String title;
private int location_x = 1;
private int location_y = 1;
private int width = 500;
private int height = 500;
private int killProcess = 3;
private boolean isOpen = false;
/**
* Avec le titre et mode de fermeture.
*
* @param title Le titre de la fenetre
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String title, int oC) {
this.title = title;
this.killProcess = oC;
initBFrame();
}
/**
* Avec le titre, la taille (en L et l) et mode de fermeture.
*
* @param titlee Le titre de la fenetre
* @param size_x La longueur de la fenetre
* @param size_y La largeur y de la fenetre
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String titlee, int size_x, int size_y, int oC) {
this.title = titlee;
this.width = size_x;
this.height = size_y;
this.killProcess = oC;
initBFrame();
}
/**
* Avec le titre, la locasation (en x et y), la taille (en L et l) et mode de fermeture.
*
* @param title Le titre de la fenetre
* @param loca_x La localisation en x de la fenetre
* @param loca_y La localisation en y de la fenetre
* @param size_x La longueur de la fenetre
* @param size_y La largeur de la fenetre
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String title, int loca_x, int loca_y, int size_x, int size_y, int oC) {
this.title = title;
this.location_x = loca_x;
this.location_y = loca_y;
this.width = size_x;
this.height = size_y;
this.killProcess = oC;
initBFrame();
}
/**
* Avec le titre, la locasation (en x et y), la taille (en L et l), le layout et le mode de fermeture.
*
* @param title Le titre de la fenetre
* @param loca_x La localisation en x de la fenetre
* @param loca_y La localisation en y de la fenetre
* @param size_x La longueur de la fenetre
* @param size_y La largeur de la fenetre
* @param layout Layout a utiliser dispo : GridBagLayout / GridLayout
* @param layout_row the layout row
* @param layout_col the layout col
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String title, int loca_x, int loca_y, int size_x, int size_y, String layout, int layout_row, int layout_col, int oC) {
this.title = title;
this.location_x = loca_x;
this.location_y = loca_y;
this.width = size_x;
this.height = size_y;
this.killProcess = oC;
initBFrame(layout, layout_row, layout_col);
}
/**
* Initialiser la fenetre sans Layout par def.
*/
protected void initBFrame() {
ImageIcon icon = new ImageIcon("assets/logo.png");
this.setTitle(this.title);
this.setLocation(this.location_x, this.location_y);
this.setSize(this.width, this.height);
this.setLayout(new GridBagLayout());
this.setIconImage(icon.getImage());
this.setDefaultCloseOperation(this.killProcess);
}
/**
* Initialiser la fenetre avec Layout
*
* @param layout the layout
* @param row the row
* @param col the col
*/
protected void initBFrame(String layout, int row, int col) {
ImageIcon icon = new ImageIcon("assets/logo.png");
this.setTitle(this.title);
this.setLocation(this.location_x, this.location_y);
this.setSize(this.width, this.height);
if(layout == "GridLayout") {
this.setLayout(new GridLayout(row, col));
} else {
System.out.println("Un layout doit etre fourni.");
}
this.setIconImage(icon.getImage());
this.setDefaultCloseOperation(this.killProcess);
}
/**
* Ouvrir la fenetre
*/
public void openBFrame() {
this.isOpen = true;
this.setVisible(true);
}
/**
* Fermer la fenetre
*/
public void closeBFrame() {
this.isOpen = false;
this.setVisible(false);
this.dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_CLOSING));
}
/**
* Rafraichir la fenetre
*/
public void refreshBFrame() {
SwingUtilities.updateComponentTreeUI(this);
}
/**
* Statut de visibilite de la fenetre
*/
public boolean isVisible() {
return this.isOpen;
}
@Override
public String toString() {
return this.title + ": is opened";
}
package Test;
/* [BPackage.BFrame]
* Desc: To create Operationnal JFrame with utils methods fast :)
* GitHub: https://github.com/lalBi94
* Created by: Bilal Boudjemline
* 28/09/2022 at 20:35
* */
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.ImageIcon;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.event.WindowEvent;
/**
* <p>Pour creer une fenetre rapidement avec les methodes simplifier</p>
*
* @author <a href="https://github.com/lalBi94">Bilal Boudjemline</a>
*/
public class BFrame extends JFrame {
private final String title;
private int location_x = 1;
private int location_y = 1;
private int width = 500;
private int height = 500;
private int killProcess = 3;
private boolean isOpen = false;
/**
* Avec le titre et mode de fermeture.
*
* @param title Le titre de la fenetre
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String title, int oC) {
this.title = title;
this.killProcess = oC;
initBFrame();
}
/**
* Avec le titre, la taille (en L et l) et mode de fermeture.
*
* @param titlee Le titre de la fenetre
* @param size_x La longueur de la fenetre
* @param size_y La largeur y de la fenetre
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String titlee, int size_x, int size_y, int oC) {
this.title = titlee;
this.width = size_x;
this.height = size_y;
this.killProcess = oC;
initBFrame();
}
/**
* Avec le titre, la locasation (en x et y), la taille (en L et l) et mode de fermeture.
*
* @param title Le titre de la fenetre
* @param loca_x La localisation en x de la fenetre
* @param loca_y La localisation en y de la fenetre
* @param size_x La longueur de la fenetre
* @param size_y La largeur de la fenetre
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String title, int loca_x, int loca_y, int size_x, int size_y, int oC) {
this.title = title;
this.location_x = loca_x;
this.location_y = loca_y;
this.width = size_x;
this.height = size_y;
this.killProcess = oC;
initBFrame();
}
/**
* Avec le titre, la locasation (en x et y), la taille (en L et l), le layout et le mode de fermeture.
*
* @param title Le titre de la fenetre
* @param loca_x La localisation en x de la fenetre
* @param loca_y La localisation en y de la fenetre
* @param size_x La longueur de la fenetre
* @param size_y La largeur de la fenetre
* @param layout Layout a utiliser dispo : GridBagLayout / GridLayout
* @param layout_row the layout row
* @param layout_col the layout col
* @param oC Mode de fermeture de la fenetre
*/
public BFrame(String title, int loca_x, int loca_y, int size_x, int size_y, String layout, int layout_row, int layout_col, int oC) {
this.title = title;
this.location_x = loca_x;
this.location_y = loca_y;
this.width = size_x;
this.height = size_y;
this.killProcess = oC;
initBFrame(layout, layout_row, layout_col);
}
/**
* Initialiser la fenetre sans Layout par def.
*/
protected void initBFrame() {
ImageIcon icon = new ImageIcon("assets/logo.png");
this.setTitle(this.title);
this.setLocation(this.location_x, this.location_y);
this.setSize(this.width, this.height);
this.setLayout(new GridBagLayout());
this.setIconImage(icon.getImage());
this.setDefaultCloseOperation(this.killProcess);
}
/**
* Initialiser la fenetre avec Layout
*
* @param layout the layout
* @param row the row
* @param col the col
*/
protected void initBFrame(String layout, int row, int col) {
ImageIcon icon = new ImageIcon("assets/logo.png");
this.setTitle(this.title);
this.setLocation(this.location_x, this.location_y);
this.setSize(this.width, this.height);
if(layout == "GridLayout") {
this.setLayout(new GridLayout(row, col));
} else {
System.out.println("Un layout doit etre fourni.");
}
this.setIconImage(icon.getImage());
this.setDefaultCloseOperation(this.killProcess);
}
/**
* Ouvrir la fenetre
*/
public void openBFrame() {
this.isOpen = true;
this.setVisible(true);
}
/**
* Fermer la fenetre
*/
public void closeBFrame() {
this.isOpen = false;
this.setVisible(false);
this.dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_CLOSING));
}
/**
* Rafraichir la fenetre
*/
public void refreshBFrame() {
SwingUtilities.updateComponentTreeUI(this);
}
/**
* Statut de visibilite de la fenetre
*/
public boolean isVisible() {
return this.isOpen;
}
@Override
public String toString() {
return this.title + ": is opened";
}
}

342
src/Test/BLayout.java
View File

@@ -1,171 +1,171 @@
package Test;
/* [BPakage.BLayout]
* Desc: To create a layout fast :)
* GitHub: https://github.com/lalBi94
* Created by: Bilal Boudjemline
* 28/09/2022 at 20:35
* */
import java.awt.GridBagConstraints;
import java.awt.Insets;
/**
* <p>Pour creer un layout de type GridBagLayout rapidement avec les methodes simplifier.</p>
*
* @author <a href="https://github.com/lalBi94">Bilal Boudjemline</a>
*/
public class BLayout extends GridBagConstraints {
public int PositionOnX = 0;
public int PositionOnY = 0;
public int takeCaseOnX = 1;
public int takeCaseOnY = 1;
public double sizeOnX = 0.0f;
public double sizeOnY = 0.0f;
public int padding_top = 1;
public int padding_left = 1;
public int padding_bottom = 1;
public int padding_right = 1;
public Insets padding = new Insets(this.padding_top, this.padding_left, this.padding_bottom, this.padding_right);
public int positionOnScreen = GridBagConstraints.NORTH;
public int filler = GridBagConstraints.BASELINE;
public BLayout() {
initLayout();
}
/**
* @param positionX Position en X.
* @param positionY Position en y.
* @param manyCaseX Combien le component prend de case en x.
* @param manyCaseY Combien le component prend de case en y.
* @param sizeX Taille en double en x.
* @param sizeY Taille en double en y.
* @param pad Le padding.
* @param positionOnScreen La position sur la frame (centre, north etc...).
* @param filling Remplissage (H, V, B).
*/
public BLayout(int positionX, int positionY, int manyCaseX, int manyCaseY, double sizeX,
double sizeY, Insets pad, int positionOnScreen, int filling) {
this.PositionOnX = positionX;
this.PositionOnY = positionY;
this.takeCaseOnX = manyCaseX;
this.takeCaseOnY = manyCaseY;
this.sizeOnX = sizeX;
this.sizeOnY = sizeY;
this.padding_top = pad.top;
this.padding_left = pad.left;
this.padding_bottom = pad.bottom;
this.padding_right = pad.right;
this.padding = pad;
this.positionOnScreen = positionOnScreen;
this.filler = filling;
initLayout();
}
/**
* Initialiser le layout pour le changer dans GridBagConstraint (Valeur attribuer par def.).
* */
private void initLayout() {
this.gridx = this.PositionOnX;
this.gridy = this.PositionOnY;
this.gridheight = this.takeCaseOnX;
this.gridwidth = this.takeCaseOnY;
this.weightx = this.sizeOnX;
this.weighty = this.sizeOnY;
this.insets = this.padding;
this.anchor = this.positionOnScreen;
this.fill = this.filler;
}
/**
* Changer le cuseur en x.
*
* @param by par quoi
*/
public void setPositionX(int by) {
this.PositionOnX = by;
initLayout();
}
/**
* Changer le cuseur en y.
*
* @param by par quoi
*/
public void setPositionY(int by) {
this.PositionOnY = by;
initLayout();
}
/**
* Changer la place occupe en x.
*
* @param by par quoi
*/
public void setTakeCaseOnX(int by) {
this.takeCaseOnX = by;
initLayout();
}
/**
* Changer la place occupe en y.
*
* @param by par quoi
*/
public void setTakeCaseOnY(int by) {
this.takeCaseOnY = by;
initLayout();
}
/**
* Mettre sa taille en x.
*
* @param by par quoi
*/
public void setSizeX(double by) {
this.sizeOnX = by;
initLayout();
}
/**
* Mettre sa taille en y.
*
* @param by par quoi
*/
public void setSizeY(double by) {
this.sizeOnY = by;
initLayout();
}
/**
* Mettre un padding.
*
* @param by par quoi
*/
public void setPadding(Insets by) {
this.padding = by;
initLayout();
}
/**
* Mettre une ancre.
*
* @param by par quoi
*/
public void setAnchor(int by) {
this.positionOnScreen = by;
initLayout();
}
/**
* Mettre un remplissage.
*
* @param by par quoi
*/
public void setFill(int by) {
this.filler = by;
initLayout();
}
}
package Test;
/* [BPakage.BLayout]
* Desc: To create a layout fast :)
* GitHub: https://github.com/lalBi94
* Created by: Bilal Boudjemline
* 28/09/2022 at 20:35
* */
import java.awt.GridBagConstraints;
import java.awt.Insets;
/**
* <p>Pour creer un layout de type GridBagLayout rapidement avec les methodes simplifier.</p>
*
* @author <a href="https://github.com/lalBi94">Bilal Boudjemline</a>
*/
public class BLayout extends GridBagConstraints {
public int PositionOnX = 0;
public int PositionOnY = 0;
public int takeCaseOnX = 1;
public int takeCaseOnY = 1;
public double sizeOnX = 0.0f;
public double sizeOnY = 0.0f;
public int padding_top = 1;
public int padding_left = 1;
public int padding_bottom = 1;
public int padding_right = 1;
public Insets padding = new Insets(this.padding_top, this.padding_left, this.padding_bottom, this.padding_right);
public int positionOnScreen = GridBagConstraints.NORTH;
public int filler = GridBagConstraints.BASELINE;
public BLayout() {
initLayout();
}
/**
* @param positionX Position en X.
* @param positionY Position en y.
* @param manyCaseX Combien le component prend de case en x.
* @param manyCaseY Combien le component prend de case en y.
* @param sizeX Taille en double en x.
* @param sizeY Taille en double en y.
* @param pad Le padding.
* @param positionOnScreen La position sur la frame (centre, north etc...).
* @param filling Remplissage (H, V, B).
*/
public BLayout(int positionX, int positionY, int manyCaseX, int manyCaseY, double sizeX,
double sizeY, Insets pad, int positionOnScreen, int filling) {
this.PositionOnX = positionX;
this.PositionOnY = positionY;
this.takeCaseOnX = manyCaseX;
this.takeCaseOnY = manyCaseY;
this.sizeOnX = sizeX;
this.sizeOnY = sizeY;
this.padding_top = pad.top;
this.padding_left = pad.left;
this.padding_bottom = pad.bottom;
this.padding_right = pad.right;
this.padding = pad;
this.positionOnScreen = positionOnScreen;
this.filler = filling;
initLayout();
}
/**
* Initialiser le layout pour le changer dans GridBagConstraint (Valeur attribuer par def.).
* */
private void initLayout() {
this.gridx = this.PositionOnX;
this.gridy = this.PositionOnY;
this.gridheight = this.takeCaseOnX;
this.gridwidth = this.takeCaseOnY;
this.weightx = this.sizeOnX;
this.weighty = this.sizeOnY;
this.insets = this.padding;
this.anchor = this.positionOnScreen;
this.fill = this.filler;
}
/**
* Changer le cuseur en x.
*
* @param by par quoi
*/
public void setPositionX(int by) {
this.PositionOnX = by;
initLayout();
}
/**
* Changer le cuseur en y.
*
* @param by par quoi
*/
public void setPositionY(int by) {
this.PositionOnY = by;
initLayout();
}
/**
* Changer la place occupe en x.
*
* @param by par quoi
*/
public void setTakeCaseOnX(int by) {
this.takeCaseOnX = by;
initLayout();
}
/**
* Changer la place occupe en y.
*
* @param by par quoi
*/
public void setTakeCaseOnY(int by) {
this.takeCaseOnY = by;
initLayout();
}
/**
* Mettre sa taille en x.
*
* @param by par quoi
*/
public void setSizeX(double by) {
this.sizeOnX = by;
initLayout();
}
/**
* Mettre sa taille en y.
*
* @param by par quoi
*/
public void setSizeY(double by) {
this.sizeOnY = by;
initLayout();
}
/**
* Mettre un padding.
*
* @param by par quoi
*/
public void setPadding(Insets by) {
this.padding = by;
initLayout();
}
/**
* Mettre une ancre.
*
* @param by par quoi
*/
public void setAnchor(int by) {
this.positionOnScreen = by;
initLayout();
}
/**
* Mettre un remplissage.
*
* @param by par quoi
*/
public void setFill(int by) {
this.filler = by;
initLayout();
}
}

578
src/Test/ProfView.java
View File

File diff suppressed because it is too large Load Diff

142
src/Test/TestTexteMNP.java
View File

@@ -1,71 +1,71 @@
package Test;
import API.*;
import MNP.*;
import java.util.ArrayList;
public class TestTexteMNP {
public static void main(String[] args) {
/**
* Objet de la base de donnee contenant des methodes utile a notre developpement
* */
BDatabase bd = new BDatabase();
/**
* Chargement des eleves
* */
ArrayList<Etudiant> listEtu = new ArrayList<>();
ArrayList<String> studPrenom = bd.fetchAll("SELECT prenom FROM fi_eleves");
ArrayList<String> studNom = bd.fetchAll("SELECT nom FROM fi_eleves");
ArrayList<String> studGroupe = bd.fetchAll("SELECT groupe FROM fi_eleves");
for(int i = 0; i <= studPrenom.size()-1; i++) {
if(studPrenom.get(i) != null && studNom.get(i) != null && studGroupe.get(i) != null) {
listEtu.add(
new EtudiantNP(
studNom.get(i),
studPrenom.get(i),
Integer.parseInt(studGroupe.get(i), 10)
)
);
} else {
System.out.println("[!] Erreur lors du chargement de la liste des etudiants.");
System.exit(-1);
}
}
System.out.println("[+] Liste des etudiants chargees.");
/**
* Chargement des groupes
* */
ArrayList<Groupe> listGroupe = new ArrayList<>();
ArrayList<String> groupeId = bd.fetchAll("SELECT id FROM fi_groupe");
ArrayList<String> groupeNom = bd.fetchAll("SELECT nom FROM fi_groupe");
ArrayList<String> groupeMin = bd.fetchAll("SELECT min FROM fi_groupe");
ArrayList<String> groupeMax = bd.fetchAll("SELECT max FROM fi_groupe");
for(int i = 0; i <= groupeNom.size()-1; i++) {
if(groupeId.get(i) != null && groupeNom.get(i) != null && groupeMin.get(i) != null && groupeMax.get(i) != null) {
listGroupe.add(
new GroupeNP(
Integer.parseInt(groupeId.get(i), 10),
groupeNom.get(i),
Integer.parseInt(groupeMin.get(i), 10),
Integer.parseInt(groupeMax.get(i), 10)
)
);
} else {
System.out.println("[!] Erreur lors du chargement de la liste des groupes.");
System.exit(-1);
}
}
System.out.println("[+] Liste des groupes chargees.");
/**
* Redirection vers ProfView (vue professeur)
* */
new ProfView(listEtu, listGroupe, bd);
}
}
package Test;
import API.*;
import MNP.*;
import java.util.ArrayList;
public class TestTexteMNP {
public static void main(String[] args) {
/**
* Objet de la base de donnee contenant des methodes utile a notre developpement
* */
BDatabase bd = new BDatabase();
/**
* Chargement des eleves
* */
ArrayList<Etudiant> listEtu = new ArrayList<>();
ArrayList<String> studPrenom = bd.fetchAll("SELECT prenom FROM fi_eleves");
ArrayList<String> studNom = bd.fetchAll("SELECT nom FROM fi_eleves");
ArrayList<String> studGroupe = bd.fetchAll("SELECT groupe FROM fi_eleves");
for(int i = 0; i <= studPrenom.size()-1; i++) {
if(studPrenom.get(i) != null && studNom.get(i) != null && studGroupe.get(i) != null) {
listEtu.add(
new EtudiantNP(
studNom.get(i),
studPrenom.get(i),
Integer.parseInt(studGroupe.get(i), 10)
)
);
} else {
System.out.println("[!] Erreur lors du chargement de la liste des etudiants.");
System.exit(-1);
}
}
System.out.println("[+] Liste des etudiants chargees.");
/**
* Chargement des groupes
* */
ArrayList<Groupe> listGroupe = new ArrayList<>();
ArrayList<String> groupeId = bd.fetchAll("SELECT id FROM fi_groupe");
ArrayList<String> groupeNom = bd.fetchAll("SELECT nom FROM fi_groupe");
ArrayList<String> groupeMin = bd.fetchAll("SELECT min FROM fi_groupe");
ArrayList<String> groupeMax = bd.fetchAll("SELECT max FROM fi_groupe");
for(int i = 0; i <= groupeNom.size()-1; i++) {
if(groupeId.get(i) != null && groupeNom.get(i) != null && groupeMin.get(i) != null && groupeMax.get(i) != null) {
listGroupe.add(
new GroupeNP(
Integer.parseInt(groupeId.get(i), 10),
groupeNom.get(i),
Integer.parseInt(groupeMin.get(i), 10),
Integer.parseInt(groupeMax.get(i), 10)
)
);
} else {
System.out.println("[!] Erreur lors du chargement de la liste des groupes.");
System.exit(-1);
}
}
System.out.println("[+] Liste des groupes chargees.");
/**
* Redirection vers ProfView (vue professeur)
* */
new ProfView(listEtu, listGroupe, bd);
}
}