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