madelaine/BUT2-DEV31-IHM-Public
3
5
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

API partielle

Browse Source
This commit is contained in:
Florent Madelaine 2022-10-19 15:33:42 +02:00
parent 10bd78c4af
commit ec80b6c454
29 changed files with 3055 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

493
java/APIGroupe/LICENSE Normal file
View File

@ -0,0 +1,493 @@
CeCILL FREE SOFTWARE LICENSE AGREEMENT
Version 2.1 dated 2013-06-21 Notice
This Agreement is a Free Software license agreement that is the result of
discussions between its authors in order to ensure compliance with the two
main principles guiding its drafting:
* firstly, compliance with the principles governing the distribution of Free
Software: access to source code, broad rights granted to users,
* secondly, the election of a governing law, French law, with which it is
conformant, both as regards the law of torts and intellectual property law,
and the protection that it offers to both authors and holders of the economic
rights over software.
The authors of the CeCILL¹ license are:
Commissariat à l'énergie atomique et aux énergies alternatives - CEA, a public
scientific, technical and industrial research establishment, having its principal
place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.
Centre National de la Recherche Scientifique - CNRS, a public scientific and
technological establishment, having its principal place of business at 3 rue
Michel-Ange, 75794 Paris cedex 16, France.
Institut National de Recherche en Informatique et en Automatique - Inria,
a public scientific and technological establishment, having its principal
place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay
cedex, France.
Preamble The purpose of this Free Software license agreement is to grant users
the right to modify and redistribute the software governed by this license
within the framework of an open source distribution model.
The exercising of this right is conditional upon certain obligations for users
so as to preserve this status for all subsequent redistributions.
In consideration of access to the source code and the rights to copy, modify
and redistribute granted by the license, users are provided only with a limited
warranty and the software's author, the holder of the economic rights, and
the successive licensors only have limited liability.
In this respect, the risks associated with loading, using, modifying and/or
developing or reproducing the software by the user are brought to the user's
attention, given its Free Software status, which may make it complicated to
use, with the result that its use is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore encouraged
to load and test the suitability of the software as regards their requirements
in conditions enabling the security of their systems and/or data to be ensured
and, more generally, to use and operate it in the same conditions of security.
This Agreement may be freely reproduced and published, provided it is not
altered, and that no provisions are either added or removed herefrom.
This Agreement may apply to any or all software for which the holder of the
economic rights decides to submit the use thereof to its provisions.
Frequently asked questions can be found on the official website of the CeCILL
licenses family (http://www.cecill.info/index.en.html) for any necessary clarification.
Article 1 - DEFINITIONS
For the purpose of this Agreement, when the following expressions commence
with a capital letter, they shall have the following meaning:
Agreement: means this license agreement, and its possible subsequent versions
and annexes.
Software: means the software in its Object Code and/or Source Code form and,
where applicable, its documentation, "as is" when the Licensee accepts the
Agreement.
Initial Software: means the Software in its Source Code and possibly its Object
Code form and, where applicable, its documentation, "as is" when it is first
distributed under the terms and conditions of the Agreement.
Modified Software: means the Software modified by at least one Contribution.
Source Code: means all the Software's instructions and program lines to which
access is required so as to modify the Software.
Object Code: means the binary files originating from the compilation of the
Source Code.
Holder: means the holder(s) of the economic rights over the Initial Software.
Licensee: means the Software user(s) having accepted the Agreement.
Contributor: means a Licensee having made at least one Contribution.
Licensor: means the Holder, or any other individual or legal entity, who distributes
the Software under the Agreement.
Contribution: means any or all modifications, corrections, translations, adaptations
and/or new functions integrated into the Software by any or all Contributors,
as well as any or all Internal Modules.
Module: means a set of sources files including their documentation that enables
supplementary functions or services in addition to those offered by the Software.
External Module: means any or all Modules, not derived from the Software,
so that this Module and the Software run in separate address spaces, with
one calling the other when they are run.
Internal Module: means any or all Module, connected to the Software so that
they both execute in the same address space.
GNU GPL: means the GNU General Public License version 2 or any subsequent
version, as published by the Free Software Foundation Inc.
GNU Affero GPL: means the GNU Affero General Public License version 3 or any
subsequent version, as published by the Free Software Foundation Inc.
EUPL: means the European Union Public License version 1.1 or any subsequent
version, as published by the European Commission.
Parties: mean both the Licensee and the Licensor.
These expressions may be used both in singular and plural form.
Article 2 - PURPOSE
The purpose of the Agreement is the grant by the Licensor to the Licensee
of a non-exclusive, transferable and worldwide license for the Software as
set forth in Article 5 <#scope> hereinafter for the whole term of the protection
granted by the rights over said Software.
Article 3 - ACCEPTANCE
3.1 The Licensee shall be deemed as having accepted the terms and conditions
of this Agreement upon the occurrence of the first of the following events:
(i) loading the Software by any or all means, notably, by downloading from
a remote server, or by loading from a physical medium;
(ii) the first time the Licensee exercises any of the rights granted hereunder.
3.2 One copy of the Agreement, containing a notice relating to the characteristics
of the Software, to the limited warranty, and to the fact that its use is
restricted to experienced users has been provided to the Licensee prior to
its acceptance as set forth in Article 3.1 <#accepting> hereinabove, and the
Licensee hereby acknowledges that it has read and understood it.
Article 4 - EFFECTIVE DATE AND TERM
4.1 EFFECTIVE DATE
The Agreement shall become effective on the date when it is accepted by the
Licensee as set forth in Article 3.1 <#accepting> .
4.2 TERM
The Agreement shall remain in force for the entire legal term of protection
of the economic rights over the Software.
Article 5 - SCOPE OF RIGHTS GRANTED
The Licensor hereby grants to the Licensee, who accepts, the following rights
over the Software for any or all use, and for the term of the Agreement, on
the basis of the terms and conditions set forth hereinafter.
Besides, if the Licensor owns or comes to own one or more patents protecting
all or part of the functions of the Software or of its components, the Licensor
undertakes not to enforce the rights granted by these patents against successive
Licensees using, exploiting or modifying the Software. If these patents are
transferred, the Licensor undertakes to have the transferees subscribe to
the obligations set forth in this paragraph.
5.1 RIGHT OF USE
The Licensee is authorized to use the Software, without any limitation as
to its fields of application, with it being hereinafter specified that this
comprises:
1. permanent or temporary reproduction of all or part of the Software by any
or all means and in any or all form.
2. loading, displaying, running, or storing the Software on any or all medium.
3. entitlement to observe, study or test its operation so as to determine
the ideas and principles behind any or all constituent elements of said Software.
This shall apply when the Licensee carries out any or all loading, displaying,
running, transmission or storage operation as regards the Software, that it
is entitled to carry out hereunder.
5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS
The right to make Contributions includes the right to translate, adapt, arrange,
or make any or all modifications to the Software, and the right to reproduce
the resulting software.
The Licensee is authorized to make any or all Contributions to the Software
provided that it includes an explicit notice that it is the author of said
Contribution and indicates the date of the creation thereof.
5.3 RIGHT OF DISTRIBUTION
In particular, the right of distribution includes the right to publish, transmit
and communicate the Software to the general public on any or all medium, and
by any or all means, and the right to market, either in consideration of a
fee, or free of charge, one or more copies of the Software by any means.
The Licensee is further authorized to distribute copies of the modified or
unmodified Software to third parties according to the terms and conditions
set forth hereinafter.
5.3.1. DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION
The Licensee is authorized to distribute true copies of the Software in Source
Code or Object Code form, provided that said distribution complies with all
the provisions of the Agreement and is accompanied by:
1. a copy of the Agreement,
2. a notice relating to the limitation of both the Licensor's warranty and
liability as set forth in Articles 8 and 9,
and that, in the event that only the Object Code of the Software is redistributed,
the Licensee allows effective access to the full Source Code of the Software
for a period of at least three years from the distribution of the Software,
it being understood that the additional acquisition cost of the Source Code
shall not exceed the cost of the data transfer.
5.3.2. DISTRIBUTION OF MODIFIED SOFTWARE
When the Licensee makes a Contribution to the Software, the terms and conditions
for the distribution of the resulting Modified Software become subject to
all the provisions of this Agreement.
The Licensee is authorized to distribute the Modified Software, in source
code or object code form, provided that said distribution complies with all
the provisions of the Agreement and is accompanied by:
1. a copy of the Agreement,
2. a notice relating to the limitation of both the Licensor's warranty and
liability as set forth in Articles 8 and 9,
and, in the event that only the object code of the Modified Software is redistributed,
3. a note stating the conditions of effective access to the full source code
of the Modified Software for a period of at least three years from the distribution
of the Modified Software, it being understood that the additional acquisition
cost of the source code shall not exceed the cost of the data transfer.
5.3.3. DISTRIBUTION OF EXTERNAL MODULES
When the Licensee has developed an External Module, the terms and conditions
of this Agreement do not apply to said External Module, that may be distributed
under a separate license agreement.
5.3.4. COMPATIBILITY WITH OTHER LICENSES
The Licensee can include a code that is subject to the provisions of one of
the versions of the GNU GPL, GNU Affero GPL and/or EUPL in the Modified or
unmodified Software, and distribute that entire code under the terms of the
same version of the GNU GPL, GNU Affero GPL and/or EUPL.
The Licensee can include the Modified or unmodified Software in a code that
is subject to the provisions of one of the versions of the GNU GPL, GNU Affero
GPL and/or EUPL and distribute that entire code under the terms of the same
version of the GNU GPL, GNU Affero GPL and/or EUPL.
Article 6 - INTELLECTUAL PROPERTY
6.1 OVER THE INITIAL SOFTWARE
The Holder owns the economic rights over the Initial Software. Any or all
use of the Initial Software is subject to compliance with the terms and conditions
under which the Holder has elected to distribute its work and no one shall
be entitled to modify the terms and conditions for the distribution of said
Initial Software.
The Holder undertakes that the Initial Software will remain ruled at least
by this Agreement, for the duration set forth in Article 4.2 <#term> .
6.2 OVER THE CONTRIBUTIONS
The Licensee who develops a Contribution is the owner of the intellectual
property rights over this Contribution as defined by applicable law.
6.3 OVER THE EXTERNAL MODULES
The Licensee who develops an External Module is the owner of the intellectual
property rights over this External Module as defined by applicable law and
is free to choose the type of agreement that shall govern its distribution.
6.4 JOINT PROVISIONS
The Licensee expressly undertakes:
1. not to remove, or modify, in any manner, the intellectual property notices
attached to the Software;
2. to reproduce said notices, in an identical manner, in the copies of the
Software modified or not.
The Licensee undertakes not to directly or indirectly infringe the intellectual
property rights on the Software of the Holder and/or Contributors, and to
take, where applicable, vis-à-vis its staff, any and all measures required
to ensure respect of said intellectual property rights of the Holder and/or
Contributors.
Article 7 - RELATED SERVICES
7.1 Under no circumstances shall the Agreement oblige the Licensor to provide
technical assistance or maintenance services for the Software.
However, the Licensor is entitled to offer this type of services. The terms
and conditions of such technical assistance, and/or such maintenance, shall
be set forth in a separate instrument. Only the Licensor offering said maintenance
and/or technical assistance services shall incur liability therefor.
7.2 Similarly, any Licensor is entitled to offer to its licensees, under its
sole responsibility, a warranty, that shall only be binding upon itself, for
the redistribution of the Software and/or the Modified Software, under terms
and conditions that it is free to decide. Said warranty, and the financial
terms and conditions of its application, shall be subject of a separate instrument
executed between the Licensor and the Licensee.
Article 8 - LIABILITY
8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled
to claim compensation for any direct loss it may have suffered from the Software
as a result of a fault on the part of the relevant Licensor, subject to providing
evidence thereof.
8.2 The Licensor's liability is limited to the commitments made under this
Agreement and shall not be incurred as a result of in particular: (i) loss
due the Licensee's total or partial failure to fulfill its obligations, (ii)
direct or consequential loss that is suffered by the Licensee due to the use
or performance of the Software, and (iii) more generally, any consequential
loss. In particular the Parties expressly agree that any or all pecuniary
or business loss (i.e. loss of data, loss of profits, operating loss, loss
of customers or orders, opportunity cost, any disturbance to business activities)
or any or all legal proceedings instituted against the Licensee by a third
party, shall constitute consequential loss and shall not provide entitlement
to any or all compensation from the Licensor.
Article 9 - WARRANTY
9.1 The Licensee acknowledges that the scientific and technical state-of-the-art
when the Software was distributed did not enable all possible uses to be tested
and verified, nor for the presence of possible defects to be detected. In
this respect, the Licensee's attention has been drawn to the risks associated
with loading, using, modifying and/or developing and reproducing the Software
which are reserved for experienced users.
The Licensee shall be responsible for verifying, by any or all means, the
suitability of the product for its requirements, its good working order, and
for ensuring that it shall not cause damage to either persons or properties.
9.2 The Licensor hereby represents, in good faith, that it is entitled to
grant all the rights over the Software (including in particular the rights
set forth in Article 5 <#scope> ).
9.3 The Licensee acknowledges that the Software is supplied "as is" by the
Licensor without any other express or tacit warranty, other than that provided
for in Article 9.2 <#good-faith> and, in particular, without any warranty
as to its commercial value, its secured, safe, innovative or relevant nature.
Specifically, the Licensor does not warrant that the Software is free from
any error, that it will operate without interruption, that it will be compatible
with the Licensee's own equipment and software configuration, nor that it
will meet the Licensee's requirements.
9.4 The Licensor does not either expressly or tacitly warrant that the Software
does not infringe any third party intellectual property right relating to
a patent, software or any other property right. Therefore, the Licensor disclaims
any and all liability towards the Licensee arising out of any or all proceedings
for infringement that may be instituted in respect of the use, modification
and redistribution of the Software. Nevertheless, should such proceedings
be instituted against the Licensee, the Licensor shall provide it with technical
and legal expertise for its defense. Such technical and legal expertise shall
be decided on a case-by-case basis between the relevant Licensor and the Licensee
pursuant to a memorandum of understanding. The Licensor disclaims any and
all liability as regards the Licensee's use of the name of the Software. No
warranty is given as regards the existence of prior rights over the name of
the Software or as regards the existence of a trademark.
Article 10 - TERMINATION
10.1 In the event of a breach by the Licensee of its obligations hereunder,
the Licensor may automatically terminate this Agreement thirty (30) days after
notice has been sent to the Licensee and has remained ineffective.
10.2 A Licensee whose Agreement is terminated shall no longer be authorized
to use, modify or distribute the Software. However, any licenses that it may
have granted prior to termination of the Agreement shall remain valid subject
to their having been granted in compliance with the terms and conditions hereof.
Article 11 - MISCELLANEOUS
11.1 EXCUSABLE EVENTS
Neither Party shall be liable for any or all delay, or failure to perform
the Agreement, that may be attributable to an event of force majeure, an act
of God or an outside cause, such as defective functioning or interruptions
of the electricity or telecommunications networks, network paralysis following
a virus attack, intervention by government authorities, natural disasters,
water damage, earthquakes, fire, explosions, strikes and labor unrest, war,
etc.
11.2 Any failure by either Party, on one or more occasions, to invoke one
or more of the provisions hereof, shall under no circumstances be interpreted
as being a waiver by the interested Party of its right to invoke said provision(s)
subsequently.
11.3 The Agreement cancels and replaces any or all previous agreements, whether
written or oral, between the Parties and having the same purpose, and constitutes
the entirety of the agreement between said Parties concerning said purpose.
No supplement or modification to the terms and conditions hereof shall be
effective as between the Parties unless it is made in writing and signed by
their duly authorized representatives.
11.4 In the event that one or more of the provisions hereof were to conflict
with a current or future applicable act or legislative text, said act or legislative
text shall prevail, and the Parties shall make the necessary amendments so
as to comply with said act or legislative text. All other provisions shall
remain effective. Similarly, invalidity of a provision of the Agreement, for
any reason whatsoever, shall not cause the Agreement as a whole to be invalid.
11.5 LANGUAGE
The Agreement is drafted in both French and English and both versions are
deemed authentic.
Article 12 - NEW VERSIONS OF THE AGREEMENT
12.1 Any person is authorized to duplicate and distribute copies of this Agreement.
12.2 So as to ensure coherence, the wording of this Agreement is protected
and may only be modified by the authors of the License, who reserve the right
to periodically publish updates or new versions of the Agreement, each with
a separate number. These subsequent versions may address new issues encountered
by Free Software.
12.3 Any Software distributed under a given version of the Agreement may only
be subsequently distributed under the same version of the Agreement or a subsequent
version, subject to the provisions of Article 5.3.4 <#compatibility> .
Article 13 - GOVERNING LAW AND JURISDICTION
13.1 The Agreement is governed by French law. The Parties agree to endeavor
to seek an amicable solution to any disagreements or disputes that may arise
during the performance of the Agreement.
13.2 Failing an amicable solution within two (2) months as from their occurrence,
and unless emergency proceedings are necessary, the disagreements or disputes
shall be referred to the Paris Courts having jurisdiction, by the more diligent
Party. 1 CeCILL stands for Ce(a) C(nrs) I(nria) L(ogiciel) L(ibre)

105
java/APIGroupe/Makefile Normal file
View File

@ -0,0 +1,105 @@
# COMMANDES #
JAVAC = javac
# note $$ to get a single shell $
JAVAC_OPTIONS = -d build -cp build:$$CLASSPATH -implicit:none
JAVA = java
JAR = jar
EXEC_JAR = ${JAVA} -jar
# CHEMINS RELATIFS
SRC = src/fr/iutfbleau/projetIHM2022FI2
BUILD = build/fr/iutfbleau/projetIHM2022FI2
DOC = doc/fr/iutfbleau/projetIHM2022FI2
# CHOIX NOMS
JAR_MNP = test-mnp.jar
# BUTS FACTICES #
.PHONY : run clean doc
# BUT PAR DEFAUT #
run : ${JAR_MNP}
${EXEC_JAR} ${JAR_MNP}
# AUTRE BUTS
doc :
javadoc -d doc src/fr/iutfbleau/projetIHM2022FI2/API/*.java src/fr/iutfbleau/projetIHM2022FI2/MNP/*.java
clean :
rm -rf ${BUILD}/* *.jar
# REGLES DE DEPENDANCE #
## API ##
${BUILD}/API/MonPrint.class : ${SRC}/API/MonPrint.java
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/API/MonPrint.java
${BUILD}/API/TypeGroupe.class : ${SRC}/API/TypeGroupe.java
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/API/TypeGroupe.java
${BUILD}/API/Groupe.class : ${SRC}/API/Groupe.java \
${BUILD}/API/TypeGroupe.class\
${BUILD}/API/MonPrint.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/API/Groupe.java
${BUILD}/API/Etudiant.class : ${SRC}/API/Etudiant.java \
${BUILD}/API/MonPrint.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/API/Etudiant.java
${BUILD}/API/Changement.class : ${SRC}/API/Changement.java \
${BUILD}/API/Etudiant.class \
${BUILD}/API/Groupe.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/API/Changement.java
${BUILD}/API/AbstractGroupeFactory.class : ${SRC}/API/AbstractGroupeFactory.java \
${BUILD}/API/Groupe.class \
${BUILD}/API/Etudiant.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/API/AbstractGroupeFactory.java
${BUILD}/API/AbstractChangementFactory.class : ${SRC}/API/AbstractChangementFactory.java \
${BUILD}/API/AbstractGroupeFactory.class \
${BUILD}/API/Changement.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/API/AbstractChangementFactory.java
## MNP ##
${BUILD}/MNP/EtudiantNP.class : ${SRC}/MNP/EtudiantNP.java \
${BUILD}/API/Etudiant.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/MNP/EtudiantNP.java
${BUILD}/MNP/GroupeNP.class : ${SRC}/MNP/GroupeNP.java \
${BUILD}/API/Groupe.class \
${BUILD}/API/TypeGroupe.class \
${BUILD}/API/Etudiant.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/MNP/GroupeNP.java
${BUILD}/MNP/ChangementNP.class : ${BUILD}/API/Changement.class \
${SRC}/MNP/ChangementNP.java \
${BUILD}/API/Groupe.class \
${BUILD}/API/Etudiant.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/MNP/ChangementNP.java
${BUILD}/MNP/AbstractGroupeFactoryNP.class : ${SRC}/MNP/AbstractGroupeFactoryNP.java \
${BUILD}/API/AbstractGroupeFactory.class
${JAVAC} ${JAVAC_OPTIONS} ${SRC}/MNP/AbstractGroupeFactoryNP.java
###...
## TEST ##
${BUILD}/Test/TestTexteMNP.class : ${SRC}/Test/TestTexteMNP.java \
${BUILD}/MNP/EtudiantNP.class \
${BUILD}/MNP/GroupeNP.class \
${BUILD}/MNP/ChangementNP.class \
${BUILD}/MNP/AbstractGroupeFactoryNP.class
${JAVAC} -Xlint:deprecation ${JAVAC_OPTIONS} ${SRC}/Test/TestTexteMNP.java
# ## JARS ##
${JAR_MNP} : ${BUILD}/Test/TestTexteMNP.class
${JAR} cvfe ${JAR_MNP} fr.iutfbleau.projetIHM2022FI2.Test.TestTexteMNP -C build fr

16
java/APIGroupe/README.md Normal file
View File

@ -0,0 +1,16 @@
# APIGroupes
Attention l'API n'est pas encore complète.
API pour le projet IHM 2022-2023.
Vous avez un makefile qui permet de générer la javadoc en faisant.
$ make doc
Vous pouvez ensuite naviguer dans la doc en commençant par le fichier doc/overview-tree.html
Un petit fichier de test permet de mieux comprendre l'architecture.
Il faut faire
$ make run
Ensuite vous pouvez aller lire les sources.

44
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java Normal file
View File

@ -0,0 +1,44 @@
package fr.iutfbleau.projetIHM2022FI2.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
*/
public AbstractGroupeFactory getGroupeFactory();
/**
* permet de récupérer les changements
* @return tous les changements en attente
*/
public Iterator<Changement> getAllChangements();
/**
* 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);
}

93
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java~ Normal file
View File

@ -0,0 +1,93 @@
package fr.iutfbleau.projetIHM2022FI2.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();
/**
* 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
*
* 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 de son identifiant
*
* @param id l'identifiant de l'étudiant
* @return Etudiant l'étudiant connu de la factory ayant cet identifiant
*
* @throws java.lang.IllegalStateException la factory ne connaît pas l'étudiant.
*/
public Etudiant getEtudiantFromId(int idEtu);
}

106
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java Normal file
View File

@ -0,0 +1,106 @@
package fr.iutfbleau.projetIHM2022FI2.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();
/**
* 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
*
* 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.
*
* 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);
}

106
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java~ Normal file
View File

@ -0,0 +1,106 @@
package fr.iutfbleau.projetIHM2022FI2.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();
/**
* 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
*
* 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.
*
* 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> getEtudiantFromId(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);
}

49
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java Normal file
View File

@ -0,0 +1,49 @@
package fr.iutfbleau.projetIHM2022FI2.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.
*
* 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.getA().getName());
return sb.toString();
}
}

85
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java~ Normal file
View File

@ -0,0 +1,85 @@
package fr.iutfbleau.projetIHM2022FI2.API;
import java.util.*;
/**
* Un groupe
*/
public interface Groupe extends MonPrint {
/**
* 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 un itérateur sur sous-groupes.
*/
public Iterator<Groupe> getSousGroupes();
/**
* Potentiellement "vide"
* @return un itérateur sur les étudiants.
*/
public Iterator<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.
*
* 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()+")");
Iterator<Etudiant> i = getEtudiants();
sb.append("%n");
while (i.hasNext()){
Etudiant s = i.next();
sb.append(s.toString());
sb.append("%n");
}
return sb.toString();
}
}

33
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java Normal file
View File

@ -0,0 +1,33 @@
package fr.iutfbleau.projetIHM2022FI2.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();
/**
* @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() + " (id="+getId()+")");
}
}

33
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java~ Normal file
View File

@ -0,0 +1,33 @@
package fr.iutfbleau.projetIHM2022FI2.API;
/**
* Un étudiant
*/
public interface Etudiant extends MonPrint{
/**
* permet de récupérer l'identifiant de l'étudiant (qu'on suppose être le même pour les différents systèmes, internes et externes à l'hôtel).
* @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();
/**
* @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() + " (id="+getId()+")");
}
}

121
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java Normal file
View File

@ -0,0 +1,121 @@
package fr.iutfbleau.projetIHM2022FI2.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.
*
* 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 Groupess **\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();
}
}

115
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java~ Normal file
View File

@ -0,0 +1,115 @@
package fr.iutfbleau.projetIHM2022FI2.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.
*
* 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
for (Etudiant s: getEtudiants()){
sb.append("\t"+ s.monPrint());
sb.append("\n");
}
return sb.toString();
}
}

12
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java Normal file
View File

@ -0,0 +1,12 @@
package fr.iutfbleau.projetIHM2022FI2.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();
}

7
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java~ Normal file
View File

@ -0,0 +1,7 @@
public interface MonPrint{
/**
* Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint();
*/
public String monPrint();
}

10
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java Normal file
View File

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

10
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java~ Normal file
View File

@ -0,0 +1,10 @@
package fr.iutfbleau.projetIHM2022FI2.API;
public enum TypeGroupe {
ROOT ("Tous les étudiants"), PARTITION ("partitionable"), FREE ("libre") ;
private final String name;
private TypeGroupe(String s) {
name = s;
}
}

106
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupFactoryNP.java~ Normal file
View File

@ -0,0 +1,106 @@
package fr.iutfbleau.projetIHM2022FI2.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();
/**
* 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
*
* 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.
*
* 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> getEtudiantFromId(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);
}

222
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java Normal file
View File

@ -0,0 +1,222 @@
package fr.iutfbleau.projetIHM2022FI2.MNP;
import fr.iutfbleau.projetIHM2022FI2.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(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(name,min,max);
this.brain=new HashMap<Integer,Groupe>();
this.brain.put(Integer.valueOf(this.promo.getId()),this.promo);
}
/**
* Test pltôt optimiste. Si la clé est identique alors on fait comme si c'était le bon groupe.
*/
private 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;
for(int i = 0; i<n; i++){
Groupe g = new GroupeNP(copiePereRacinePartition,name+"_"+i,min,max);
copiePereRacinePartition.addSousGroupe(g);
this.brain.put(Integer.valueOf(g.getId()),g);
}
}
/**
* 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){
throw new UnsupportedOperationException("pas encore implanté");
}
/**
* 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é");
}
}

143
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java~ Normal file
View File

@ -0,0 +1,143 @@
package fr.iutfbleau.projetIHM2022FI2.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).
private HashMap<Int,Groupe> brain;
/**
*
*/
private Boolean known(Groupe g){
return this.brain.containsKey(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){
throw new UnsupportedOperationException("pas encore implanté");
}
/**
* 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){
throw new UnsupportedOperationException("pas encore implanté");
}
/**
* 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
*
* 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){
throw new UnsupportedOperationException("pas encore implanté");
}
/**
* 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){
throw new UnsupportedOperationException("pas encore implanté");
}
/**
* 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é");
}
}

60
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java Normal file
View File

@ -0,0 +1,60 @@
package fr.iutfbleau.projetIHM2022FI2.MNP;
import fr.iutfbleau.projetIHM2022FI2.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 {
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");
// Nous n'utilisons dans l'immédiat pas le champs id qui vaut 0 pour tous les changements.
this.id=0;
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.a;
}
/**
* permet de récupérer l'étudiant demandant le changement
* @return cet étudiant
*/
public Etudiant getEtu(){
return this.e;
}
}

60
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java~ Normal file
View File

@ -0,0 +1,60 @@
package fr.iutfbleau.projetIHM2022FI2.MNP;
import fr.iutfbleau.projetIHM2022FI2.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 {
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(r,"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");
// Nous n'utilisons dans l'immédiat pas le champs id qui vaut 0 pour tous les changements.
this.id=0;
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.a;
}
/**
* permet de récupérer l'étudiant demandant le changement
* @return cet étudiant
*/
public Etudiant getEtu(){
return this.e;
}
}

51
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java Normal file
View File

@ -0,0 +1,51 @@
package fr.iutfbleau.projetIHM2022FI2.MNP;
import fr.iutfbleau.projetIHM2022FI2.API.*;
import java.util.*;
/**
* Un étudiant
*/
public class EtudiantNP implements Etudiant{
private static int nextId=0;
private int id;
private String nom, prenom;
/**
* Constructeur.
*/
public EtudiantNP(String nom, String prenom){
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.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;
}
}

51
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java~ Normal file
View File

@ -0,0 +1,51 @@
package fr.iutfbleau.projetIHM2022FI2.MNP;
import fr.iutfbleau.projetIHM2022FI2.API.*;
import java.util.*;
/**
* Un étudiant
*/
public class EtudiantNP implements Etudiant{
private static nextId=0;
private int id;
private String nom, prenom;
/**
* Constructeur.
*/
public EtudiantNP(String nom, String prenom){
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.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;
}
}

192
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java Normal file
View File

@ -0,0 +1,192 @@
package fr.iutfbleau.projetIHM2022FI2.MNP;
import fr.iutfbleau.projetIHM2022FI2.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(String name, int min, int max){
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.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;
}
}

199
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java~ Normal file
View File

@ -0,0 +1,199 @@
package fr.iutfbleau.projetIHM2022FI2.MNP;
import fr.iutfbleau.projetIHM2022FI2.API.*;
import java.util.*;
/**
* Un groupe
*/
public class GroupeNP extends Groupe {
//auto-incrément des groupes. (NB. inutile, mais ça fair un exemple d'attribut statique).
private static 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;
// les méthodes de l'interface groupe sont en fin de fichier.
// On commence par les get/set additionnels, puis les constructeurs.
/**
* Réfléchir à donner droit dans paquet.
* @return le set des étudiants (attention ce n'est pas une copie, tout changement impacte le groupe).
*/
public Set<Etudiant> getSetEtudiants(){
return this.membresDuGroupe;
}
/**
* Ajoute un étudiant. Se comporte comme add de l'interface Set.
*
* @return true iff e est ajouté
*/
package 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é
*/
package 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é
*/
package 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é
*/
package boolean removeSousGroupe(Groupe g){
Objects.requireNonNull(e,"On ne peut pas enlever un Étudiant qui est null");
return this.souGroupes.remove(g);
}
/**
* Nouveau groupe vide de type PROMOTION sans étudiants, sans sous-Groupe
*/
public GroupeNP(String name, int min, int max){
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=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= this.pere.getSetEtudiants();
}
/**
* 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"
* @return un itérateur sur sous-groupes.
*/
public Iterator<Groupe> getSousGroupes(){
return this.sousGroupes.iterator();
}
/**
* Potentiellement "vide"
* @return un itérateur sur les étudiants.
*/
public Iterator<Etudiant> getEtudiants(){
return this.membresDuGroupe.iterator();
}
}

164
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ReservationFactoryNP.java~ Normal file
View File

@ -0,0 +1,164 @@
package fr.iutfbleau.projetIHM2021FI2.MNP;
import fr.iutfbleau.projetIHM2021FI2.API.*;
import java.time.LocalDate;
import java.util.*;
import java.util.function.Predicate;
/**
* Usine non persistante stockant les réservations dans une structure de données permettant de simuler un ensemble.
*
*
*/
public interface ReservationFactory{
/**
* Recherche une chambre adéquate à partir de
* @param p une préréservation
* @return la chambre
* @throws NullPointerException si un argument est null
* @throws IllegalStateException si une chambre correspondant à cette Préréservation n'existe pas.
*
* Ne devrait pas retourner un objet null.
*/
public Chambre getChambre(Prereservation p);
/**
* Recherche toutes les chambres adéquates à partir de
* @param p une préréservation
* @return les chambres (set de chambre)
* @throws NullPointerException si un argument est null
* @throws IllegalStateException si une chambre correspondant à cette Préréservation n'existe pas.
*
* Ne devrait pas retourner un objet null.
*/
public Set<Chambre> getChambres(Prereservation p);
/**
* Fabrique (ajoute) une réservation
* @param p une préréservation
* @param c une chambre (normalement libre et adaptée à la préréservation)
* @return la réservation
* @throws NullPointerException si un argument est null
* @throws IllegalArgumentException si la chambre ne correspondant pas au type de chambre de la préréservation.
* @throws IllegalStateException si la chambre n'est pas disponible.
*
* Ne devrait pas retourner un objet null.
*/
public Reservation createReservation(Prereservation p, Chambre c);
/**
* Cherche les réservations
* @param d une date
* @return la ou les réservation(s) à cette date sous forme d'un ensemble
* @throws NullPointerException si un argument est null
*
* Ne devrait pas retourner un objet null, par contre peut être un ensemble qui est vide.
*/
public Set<Reservation> getReservation(LocalDate d);
/**
* Cherche le nombre de chambres disponibles pour une date (réservées ou non).
* @param d une date
* @return un entier
* @throws NullPointerException si un argument est null
*
* Ne devrait pas retourner un entier négatif.
*/
public int getDisponibles(LocalDate d);
/**
* Cherche les réservations
* @param d une date
* @param t un type de chambre
* @return la ou les réservation(s) pour ce type de chambre à cette date sous forme d'un ensemble
* @throws NullPointerException si un argument est null
*
* Ne devrait pas retourner un objet null, par contre peut être un ensemble qui est vide.
*/
public Set<Reservation> getReservation(LocalDate d, TypeChambre t);
/**
* Cherche le nombre de chambres disponibles d'un certain type pour une date (réservées ou non).
* @param d une date
* @param t un type de chambre
* @return un entier
* @throws NullPointerException si un argument est null
*
* Ne devrait pas retourner un entier négatif.
*/
public int getDisponibles(LocalDate d, TypeChambre t);
/**
* Cherche la proportion de chambres disponibles pour une date (réservées sur réservables).
* @param d une date
* @return un entier entre 0 et 100
* @throws NullPointerException si un argument est null
*/
public int getRatio(LocalDate d);
/**
* Cherche la proportion de chambres disponibles d'un certain type pour une date (réservées sur réservables).
* @param d une date
* @param t un type de chambre
* @return un entier entre 0 et 100
* @throws NullPointerException si un argument est null
*/
public int getRatio(LocalDate d, TypeChambre t);
/**
* Cherche le nombre moyen de chambres disponibles entre deux date (réservées ou non), arrondies à l'entier inférieur.
* @param d1 une date
* @param d2 une date
* @return un entier
* @throws NullPointerException si un argument est null
* @throws IllegalArgumentException si l'ordre temporel d1 avant d2 n'est pas respecté.
*
* Ne devrait pas retourner un entier négatif.
*/
public int getDisponibles(LocalDate d1, LocalDate d2);
/**
* Cherche les réservations
* @param d1 une date
* @param d2 une date
* @param t un type de chambre
* @return la ou les réservation(s) pour ce type de chambre entre les dates sous forme d'un ensemble
* @throws NullPointerException si un argument est null
* @throws IllegalArgumentException si l'ordre temporel d1 avant d2 n'est pas respecté.
*
* Ne devrait pas retourner un objet null, par contre peut être un ensemble qui est vide.
*/
public Set<Reservation> getReservation(LocalDate d1, LocalDate d2, TypeChambre t);
/**
* Cherche le <b>nombre moyen</b> de chambres disponibles d'un certain type entre deux date (réservées ou non), arrondies à l'entier inférieur.
* @param d1 une date
* @param d2 une date
* @param t un type de chambre
* @return un entier
* @throws NullPointerException si un argument est null
* @throws IllegalArgumentException si l'ordre temporel d1 avant d2 n'est pas respecté.
*
* Ne devrait pas retourner un entier négatif.
*/
public int getDisponibles(LocalDate d1, LocalDate d2, TypeChambre t);
/**
* Cherche la <b>proportion moyenne</b> de chambres disponibles pour une date (réservées sur réservables).
* @param d1 une date
* @param d2 une date
* @return un entier entre 0 et 100
* @throws NullPointerException si un argument est null
*/
public int getRatio(LocalDate d1, LocalDate d2);
/**
* Cherche la <b>proportion moyenne</b> de chambres disponibles d'un certain type pour une date (réservées sur réservables).
* @param d1 une date
* @param d2 une date
* @param t un type de chambre
* @return un entier entre 0 et 100
* @throws NullPointerException si un argument est null
*/
public int getRatio(LocalDate d1, LocalDate d2, TypeChambre t);
}

186
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java Normal file
View File

@ -0,0 +1,186 @@
package fr.iutfbleau.projetIHM2022FI2.Test;
import fr.iutfbleau.projetIHM2022FI2.API.*;
import fr.iutfbleau.projetIHM2022FI2.MNP.*;
import java.util.*;
//import java.util.Random;
public class TestTexteMNP{
public static void main(String[] args) {
// morceaux de modèle
// Notez que à gauche d'une déclaration on utilise une interface et à droite une version concrète.
// Il faut que votre vue se calque sur le fonctionnemment de ce main et ne fasse pas d'hypothèse sur l'implémentation concrète de l'interface.
// i.e. entre les versions non persistantes (qui terminent par NP) et votre implémentation éventuelle persistante, le seul changement de comportement devrait être la persistance.
//
System.out.println("Test de l\'API");
System.out.print("Création des étudiants");
Etudiant e1=new EtudiantNP("césar","lycurgus");
Etudiant e2=new EtudiantNP("denis","uranus");
Etudiant e3=new EtudiantNP("marcel","castor");
Etudiant e4=new EtudiantNP("marin","eurydice");
Etudiant e5=new EtudiantNP("constantin","akoni");
Etudiant e6=new EtudiantNP("donat","anakoni");
Etudiant e7=new EtudiantNP("alexandre","apikalia");
Etudiant e8=new EtudiantNP("andré","ekewaka");
Etudiant e9=new EtudiantNP("renard","elikapeka");
Etudiant e10=new EtudiantNP("achille","haukea");
System.out.print(".");
Etudiant e11=new EtudiantNP("agathe","iakopa");
Etudiant e12=new EtudiantNP("sabine","spartacus");
Etudiant e13=new EtudiantNP("michel","caligula");
Etudiant e14=new EtudiantNP("marthe","alaric");
Etudiant e15=new EtudiantNP("juliane","hannibal");
Etudiant e16=new EtudiantNP("anne","juvenal");
Etudiant e17=new EtudiantNP("sophie","bede");
Etudiant e18=new EtudiantNP("louis","hamilcar");
Etudiant e19=new EtudiantNP("diane","ladislas");
Etudiant e20=new EtudiantNP("christine","mahatma");
System.out.print(".");
Etudiant e21=new EtudiantNP("francine","napoleon");
Etudiant e22=new EtudiantNP("louise","lalita");
Etudiant e23=new EtudiantNP("chantal","laxman");
Etudiant e24=new EtudiantNP("giselle","laxmi");
Etudiant e25=new EtudiantNP("caroline","leela");
Etudiant e26=new EtudiantNP("claude","lila");
Etudiant e27=new EtudiantNP("pauline","lilavati");
Etudiant e28=new EtudiantNP("avril","lochan");
Etudiant e29=new EtudiantNP("jacqueline","madhav");
Etudiant e30=new EtudiantNP("denise","turlough");
System.out.print(".");
Etudiant e31=new EtudiantNP("gabrielle","uaithne");
Etudiant e32=new EtudiantNP("julie","uilleag");
Etudiant e33=new EtudiantNP("madeleine","uilliam");
Etudiant e34=new EtudiantNP("charlotte","uinseann");
Etudiant e35=new EtudiantNP("bertrand","ulick");
Etudiant e36=new EtudiantNP("lucile","ultan");
Etudiant e37=new EtudiantNP("nicole","firdaus");
Etudiant e38=new EtudiantNP("blanche","yasmin");
Etudiant e39=new EtudiantNP("jeanine","javed");
Etudiant e40=new EtudiantNP("roxane","naveed");
System.out.print(".");
Etudiant e41=new EtudiantNP("adeline","shahnaz");
Etudiant e42=new EtudiantNP("dion","ardashir");
Etudiant e43=new EtudiantNP("liane","atefeh");
Etudiant e44=new EtudiantNP("myriam","luigina");
Etudiant e45=new EtudiantNP("danielle","luigino");
Etudiant e46=new EtudiantNP("arlette","maddalena");
Etudiant e47=new EtudiantNP("michelle","manfredo");
Etudiant e48=new EtudiantNP("justine","manlio");
Etudiant e49=new EtudiantNP("natalie","marcellino");
Etudiant e50=new EtudiantNP("aline","mariangela");
System.out.print(".");
Etudiant e51=new EtudiantNP("prosper","marzio");
Etudiant e52=new EtudiantNP("mirabelle","massimiliano");
Etudiant e53=new EtudiantNP("carine","matteo");
Etudiant e54=new EtudiantNP("jeannine","melchiorre");
Etudiant e55=new EtudiantNP("dianne","micaela");
Etudiant e56=new EtudiantNP("evette","michela");
Etudiant e57=new EtudiantNP("gisselle","michelangela");
System.out.println("terminé.");
System.out.print("Création de l\'usine à groupe");
AbstractGroupeFactory agf = new AbstractGroupeFactoryNP("BUT2 FI", 15, 92);
System.out.println("terminé.");
System.out.print("Ajout des étudiants dans le groupe de la promotion racine");
agf.addToGroupe(agf.getPromotion(),e1);
agf.addToGroupe(agf.getPromotion(),e2);
agf.addToGroupe(agf.getPromotion(),e3);
agf.addToGroupe(agf.getPromotion(),e4);
agf.addToGroupe(agf.getPromotion(),e5);
agf.addToGroupe(agf.getPromotion(),e6);
agf.addToGroupe(agf.getPromotion(),e7);
agf.addToGroupe(agf.getPromotion(),e8);
agf.addToGroupe(agf.getPromotion(),e9);
agf.addToGroupe(agf.getPromotion(),e10);
System.out.print(".");
agf.addToGroupe(agf.getPromotion(),e11);
agf.addToGroupe(agf.getPromotion(),e12);
agf.addToGroupe(agf.getPromotion(),e13);
agf.addToGroupe(agf.getPromotion(),e14);
agf.addToGroupe(agf.getPromotion(),e15);
agf.addToGroupe(agf.getPromotion(),e16);
agf.addToGroupe(agf.getPromotion(),e17);
agf.addToGroupe(agf.getPromotion(),e18);
agf.addToGroupe(agf.getPromotion(),e19);
agf.addToGroupe(agf.getPromotion(),e20);
System.out.print(".");
agf.addToGroupe(agf.getPromotion(),e21);
agf.addToGroupe(agf.getPromotion(),e22);
agf.addToGroupe(agf.getPromotion(),e23);
agf.addToGroupe(agf.getPromotion(),e24);
agf.addToGroupe(agf.getPromotion(),e25);
agf.addToGroupe(agf.getPromotion(),e26);
agf.addToGroupe(agf.getPromotion(),e27);
agf.addToGroupe(agf.getPromotion(),e28);
agf.addToGroupe(agf.getPromotion(),e29);
agf.addToGroupe(agf.getPromotion(),e30);
agf.addToGroupe(agf.getPromotion(),e31);
agf.addToGroupe(agf.getPromotion(),e32);
agf.addToGroupe(agf.getPromotion(),e33);
agf.addToGroupe(agf.getPromotion(),e34);
agf.addToGroupe(agf.getPromotion(),e35);
agf.addToGroupe(agf.getPromotion(),e36);
agf.addToGroupe(agf.getPromotion(),e37);
agf.addToGroupe(agf.getPromotion(),e38);
agf.addToGroupe(agf.getPromotion(),e39);
System.out.print(".");
agf.addToGroupe(agf.getPromotion(),e40);
agf.addToGroupe(agf.getPromotion(),e41);
agf.addToGroupe(agf.getPromotion(),e42);
agf.addToGroupe(agf.getPromotion(),e43);
agf.addToGroupe(agf.getPromotion(),e44);
agf.addToGroupe(agf.getPromotion(),e45);
agf.addToGroupe(agf.getPromotion(),e46);
agf.addToGroupe(agf.getPromotion(),e47);
agf.addToGroupe(agf.getPromotion(),e48);
agf.addToGroupe(agf.getPromotion(),e49);
agf.addToGroupe(agf.getPromotion(),e50);
agf.addToGroupe(agf.getPromotion(),e51);
agf.addToGroupe(agf.getPromotion(),e52);
agf.addToGroupe(agf.getPromotion(),e53);
agf.addToGroupe(agf.getPromotion(),e54);
agf.addToGroupe(agf.getPromotion(),e55);
agf.addToGroupe(agf.getPromotion(),e56);
agf.addToGroupe(agf.getPromotion(),e57);
System.out.println("terminé.");
System.out.println("Initialisation complète.");
System.out.println("==========================");
System.out.println("Le groupe promotion");
System.out.println(agf.getPromotion().monPrint());
System.out.println("==========================");
System.out.println("Partition du groupe racine en 3 groupes TD.");
agf.createPartition(agf.getPromotion(), "TD",3);
System.out.println(agf.getPromotion().monPrint());
Groupe racineDeLaPartition = agf.getPromotion().getSousGroupes().iterator().next();
System.out.println(racineDeLaPartition.monPrint());
}
}

183
java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java~ Normal file
View File

@ -0,0 +1,183 @@
package fr.iutfbleau.projetIHM2022FI2.Test;
import fr.iutfbleau.projetIHM2022FI2.API.*;
import fr.iutfbleau.projetIHM2022FI2.MNP.*;
import java.util.*;
//import java.util.Random;
public class TestTexteMNP{
public static void main(String[] args) {
// morceaux de modèle
// Notez que à gauche d'une déclaration on utilise une interface et à droite une version concrète.
// Il faut que votre vue se calque sur le fonctionnemment de ce main et ne fasse pas d'hypothèse sur l'implémentation concrète de l'interface.
// i.e. entre les versions non persistantes (qui terminent par NP) et votre implémentation éventuelle persistante, le seul changement de comportement devrait être la persistance.
//
System.out.println("Test de l\'API");
System.out.print("Création des étudiants");
Etudiant e1=new EtudiantNP("césar","lycurgus");
Etudiant e2=new EtudiantNP("denis","uranus");
Etudiant e3=new EtudiantNP("marcel","castor");
Etudiant e4=new EtudiantNP("marin","eurydice");
Etudiant e5=new EtudiantNP("constantin","akoni");
Etudiant e6=new EtudiantNP("donat","anakoni");
Etudiant e7=new EtudiantNP("alexandre","apikalia");
Etudiant e8=new EtudiantNP("andré","ekewaka");
Etudiant e9=new EtudiantNP("renard","elikapeka");
Etudiant e10=new EtudiantNP("achille","haukea");
System.out.print(".");
Etudiant e11=new EtudiantNP("agathe","iakopa");
Etudiant e12=new EtudiantNP("sabine","spartacus");
Etudiant e13=new EtudiantNP("michel","caligula");
Etudiant e14=new EtudiantNP("marthe","alaric");
Etudiant e15=new EtudiantNP("juliane","hannibal");
Etudiant e16=new EtudiantNP("anne","juvenal");
Etudiant e17=new EtudiantNP("sophie","bede");
Etudiant e18=new EtudiantNP("louis","hamilcar");
Etudiant e19=new EtudiantNP("diane","ladislas");
Etudiant e20=new EtudiantNP("christine","mahatma");
System.out.print(".");
Etudiant e21=new EtudiantNP("francine","napoleon");
Etudiant e22=new EtudiantNP("louise","lalita");
Etudiant e23=new EtudiantNP("chantal","laxman");
Etudiant e24=new EtudiantNP("giselle","laxmi");
Etudiant e25=new EtudiantNP("caroline","leela");
Etudiant e26=new EtudiantNP("claude","lila");
Etudiant e27=new EtudiantNP("pauline","lilavati");
Etudiant e28=new EtudiantNP("avril","lochan");
Etudiant e29=new EtudiantNP("jacqueline","madhav");
Etudiant e30=new EtudiantNP("denise","turlough");
System.out.print(".");
Etudiant e31=new EtudiantNP("gabrielle","uaithne");
Etudiant e32=new EtudiantNP("julie","uilleag");
Etudiant e33=new EtudiantNP("madeleine","uilliam");
Etudiant e34=new EtudiantNP("charlotte","uinseann");
Etudiant e35=new EtudiantNP("bertrand","ulick");
Etudiant e36=new EtudiantNP("lucile","ultan");
Etudiant e37=new EtudiantNP("nicole","firdaus");
Etudiant e38=new EtudiantNP("blanche","yasmin");
Etudiant e39=new EtudiantNP("jeanine","javed");
Etudiant e40=new EtudiantNP("roxane","naveed");
System.out.print(".");
Etudiant e41=new EtudiantNP("adeline","shahnaz");
Etudiant e42=new EtudiantNP("dion","ardashir");
Etudiant e43=new EtudiantNP("liane","atefeh");
Etudiant e44=new EtudiantNP("myriam","luigina");
Etudiant e45=new EtudiantNP("danielle","luigino");
Etudiant e46=new EtudiantNP("arlette","maddalena");
Etudiant e47=new EtudiantNP("michelle","manfredo");
Etudiant e48=new EtudiantNP("justine","manlio");
Etudiant e49=new EtudiantNP("natalie","marcellino");
Etudiant e50=new EtudiantNP("aline","mariangela");
System.out.print(".");
Etudiant e51=new EtudiantNP("prosper","marzio");
Etudiant e52=new EtudiantNP("mirabelle","massimiliano");
Etudiant e53=new EtudiantNP("carine","matteo");
Etudiant e54=new EtudiantNP("jeannine","melchiorre");
Etudiant e55=new EtudiantNP("dianne","micaela");
Etudiant e56=new EtudiantNP("evette","michela");
Etudiant e57=new EtudiantNP("gisselle","michelangela");
System.out.prinln("terminé.");
System.out.print("Création de l\'usine à groupe");
AbstractGroupeFactory agf = new AbstractGroupeFactoryNP("BUT2 FI", 15, 92);
System.out.prinln("terminé.");
System.out.print("Ajout des étudiants dans le groupe de la promotion racine");
agf.addToGroupe(agf.getPromotion(),e1);
agf.addToGroupe(agf.getPromotion(),e2);
agf.addToGroupe(agf.getPromotion(),e3);
agf.addToGroupe(agf.getPromotion(),e4);
agf.addToGroupe(agf.getPromotion(),e5);
agf.addToGroupe(agf.getPromotion(),e6);
agf.addToGroupe(agf.getPromotion(),e7);
agf.addToGroupe(agf.getPromotion(),e8);
agf.addToGroupe(agf.getPromotion(),e9);
agf.addToGroupe(agf.getPromotion(),e10);
System.out.print(".");
agf.addToGroupe(agf.getPromotion(),e11);
agf.addToGroupe(agf.getPromotion(),e12);
agf.addToGroupe(agf.getPromotion(),e13);
agf.addToGroupe(agf.getPromotion(),e14);
agf.addToGroupe(agf.getPromotion(),e15);
agf.addToGroupe(agf.getPromotion(),e16);
agf.addToGroupe(agf.getPromotion(),e17);
agf.addToGroupe(agf.getPromotion(),e18);
agf.addToGroupe(agf.getPromotion(),e19);
agf.addToGroupe(agf.getPromotion(),e20);
System.out.print(".");
agf.addToGroupe(agf.getPromotion(),e21);
agf.addToGroupe(agf.getPromotion(),e22);
agf.addToGroupe(agf.getPromotion(),e23);
agf.addToGroupe(agf.getPromotion(),e24);
agf.addToGroupe(agf.getPromotion(),e25);
agf.addToGroupe(agf.getPromotion(),e26);
agf.addToGroupe(agf.getPromotion(),e27);
agf.addToGroupe(agf.getPromotion(),e28);
agf.addToGroupe(agf.getPromotion(),e29);
agf.addToGroupe(agf.getPromotion(),e30);
agf.addToGroupe(agf.getPromotion(),e31);
agf.addToGroupe(agf.getPromotion(),e32);
agf.addToGroupe(agf.getPromotion(),e33);
agf.addToGroupe(agf.getPromotion(),e34);
agf.addToGroupe(agf.getPromotion(),e35);
agf.addToGroupe(agf.getPromotion(),e36);
agf.addToGroupe(agf.getPromotion(),e37);
agf.addToGroupe(agf.getPromotion(),e38);
agf.addToGroupe(agf.getPromotion(),e39);
System.out.print(".");
agf.addToGroupe(agf.getPromotion(),e40);
agf.addToGroupe(agf.getPromotion(),e41);
agf.addToGroupe(agf.getPromotion(),e42);
agf.addToGroupe(agf.getPromotion(),e43);
agf.addToGroupe(agf.getPromotion(),e44);
agf.addToGroupe(agf.getPromotion(),e45);
agf.addToGroupe(agf.getPromotion(),e46);
agf.addToGroupe(agf.getPromotion(),e47);
agf.addToGroupe(agf.getPromotion(),e48);
agf.addToGroupe(agf.getPromotion(),e49);
agf.addToGroupe(agf.getPromotion(),e50);
agf.addToGroupe(agf.getPromotion(),e51);
agf.addToGroupe(agf.getPromotion(),e52);
agf.addToGroupe(agf.getPromotion(),e53);
agf.addToGroupe(agf.getPromotion(),e54);
agf.addToGroupe(agf.getPromotion(),e55);
agf.addToGroupe(agf.getPromotion(),e56);
agf.addToGroupe(agf.getPromotion(),e57);
System.out.prinln("terminé.");
System.out.prinln("Initialisation complète.");
System.out.println("==========================");
System.out.prinln("Le groupe promotion");
System.out.println(agf.getPromotion().monPrint());
System.out.println("==========================");
System.out.prinln("Partition du groupe racine en 3 groupes TD.");
agf.createPartition(agf.getPromotion(), "TD",3);
System.out.println(agf.getPromotion().monPrint());
}
}