$
This commit is contained in:
pro.boooooo
@@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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é");
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user