From ec80b6c454803b99f4414e63ddbce338623268fe Mon Sep 17 00:00:00 2001 From: Florent Madelaine Date: Wed, 19 Oct 2022 15:33:42 +0200 Subject: [PATCH] API partielle --- java/APIGroupe/LICENSE | 493 ++++++++++++++++++ java/APIGroupe/Makefile | 105 ++++ java/APIGroupe/README.md | 16 + .../API/AbstractChangementFactory.java | 44 ++ .../API/AbstractChangementFactory.java~ | 93 ++++ .../API/AbstractGroupeFactory.java | 106 ++++ .../API/AbstractGroupeFactory.java~ | 106 ++++ .../projetIHM2022FI2/API/Changement.java | 49 ++ .../projetIHM2022FI2/API/Changement.java~ | 85 +++ .../projetIHM2022FI2/API/Etudiant.java | 33 ++ .../projetIHM2022FI2/API/Etudiant.java~ | 33 ++ .../projetIHM2022FI2/API/Groupe.java | 121 +++++ .../projetIHM2022FI2/API/Groupe.java~ | 115 ++++ .../projetIHM2022FI2/API/MonPrint.java | 12 + .../projetIHM2022FI2/API/MonPrint.java~ | 7 + .../projetIHM2022FI2/API/TypeGroupe.java | 10 + .../projetIHM2022FI2/API/TypeGroupe.java~ | 10 + .../MNP/AbstractGroupFactoryNP.java~ | 106 ++++ .../MNP/AbstractGroupeFactoryNP.java | 222 ++++++++ .../MNP/AbstractGroupeFactoryNP.java~ | 143 +++++ .../projetIHM2022FI2/MNP/ChangementNP.java | 60 +++ .../projetIHM2022FI2/MNP/ChangementNP.java~ | 60 +++ .../projetIHM2022FI2/MNP/EtudiantNP.java | 51 ++ .../projetIHM2022FI2/MNP/EtudiantNP.java~ | 51 ++ .../projetIHM2022FI2/MNP/GroupeNP.java | 192 +++++++ .../projetIHM2022FI2/MNP/GroupeNP.java~ | 199 +++++++ .../MNP/ReservationFactoryNP.java~ | 164 ++++++ .../projetIHM2022FI2/Test/TestTexteMNP.java | 186 +++++++ .../projetIHM2022FI2/Test/TestTexteMNP.java~ | 183 +++++++ 29 files changed, 3055 insertions(+) create mode 100644 java/APIGroupe/LICENSE create mode 100644 java/APIGroupe/Makefile create mode 100644 java/APIGroupe/README.md create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupFactoryNP.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ReservationFactoryNP.java~ create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java create mode 100644 java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java~ diff --git a/java/APIGroupe/LICENSE b/java/APIGroupe/LICENSE new file mode 100644 index 0000000..44d7b76 --- /dev/null +++ b/java/APIGroupe/LICENSE @@ -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) diff --git a/java/APIGroupe/Makefile b/java/APIGroupe/Makefile new file mode 100644 index 0000000..ca8bb68 --- /dev/null +++ b/java/APIGroupe/Makefile @@ -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 + diff --git a/java/APIGroupe/README.md b/java/APIGroupe/README.md new file mode 100644 index 0000000..22317a9 --- /dev/null +++ b/java/APIGroupe/README.md @@ -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. diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java new file mode 100644 index 0000000..9c2c6b4 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java @@ -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 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); + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java~ new file mode 100644 index 0000000..c0849de --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractChangementFactory.java~ @@ -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); + + + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java new file mode 100644 index 0000000..946dff7 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java @@ -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 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 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 getGroupesOfEtudiant(Etudiant etu); + + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java~ new file mode 100644 index 0000000..f1dbec9 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/AbstractGroupeFactory.java~ @@ -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 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 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 getGroupesOfEtudiant(Etudiant etu); + + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java new file mode 100644 index 0000000..1b0d88d --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java @@ -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(); + } + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java~ new file mode 100644 index 0000000..f345ad0 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Changement.java~ @@ -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 getSousGroupes(); + + /** + * Potentiellement "vide" + * @return un itérateur sur les étudiants. + */ + public Iterator 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 i = getEtudiants(); + sb.append("%n"); + while (i.hasNext()){ + Etudiant s = i.next(); + sb.append(s.toString()); + sb.append("%n"); + } + return sb.toString(); + } + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java new file mode 100644 index 0000000..a31828b --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java @@ -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()+")"); + } +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java~ new file mode 100644 index 0000000..e7334a6 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Etudiant.java~ @@ -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()+")"); + } +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java new file mode 100644 index 0000000..cb397fa --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java @@ -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 getSousGroupes(); + + /** + * Potentiellement "vide" + * @return l'ensemble des étudiants. + */ + public Set 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(); + } + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java~ new file mode 100644 index 0000000..417c779 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/Groupe.java~ @@ -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 getSousGroupes(); + + /** + * Potentiellement "vide" + * @return l'ensemble des étudiants. + */ + public Set 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(); + } + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java new file mode 100644 index 0000000..7f8d663 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java @@ -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(); +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java~ new file mode 100644 index 0000000..e5fafae --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/MonPrint.java~ @@ -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(); +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java new file mode 100644 index 0000000..b9d9080 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java @@ -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; + } +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java~ new file mode 100644 index 0000000..902843e --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/API/TypeGroupe.java~ @@ -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; + } +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupFactoryNP.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupFactoryNP.java~ new file mode 100644 index 0000000..f1dbec9 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupFactoryNP.java~ @@ -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 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 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 getGroupesOfEtudiant(Etudiant etu); + + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java new file mode 100644 index 0000000..c86a834 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java @@ -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 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(); + 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 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 getEtudiants(String nomEtu){ + // on cherche bêtement dans la promo. + Set out = new LinkedHashSet(); + 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 getGroupesOfEtudiant(Etudiant etu){ + throw new UnsupportedOperationException("pas encore implanté"); + } + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java~ new file mode 100644 index 0000000..7ab138a --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/AbstractGroupeFactoryNP.java~ @@ -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 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 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 getEtudiants(String nomEtu){ + // on cherche bêtement dans la promo. + Set out = new LinkedHashSet(); + 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 getGroupesOfEtudiant(Etudiant etu){ + throw new UnsupportedOperationException("pas encore implanté"); + } + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java new file mode 100644 index 0000000..ba98b21 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java @@ -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; + } + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java~ new file mode 100644 index 0000000..49e2bd9 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ChangementNP.java~ @@ -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; + } + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java new file mode 100644 index 0000000..4d9df60 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java @@ -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; + } + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java~ new file mode 100644 index 0000000..2b6d0b9 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/EtudiantNP.java~ @@ -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; + } + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java new file mode 100644 index 0000000..cefd3c7 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java @@ -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 sousGroupes; + private Set 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(); + this.membresDuGroupe=new LinkedHashSet(); + } + + /** + * 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(); + this.membresDuGroupe=new LinkedHashSet(); + } + + /** + * 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(); + 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 getSousGroupes(){ + return this.sousGroupes; + } + + /** + * Potentiellement "vide" + * Attention nous renvoyons l'ensemble sans le copier + * + * @return l'ensemble des étudiants. + */ + public Set getEtudiants(){ + return this.membresDuGroupe; + } + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java~ new file mode 100644 index 0000000..e34daba --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/GroupeNP.java~ @@ -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 sousGroupes; + private Set 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 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(); + this.membresDugroupe=new LinkedHashSet(); + } + + /** + * 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(); + this.membresDugroupe=new LinkedHashSet(); + } + + /** + * 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(); + 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 getSousGroupes(){ + return this.sousGroupes.iterator(); + } + + /** + * Potentiellement "vide" + * @return un itérateur sur les étudiants. + */ + public Iterator getEtudiants(){ + return this.membresDuGroupe.iterator(); + } + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ReservationFactoryNP.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ReservationFactoryNP.java~ new file mode 100644 index 0000000..a4a4d99 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/MNP/ReservationFactoryNP.java~ @@ -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 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 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 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 getReservation(LocalDate d1, LocalDate d2, TypeChambre t); + + /** + * Cherche le nombre moyen 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 proportion moyenne 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 proportion moyenne 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); + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java new file mode 100644 index 0000000..a86f75c --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java @@ -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()); + } + + +} diff --git a/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java~ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java~ new file mode 100644 index 0000000..c41e896 --- /dev/null +++ b/java/APIGroupe/src/fr/iutfbleau/projetIHM2022FI2/Test/TestTexteMNP.java~ @@ -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()); + } + + +}