source: ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Test.java @ 482

Last change on this file since 482 was 482, checked in by vmipsl, 12 years ago

BO insertion données _ insertion code medias package insertion
  • Property svn:executable set to *
File size: 68.7 KB
Line 
1//TODO
2package integration.principal;
3import integration.lecture_ecriture.EcritureLog;
4import integration.lecture_ecriture.LectureCapteurs;
5import integration.lecture_ecriture.LectureModeleXML;
6import integration.lecture_ecriture.LectureOrganismes;
7import integration.lecture_ecriture.LectureParametres;
8import integration.lecture_ecriture.LecturePersonnes;
9import integration.lecture_ecriture.LecturePlateformes;
10import integration.lecture_ecriture.LectureUnites;
11import integration.prevalidation.PreValidation;
12import integration.repartition.Repartition;
13import integration.utils.Chrono;
14import integration.utils.Constantes;
15import integration.utils.DateTime;
16import integration.utils.Nombre;
17import integration.utils.Statiques;
18import integration.validation.Validation;
19import integration.vues.MesureModele;
20import integration.vues.ParametreModele;
21import integration.vues.PlateformeModele;
22import integration.vues.SequenceModele;
23import integration.vues.ValeurModele;
24import integration.insertion.*;
25import java.io.File;
26import java.util.ArrayList;
27import java.util.Arrays;
28
29
30/**
31 * Created on 24 Jan. 2007
32 *
33 */
34
35/**
36 *
37 * @author
38 *
39 * *******************************************************************************************************************
40 * Classe permettant de prevalider, valider, répartir et inserer un ensemble de fichier d'un jeu donné.                        *
41 * *******************************************************************************************************************
42 */
43
44public class Test {
45
46
47        public static void main(String[] args) {
48                // Argument 0 : LE NOM DE LA CATEGORIE
49                String nomCategorie = args[0];
50                // Argument 1 : LE NOM DU JEU
51                String nomJeu = args[1];
52
53                /**
54                 * Lancement du chronométre
55                 *
56                */ 
57               
58                Chrono chrono = new Chrono();
59                Chrono chronoFichier;
60                Chrono chronoMeta;
61                Chrono chronoFin;
62                chrono.start();
63                // Fichier de log
64                EcritureLog.init(nomJeu, nomCategorie);
65                // ************ On recherche les fichiers du jeu
66                // ************************
67                String cheminJeu = Constantes.cheminDonnees + nomCategorie + "/" + nomJeu
68                                + "/";
69                String cheminFichier;
70                PreValidation preValidation;
71                Validation validation;
72                ArrayList<String> listeMesures = null;
73                ArrayList<ArrayList<String>> listeDonnees = null;
74                int nbErreursValidation;
75//              Fichier fichier;
76                MesureModele mesureModele;
77//              ValeurModele valeurModele = null;
78//              Valeur valeur = null;
79                ArrayList<ValeurModele> valeursMesure = null;
80                ArrayList<String> donneesMesure = null;
81//              Mesure mesure = null;
82//              String numSeqPrecedent = null;
83                //Bilan bilan = null;
84//              int flagLocId;
85                //int flagValId;
86//              int flagValidId;
87                // On récupére tous les fichiers du répertoire
88                File fileCourant = new File(cheminJeu);
89                String[] listeFichiers = fileCourant.list();
90                // S'il y a au moins un fichier dans le jeu
91                if (listeFichiers.length != 0) {
92                        chronoMeta = new Chrono();
93                        chronoMeta.start();
94                        // Trier les fichiers par ordre alphabétique
95                        Arrays.sort(listeFichiers);
96                        // Etape 3 : On lit le modéle XML du jeu
97                        LectureModeleXML lectureModeleXML = new LectureModeleXML(nomCategorie,nomJeu);
98                        lectureModeleXML.lireModele();
99                        ArrayList<ParametreModele> parametresModele = lectureModeleXML.getParametres();
100//                      ArrayList<ParametreModele> parametresValeur = lectureModeleXML.getParametresValeur();
101                        // Etape 4 : On lit les listes EXCEL de capteurs, paramétres, plateformes, ...
102                        LectureCapteurs lectureCapteurs = new LectureCapteurs();
103                        lectureCapteurs.lireFichier();
104                        LecturePlateformes lecturePlateformes = new LecturePlateformes();
105                        lecturePlateformes.lireFichier();
106                        LectureParametres lectureParametres = new LectureParametres();
107                        lectureParametres.lireFichier();
108                        LecturePersonnes lecturePersonnes = new LecturePersonnes();
109                        lecturePersonnes.lireFichier();
110                        LectureUnites lectureUnites = new LectureUnites();
111                        lectureUnites.lireFichier();
112//                      ArrayList<String> codesUnite = lectureUnites.getCodesUni();
113                        LectureOrganismes lectureOrganismes = new LectureOrganismes();
114                        lectureOrganismes.lireFichier();                       
115                        // Etape 5 : Répartition des métadonnées du jeu
116                        Statiques.plateformesModele = new ArrayList<PlateformeModele>();
117                        Repartition repartition = new Repartition(lectureModeleXML, lectureCapteurs, lecturePlateformes, lectureParametres, lecturePersonnes, lectureUnites,lectureOrganismes);
118//                      ArrayList<Personne> personnes = repartition.repartirPersonnes();
119//                      Jeu jeu = repartition.repartirJeu(personnes);
120//                      ArrayList<Parametre> parametres = repartition.repartirParametres(jeu);
121//                      ArrayList<Capteur> capteurs = repartition.repartirCapteurs(parametres);
122//                      ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
123                        // Etape 10 : Insertion des métadonnées du jeu
124                        /**---
125                         *
126                         * */
127//                      --------
128                        Insertion insertion = new Insertion();
129                        try {
130                                synchronized (Principal.class) {
131//                                     
132//                              // On ouvre la connexion
133//                                      //------------
134                                        //--------
135//                                      CommunicationBD.open();
136//                              //System.out.println("---ouvert----");
137//                              // insertion du jeu
138//                              //------
139//                              ////--------
140//                                      insertion.insererJeu(jeu);
141//                              //System.out.println("----"+jeu);
142//                              // Insertion des parametres
143//                             
144//                              /**--*/
145//                              /*
146//                               *
147//                               */
148//                                      Parametre parametre ;
149/**                             for(int numParam = 0; numParam < parametres.size(); numParam++){
150                                        parametre = parametres.get(numParam);
151//                                      //--------
152                                        insertion.insererParametre(parametre);
153//                                      System.out.println("par="+parametre.getParametreNom());
154                                }*/
155//                             
156//                              // Insertion des capteurs
157//                      Capteur capteur = null;
158/**                             for(int numCapt = 0; numCapt < capteurs.size(); numCapt++){
159                                        capteur = capteurs.get(numCapt);
160                                        //--------
161                                        insertion.insererCapteur(capteur,parametres);
162//     
163//                                     
164                                }*/
165//                             
166//                              // Insertion des plateformes
167//                              /**
168//                               *
169//                               */
170/**                             Plateforme plateforme = null;
171                                for(int numPlat = 0; numPlat < plateformes.size(); numPlat++){
172                                        plateforme = plateformes.get(numPlat);
173//                                     
174                                        ////--------
175                                        insertion.insererPlateforme(plateforme,capteurs);
176//                                     
177//                                      //--System.out.println("PLAT="+plateforme.getPlateformeNom());
178                                }/**/
179//                              // On ferme la connexion
180//                              ////--------
181//                              CommunicationBD.close();
182                               
183                                chronoMeta.stop();
184                                chronoMeta.afficheChrono("METADONNEES");
185                               
186//                              /*****************************************************************************************************
187//                              * On parcourt les fichiers du jeu                                                                                                                                        *
188//                              ******************************************************************************************************
189//                              */
190//                              // Initialisations
191                                /*****************************/
192                               
193                                Statiques.sequencesModeles = new ArrayList<SequenceModele>();
194
195                                Statiques.dateMinJeu = DateTime.stringToDate(Constantes.datePlusInf,Constantes.formatDateJJMMAAAAHHMMSS);
196                                Statiques.dateMaxJeu = DateTime.stringToDate(Constantes.dateMoinsInf,Constantes.formatDateJJMMAAAAHHMMSS);
197                                // Initialialisation des :  altitude,latitude, longitude et hauteur sol.
198                                // On onvertit une altitude, latitude, longitude ou hauteur sol de Double vers Integer.
199                                // altitude du jeu
200                                Statiques.altMaxJeu = Nombre.altDoubleToInt(Double.valueOf(Constantes.altitudeMoinsInf));
201                                Statiques.altMinJeu = Nombre.altDoubleToInt(Double.valueOf(Constantes.altitudePlusInf));
202                                // latitude du jeu
203                                Statiques.latMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudeMoinsInf));
204                                Statiques.latMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudePlusInf));
205                                // longitude du jeu
206                                Statiques.lonMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudeMoinsInf));
207                                Statiques.lonMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudePlusInf));
208                                // hauteur sol du jeu
209                                Statiques.hsMaxJeu =  Nombre.altDoubleToInt(Double.valueOf(Constantes.hsMoinsInf));
210                                Statiques.hsMinJeu = Nombre.altDoubleToInt(Double.valueOf(Constantes.hsPlusInf));
211               
212                                int nbFichiers = 0;
213//                              int nbMesures = 0;
214//                              int nbValeurs = 0;
215                                int indiceNiv = -1;
216//                              int nbNiv;
217//                              int indiceParam = 0;
218//                              int cptNiv, cptParam;
219                                nbFichiers = listeFichiers.length;
220                                for (int numFic = 0; numFic < nbFichiers; numFic++) {
221                                        chronoFichier = new Chrono();
222                                        chronoFichier.start();
223                                        cheminFichier = cheminJeu + listeFichiers[numFic];
224                                        fileCourant = new File(cheminFichier);
225                                        // Si le fichier existe et n'est pas vide
226                                        if (fileCourant.exists()) {
227                                                EcritureLog.ecrire("Fichier " + fileCourant.getName(), "out-ln");
228                                                // Etape 1 : prévalidation : On prévalide le fichier
229                                                preValidation = new PreValidation(fileCourant);
230                                                preValidation.prevalider(null,null,null,null,null,nomJeu);
231                                                viderPrevalidation(preValidation, fileCourant);
232                                                EcritureLog.ecrire("  -> Prévalidation OK", "out-ln");
233                                                //System.out.println("\n");
234                                                //for(int numListM = /*listeMesures.size()-2*/0; numListM < /*listeMesures.size()*/2; numListM++){
235                                                        //System.out.println(listeMesures.get(numListM));
236                                                //}
237                                                // Etape 2 : validation : On valide le fichier
238
239                                               
240                                                //-----------traitement de la validation
241                                                validation = new Validation(preValidation);
242                                                        listeDonnees = validation.valider(lectureModeleXML,fileCourant.getName());
243                                                        indiceNiv = validation.getIndiceNiv();
244                                                        nbErreursValidation = validation
245                                                                        .getNbErreursTotales();
246                                                        viderValidation(validation, listeMesures);
247                                                        if (nbErreursValidation == 0) {
248                                                                EcritureLog.ecrire("  -> Validation OK",
249                                                                                "out-ln");
250                                                                System.out.println("\n");
251                                                        }
252
253                                                       
254                                                          /**ArrayList<String> donnees; for(int numListD = 0;
255                                                          *numListD < listeDonnees.size(); numListD++){ donnees =
256                                                          *listeDonnees.get(numListD); for(int numDonnee =
257                                                          *0; numDonnee < /*donnees.size()*///37; numDonnee++){
258                                                          /*System.out.print(" *** "+donnees.get(numDonnee)); }
259                                                          *System.out.println(); }*/
260                                                         
261                                                        // traitement de la repartion
262                                                        // Etape 5 : répartition du fichier
263//                                                      fichier = repartition.repartirFichier(jeu,fileCourant);
264                                                        //System.out.println("***********"+fileCourant);
265                                                        // On ouvre la connexion
266                                                        ////--------
267//                                                      CommunicationBD.open();
268                                                        // Etape 10 : insertion du fichier
269                                                        //--------
270//                                                      insertion.insererFichier(fichier);
271//
272                                                        // Pour chaque mesure...
273                                                        // /***
274//                                                      nbMesures += listeDonnees.size();
275                                                        for (int numMesure = 0; numMesure < 2/*listeDonnees
276                                                                        .size()*/; numMesure++) {
277//                                                              ////--------
278//                                                              //flagLocId = insertion.getFlagLocId();
279                                                                donneesMesure = listeDonnees.get(numMesure);
280                                                               
281                                                                // Etape 6 : Rangement des données sur la ligne
282                                                                // et répartition des séquences
283                                                                //mesureModele = repartition.repartirDonnees(donneesMesure, numSeqPrecedent,parametresModele, indiceNiv);
284                                                                //
285                                                                //numSeqPrecedent = mesureModele.getNumSequence();
286                                                                //mesureModele = repartition.repartirDonnees(donneesMesure, numSeqPrecedent, parametresModele, indiceNiv);
287                                                                mesureModele = repartition.repartirDonnees(donneesMesure,parametresModele);
288//                                                              numSeqPrecedent = mesureModele.getNumSequence();
289                                                                // Etape 7 : repartition de la mesure
290//                                                              mesure = repartition.repartirMesure(mesureModele, fichier, plateformes);
291//System.out.println("mesure="+DateTime.dateToString(mesure.getMesureDate(),Constantes.formatDateJJMMAAAAHHMMSS));
292//System.out.println("mesure pos="+Nombre.altIntToFloat(mesure.getLocalisation().getLocalisationAlt()));
293                                                                // Si le fichier n'existe pas encore, on insére
294                                                                // les mesures et les valeurs
295                                                                // --
296                                                                if (!insertion.isFichierExiste()) {
297                                                                // Etape 11 : Insertion de la mesure
298                                                                ////--------
299                                                                //
300                                                                //insertion.insererMesure(mesure, flagLocId);
301                                                                valeursMesure = mesureModele.getValeursMesure();
302                                                                // Pour chaque valeur...
303//                                                              nbValeurs += valeursMesure.size();
304//                                                              nbNiv = valeursMesure.size() / parametres.size();
305//                                                              cptNiv = 0;
306//                                                              cptParam = 0;
307                                                                for (int numValeur = 0; numValeur < valeursMesure.size(); numValeur++) {
308//                                                                      ////--------
309//                                                                      //flagValId = insertion.getFlagValId();
310//                                                              //      flagValidId = insertion.getFlagValidId();
311//                                                                      valeurModele = valeursMesure.get(numValeur);
312                                                                        // Si pas subdivision
313                                                                        if (indiceNiv == -1) {
314//                                                                              indiceParam = numValeur;                                                                               
315                                                                        }
316//                                                                      }
317//                                                                      // Si subdivision
318                                                                        else {
319//                                                                              cptNiv++;
320                                                                        }
321//                                                                              // Cas oé on arrive é la derniére donnée du paramétre courant
322//                                                                              if (cptNiv > nbNiv) {
323//                                                                                      cptParam++;
324//                                                                                      cptNiv = 1;
325//                                                                              }
326//                                                                              indiceParam = cptParam;
327                                                                        }
328                                                                        // Etape 9 : repartition de la valeur
329//                                                                      valeur = repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),
330//                                                                              valeurModele, capteurs, parametres.get(indiceParam), parametres.get(indiceParam).getUnite()
331//                                                                                      .getUniteCode(),parametresValeur.get(indiceParam),codesUnite);
332                                                                        // Etape 12 : insertion de la valeur
333                                                                        ////--------
334                                                                        //System.out.println("------00-------");
335                                                                        //insertion.insererValeur(valeur, /*flagValId*/flagValidId);
336                                                                        //System.out.println("-------------");
337                                                                }
338                                                        }
339                                                }
340
341                                                // On ferme la connexion
342                                                ////--------
343                                                        //**
344                                        //              CommunicationBD.close();
345
346//                                              EcritureLog.ecrire("  -> Répartition-Insertion OK","out");
347                                        } // ---*/
348                                        /** ---viderRepartition(listeDonnees);-- */
349//
350//                                      else { EcritureLog.ecrire("Fichier " +
351//                                        fileCourant.getName()+ " non trouvé !", "err");
352//                                      }
353//                                       
354//                                     
355//                                        chronoFichier.stop(); chronoFichier.afficheChrono(" -> FICHIER");
356//                                       
357//                                       }
358                                        chronoFin = new Chrono();
359                                        chronoFin.start();
360                                        // Etape 8 : répartition de la derniére séquence
361                                        ////--------
362//                                      repartition.repartirDerniereSequence();
363                                        // Etape 13 : répartition et insertion des séquences
364//                                      SequenceModele sequenceModele;
365//                                      Sequence sequence;
366
367                                        // On ouvre la connexion
368                                        // ---
369        //                              CommunicationBD.open();
370                                        for (int numSeq = 0; numSeq < Statiques.sequencesModeles
371                                                        .size(); numSeq++) {
372//                                              sequenceModele = Statiques.sequencesModeles.get(numSeq);
373                //                              sequence = repartition.repartirSequence(jeu,sequenceModele);
374                                                ////--------
375                //                              insertion.insererSequence(sequence);
376                                                // insertion.insererSequence(sequence, numSeq);
377                                                // Mettre é jour les mesures
378                                                // Mise é jour des mesures appartenant é la séquence
379                                                // ---
380                        //                      insertion.mettreAjourMesure(sequence);
381
382                                        }
383                                        /**
384                                         * ---EcritureLog.ecrire(" 0 Mesure : mise é jour -> Ok",
385                                         * "out"); EcritureLog.ecrire("Séquences mises é jour",
386                                         * "out"); // Mettre é jour le jeu
387                                         * insertion.mettreAjourJeu(jeu); EcritureLog.ecrire(" 1 Jeu
388                                         * mis é jour : jeu -> OK", "out"); // Mettre é jour les
389                                         * tables requetes capteurs du jeu
390                                         * insertion.mettreAJourRequeteCapteurJeu(jeu, capteurs);
391                                         * EcritureLog.ecrire(" 2 Liaisons entre : jeu/capteurs ->
392                                         * OK", "out"); // Mettre é jour les les tables requetes des
393                                         * parametres du jeu
394                                         * insertion.mettreAJourRequeteParametreJeu(jeu,
395                                         * parametres); EcritureLog.ecrire(" 3 Liaisons entre :
396                                         * jeu/parametres -> OK", "out"); // Mettre é jour les les
397                                         * tables requetes des plateformes du jeu
398                                         * insertion.mettreAJourRequetePlateformeJeu(jeu,
399                                         * plateformes); EcritureLog.ecrire(" 4 Liaisons entre :
400                                         * jeu/plateformes -> OK", "out"); // Mettre é jour les les
401                                         * tables requetes nbvals
402                                         * insertion.mettreAJourRequeteNbValsJeu(jeu,nbFichiers,nbMesures,
403                                         * nbValeurs); EcritureLog.ecrire(" 5 Liaisons entre :
404                                         * jeu/nbFichiers/nbMesures/nbValeurs -> OK", "out"); //
405                                         * Mettre é jour les tables requetes des parametres des
406                                         * plateformes
407                                         * insertion.mettreAJourRequeteParametreCapteur(capteurs,
408                                         * parametres); EcritureLog.ecrire(" 6 Liaisons entre :
409                                         * capteurs/parametres -> OK", "out"); // Mettre é jour les
410                                         * tables requetes des plateformes des capteurs
411                                         * insertion.mettreAJourRequeteCapteurPlateforme(plateformes,
412                                         * capteurs); EcritureLog.ecrire(" 7 Liaisons entre :
413                                         * plateformes/capteurs -> OK", "out"); // Mettre é jour de
414                                         * la liaison entre les plateformes et les parametres.
415                                         * insertion.mettreAJourRequeteParametrePlateforme(plateformes,parametres);
416                                         * EcritureLog.ecrire(" 8 Liaisons entre :
417                                         * plateformes/paramétres -> OK", "out"); // Mise é jour de
418                                         * la liaison entre les plateformes et les localisations.
419                                         * insertion.mettreAJourRequeteLocalisationsPlateforme(plateformes);
420                                         * EcritureLog.ecrire(" 9 Liaisons localisations/plateformes ->
421                                         * OK", "out"); CommunicationBD.close();
422                                         * CommunicationBD.open(); // Insertion de la table bilan
423                                         * insertion.insererBilan(jeu, plateformes, capteurs,
424                                         * parametres); EcritureLog.ecrire(" 10 Insertion : bilan ->
425                                         * Ok", "out"); // Mettre é jour de la liaison entre le
426                                         * bilan. insertion.mettreAJourBilan(jeu);
427                                         * EcritureLog.ecrire(" 11 Bilan mis é jour", "out"); // On
428                                         * ferme la connexion CommunicationBD.close();
429                                         * EcritureLog.ecrire(" 12 Insertion du jeu terminée",
430                                         * "out");---
431                                         */
432                                        // Fin du chrono
433                                        chronoFin.stop();
434                                        System.out.println("\n");
435                                        chronoFin.afficheChrono("FINAL");
436
437                                        /**************************** */
438
439                                }
440                        } catch (Exception e) {
441                                e.printStackTrace();
442                        }
443
444                } else {
445                        //EcritureLog.ecrire("Pas de fichiers é valider dans le jeu "+ Constantes.nomJeuAMDAR, "err");
446                        EcritureLog.ecrire("Pas de fichiers é valider dans le jeu ", "err");
447                }
448                /**
449                 * Arrét du chronométre
450                 *
451                 */
452                chrono.stop();
453                chrono.afficheChrono("TOTAL");
454        }
455       
456        /**
457         * Libérer la mémoire aprés la repartition d'un fichier donné.
458         *
459         */
460        /**---private static void viderRepartition(ArrayList<ArrayList<String>> listeDonnees) {
461                listeDonnees = null;
462        }*/
463
464        /**
465         * Libérer la mémoire aprés la validation d'un fichier donné.
466         *
467         */
468        private static void viderValidation(Validation validation,
469                        ArrayList<String> listeMesures) {
470                validation = null;
471                listeMesures = null;
472        }
473       
474        /**
475         * Libérer la mémoire aprés la prévalidation d'un fichier donné.
476         *
477         */
478        private static void viderPrevalidation(PreValidation preValidation,
479                        File fichier) {
480                preValidation = null;
481                fichier = null;
482        }
483
484}
485
486/*************************************************************************************/
487///*
488// * Created on 30 Jan. 2007
489// */
490///**
491// * @author
492// *
493// *
494// */
495//package integration.principal;
496//
497//import java.io.File;
498//// import java.math.BigDecimal;
499//import java.util.ArrayList;
500//import java.util.Arrays;
501//
502////import org.hibernate.type.IntegerType;
503//// import java.util.Iterator;
504//// import java.util.List;
505//
506//// import EDU.oswego.cs.dl.util.concurrent.FJTask.Seq;
507//
508//// import integration.hibernate.Adresse;
509//import integration.hibernate.Capteur;
510//// import integration.hibernate.Categorie;
511//// import integration.hibernate.Commentaire;
512//// import integration.hibernate.DeltaMesure;
513//import integration.hibernate.Fichier;
514//import integration.hibernate.Jeu;
515//// import integration.hibernate.Langue;
516//// import integration.hibernate.Localisation;
517//import integration.hibernate.Mesure;
518//import integration.hibernate.Parametre;
519//import integration.hibernate.Personne;
520//import integration.hibernate.Plateforme;
521//import integration.hibernate.Sequence;
522//import integration.hibernate.Valeur;
523//import integration.insertion.Insertion;
524//import integration.lecture_ecriture.EcritureLog;
525//import integration.lecture_ecriture.LectureCapteurs;
526//import integration.lecture_ecriture.LectureModeleXML;
527//import integration.lecture_ecriture.LectureOrganismes;
528//import integration.lecture_ecriture.LectureParametres;
529//import integration.lecture_ecriture.LecturePersonnes;
530//import integration.lecture_ecriture.LecturePlateformes;
531//import integration.lecture_ecriture.LectureUnites;
532//import integration.prevalidation.PreValidation;
533//import integration.repartition.Repartition;
534//import integration.utils.Chrono;
535//import integration.utils.CommunicationBD;
536//import integration.utils.Constantes;
537//import integration.utils.DateTime;
538//import integration.utils.Nombre;
539//// import integration.utils.DateTime;
540//// import integration.utils.Nombre;
541//import integration.utils.Statiques;
542//import integration.validation.Validation;
543//import integration.vues.MesureModele;
544//import integration.vues.ParametreModele;
545//import integration.vues.SequenceModele;
546//import integration.vues.ValeurModele;
547//
548//public class Test {
549//
550//      /**
551//       * @param args
552//       */
553//      // **********************************************************************************
554//      // ****************************TestCapteurs******************************************
555//      // **********************************************************************************
556//      // public static void main(String[] args) {
557//      // LectureCapteurs lectureCapteurs = new LectureCapteurs();
558//      // lectureCapteurs.lireFichier();
559//      // for (int num=0; num< Constantes.nbCapteurs; num++){
560//      // System.out.print(lectureCapteurs.getNumerosCapt().get(num));
561//      // System.out.print(" * "+lectureCapteurs.getModelesCapt().get(num));
562//      // System.out.print(" * "+lectureCapteurs.getEtalonnagesCapt().get(num));
563//      // System.out.print(" * "+lectureCapteurs.getNumsSeriesCapt().get(num));
564//      // System.out.print(" * "+lectureCapteurs.getTypesCapt().get(num));
565//      // System.out.print(" * "+lectureCapteurs.getDescriptionsCapt().get(num));
566//      // System.out.print(" * "+lectureCapteurs.getFabriquantsCapt().get(num));
567//      // System.out.print(" * ");
568//      // for (int num2=0;
569//      // num2<lectureCapteurs.getParametresCapt().get(num).size(); num2++){
570//      // System.out.print(" #
571//      // "+lectureCapteurs.getParametresCapt().get(num).get(num2));
572//      // }
573//      // System.out.println();
574//      // }
575//      //     
576//      // }
577//
578//      public static void main(String[] args) {
579//              // Argument 0 : LE NOM DE LA CATEGORIE
580//              String nomCategorie = args[0];
581//              // Argument 1 : LE NOM DU JEU
582//              String nomJeu = args[1];
583//              // ******************************Lancement du chronométre
584//              // **********************************
585//              // Chrono chrono = new Chrono();
586//              // chrono.start();
587//              Chrono chrono = new Chrono();
588//              Chrono chronoFichier;
589//              Chrono chronoMeta;
590//              Chrono chronoFin;
591//              chrono.start();
592//              // Fichier de log
593//              EcritureLog.init(nomJeu, nomCategorie);
594//              // ************ On recherche les fichiers du jeu
595//              // ************************
596//              String cheminJeu = Constantes.cheminDonnees + nomCategorie + "/"
597//                              + nomJeu + "/";
598//              /**
599//               * boolean fichierExiste = false; String cheminFichier; PreValidation
600//               * preValidation; Validation validation; ArrayList<String>
601//               * listeMesures; ArrayList<ArrayList<String>> listeDonnees = null; int
602//               * nbErreursValidation; Fichier fichier = new Fichier(); Localisation
603//               * localisation = new Localisation(); MesureModele mesureModele;
604//               * ValeurModele valeurModele = null; Valeur valeur = null; ArrayList<ValeurModele>
605//               * valeursMesure = null; ArrayList<String> donneesMesure = null; Mesure
606//               * mesure = null; String numSeqPrecedent = null; File fileCourant = new
607//               * File(cheminJeu); String[] listeFichiers = fileCourant.list(); int
608//               * flagLocId; int flagValId;
609//               */
610//              String cheminFichier;
611//              PreValidation preValidation;
612//              Validation validation;
613//              ArrayList<String> listeMesures;
614//              ArrayList<ArrayList<String>> listeDonnees = null;
615//              int nbErreursValidation;
616//              Fichier fichier;
617//              MesureModele mesureModele;
618//              ValeurModele valeurModele = null;
619//              Valeur valeur = null;
620//              ArrayList<ValeurModele> valeursMesure = null;
621//              ArrayList<String> donneesMesure = null;
622//              Mesure mesure = null;
623//              String numSeqPrecedent = null;
624//              int flagLocId;
625//              int flagValId;
626//              // On récupére tous les fichiers du répertoire
627//              File fileCourant = new File(cheminJeu);
628//              String[] listeFichiers = fileCourant.list();
629//              // S'il y a au moins un fichier dans le jeu
630//              if (listeFichiers.length != 0) {
631//                      chronoMeta = new Chrono();
632//                      chronoMeta.start();
633//                      // Trier les fichiers par ordre alphabétique
634//                      Arrays.sort(listeFichiers);
635//                      // Etape 3 : On lit le modéle XML du jeu
636//                      LectureModeleXML lectureModeleXML = new LectureModeleXML(
637//                                      nomCategorie, nomJeu);
638//                      lectureModeleXML.lireModele();
639//                      ArrayList<ParametreModele> parametresModele = lectureModeleXML
640//                                      .getParametres();
641//                      ArrayList<ParametreModele> parametresValeur = lectureModeleXML
642//                                      .getParametresValeur();
643//                      // Etape 4 : On lit les listes EXCEL de capteurs, paramétres,
644//                      // plateformes, ...
645//                      LectureCapteurs lectureCapteurs = new LectureCapteurs();
646//                      lectureCapteurs.lireFichier();
647//                      LecturePlateformes lecturePlateformes = new LecturePlateformes();
648//                      lecturePlateformes.lireFichier();
649//                      LectureParametres lectureParametres = new LectureParametres();
650//                      lectureParametres.lireFichier();
651//                      LecturePersonnes lecturePersonnes = new LecturePersonnes();
652//                      lecturePersonnes.lireFichier();
653//                      LectureUnites lectureUnites = new LectureUnites();
654//                      lectureUnites.lireFichier();
655//                      ArrayList<String> codesUnite = lectureUnites.getCodesUni();
656//                      LectureOrganismes lectureOrganismes = new LectureOrganismes();
657//                      lectureOrganismes.lireFichier();
658//
659//                      // Etape 5 : Répartition des métadonnées du jeu
660//                      Repartition repartition = new Repartition(lectureModeleXML,
661//                                      lectureCapteurs, lecturePlateformes, lectureParametres,
662//                                      lecturePersonnes, lectureUnites, lectureOrganismes);
663//                      ArrayList<Personne> personnes = repartition.repartirPersonnes();
664//                      Jeu jeu = repartition.repartirJeu(personnes);
665//                      ArrayList<Parametre> parametres = repartition.repartirParametres();
666//                      ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
667//                      ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
668//                                     
669//
670//                      // Etape 10 : Insertion des métadonnées du jeu
671//                      Insertion insertion = new Insertion();
672//                      try {
673//                              synchronized (Principal.class) {
674//                                      // On ouvre la connexion
675//                                      CommunicationBD.open();
676//                                      // On insére le jeu
677//                                      insertion.insererJeu(jeu);
678//                                      // CommunicationBD.close();
679//                                      // insertion des parametres
680//                                      // CommunicationBD.open();
681//                                      // insertion des parametres
682//                                      Parametre parametre;
683//                                      for (int numParam = 0; numParam < parametres.size(); numParam++) {
684//                                              parametre = parametres.get(numParam);
685//                                              insertion.insererParametre(parametre);
686//                                      }
687//                                      // insertion des capteurs
688//                                      Capteur capteur;
689//                                      for (int numCapt = 0; numCapt < capteurs.size(); numCapt++) {
690//                                              capteur = capteurs.get(numCapt);
691//                      //                      insertion.insererCapteur(capteur);
692//                                      }
693//                                      // insererPlateforme
694//                                      Plateforme plateforme;
695//                                      for (int numPlat = 0; numPlat < plateformes.size(); numPlat++) {
696//                                              plateforme = plateformes.get(numPlat);
697//                      //                      insertion.insererPlateforme(plateforme);
698//                                      }
699//                                      //On ferme la connexion
700//                                      CommunicationBD.close();
701//                                      chronoMeta.stop();
702//                                      System.out.println("TEST DEMARRé");
703//                                      chronoMeta.afficheChrono("METADONNEES");
704//                     
705//                                      // insertion fichier
706//                                      // **************************************************************************************************
707//                                      // On parcourt les fichiers du jeu
708//                                      // ****************************************************************************************************
709//                                      // Statiques.sequencesModeles = new
710//                                      // ArrayList<SequenceModele>();
711//                                      // for (int numFic = 0; numFic < 1/*listeFichiers.length*/;
712//                                      // numFic++) {
713//                                      /**
714//                                       * cheminFichier = cheminJeu + listeFichiers[numFic];
715//                                       * fileCourant = new File(cheminFichier); // Si le fichier
716//                                       * existe et n'est pas vide if (fileCourant.exists()) {
717//                                       * EcritureLog .ecrire("Fichier " + fileCourant.getName(),
718//                                       * "out-ln"); // Etape 1 : prévalidation : On prévalide le
719//                                       * fichier preValidation = new PreValidation(nomJeu,
720//                                       * fileCourant); listeMesures = preValidation.prevalider();
721//                                       * viderPrevalidation(preValidation, fileCourant);
722//                                       * EcritureLog.ecrire(" -> Prévalidation OK", "out-ln");
723//                                       * //insertion // Etape 2 : validation : On valide le
724//                                       * fichier validation = new Validation(listeMesures);
725//                                       * listeDonnees = validation.valider(lectureModeleXML);
726//                                       * nbErreursValidation = validation.getNbErreursTotales();
727//                                       * viderValidation(validation, listeMesures); if
728//                                       * (nbErreursValidation == 0) { EcritureLog.ecrire(" ->
729//                                       * Validation OK", "out-ln"); // Etape 5 : répartition du
730//                                       * fichier fichier =
731//                                       * repartition.repartirFichier(jeu,fileCourant); //boolean
732//                                       * fichierExiste = false; fichierExiste =
733//                                       * insertion.insererFichier(fichier); //if (fichierExiste =
734//                                       * false) { }
735//                                       */
736//                                      // **************************************************************************************************
737//                                      // On parcourt les fichiers du jeu
738//                                      // ****************************************************************************************************
739//                                      // initialisations des dates.
740//                                      Statiques.sequencesModeles = new ArrayList<SequenceModele>();
741//                                      //les mettre ds constantes
742//                                      Statiques.dateMinJeu = DateTime.stringToDate(Constantes.datePlusInf,Constantes.formatDateJJMMAAAAHHMMSS);
743//                                      Statiques.dateMaxJeu = DateTime.stringToDate(Constantes.dateMoinsInf,Constantes.formatDateJJMMAAAAHHMMSS);
744//                                      // initialialisation des :  altitude,latitude, longitude et hauteur sol.
745//                                      // On onvertit une altitude, latitude, longitude ou hauteur sol de Double vers Integer.
746//                                      // altitude du jeu
747//                                      Statiques.altMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.altitudeMoinsInf));
748//                                      Statiques.altMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.altitudePlusInf));
749//                                      // latitude du jeu
750//                                      Statiques.latMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudeMoinsInf));
751//                                      Statiques.latMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudePlusInf));
752//                                      // longitude du jeu
753//                                      Statiques.lonMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudeMoinsInf));
754//                                      Statiques.lonMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudePlusInf));
755//                                      // hauteur sol du jeu
756//                                      Statiques.hsMaxJeu =  Nombre.latDoubleToInt(Double.valueOf(Constantes.hsMoinsInf));
757//                                      Statiques.hsMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.hsPlusInf));
758//                                      for (int numFic = 0; numFic < listeFichiers.length; numFic++) {
759//                                              chronoFichier = new Chrono();
760//                                              chronoFichier.start();
761//                                              cheminFichier = cheminJeu + listeFichiers[numFic];
762//                                              fileCourant = new File(cheminFichier);
763//                                              // Si le fichier existe et n'est pas vide
764//                                              if (fileCourant.exists()) {
765//                                                      EcritureLog.ecrire("Fichier "
766//                                                                      + fileCourant.getName(), "out-ln");
767//                                                      // Etape 1 : prévalidation : On prévalide le fichier
768//                                                      preValidation = new PreValidation(nomJeu,
769//                                                                      fileCourant);
770//                                                      listeMesures = preValidation.prevalider();
771//                                                      viderPrevalidation(preValidation, fileCourant);
772//                                                      EcritureLog.ecrire("  -> Prévalidation OK",
773//                                                                      "out-ln");
774//                                                      // Etape 2 : validation : On valide le fichier
775//                                                      validation = new Validation(listeMesures);
776//                                                      listeDonnees = validation.valider(lectureModeleXML);
777//                                                      nbErreursValidation = validation
778//                                                                      .getNbErreursTotales();
779//                                                      viderValidation(validation, listeMesures);
780//                                                      if (nbErreursValidation == 0) {
781//                                                              EcritureLog.ecrire("  -> Validation OK",
782//                                                                              "out-ln");
783//                                                              // Etape 5 : répartition du fichier
784//                                                              fichier = repartition.repartirFichier(jeu,
785//                                                                              fileCourant);
786//                                                              // On ouvre la connexion
787//                                                              CommunicationBD.open();
788//                                                              // Etape 10 : insertion du fichier
789//                                                              insertion.insererFichier(fichier);
790//                                                              // for (int numMesure = 0; numMesure <
791//                                                              // listeDonnees.size(); numMesure++) {
792//                                                              //                                                             
793//                                                              // donneesMesure = listeDonnees.get(numMesure);
794//                                                              // mesureModele =
795//                                                              // repartition.repartirDonnees(donneesMesure,
796//                                                              // numSeqPrecedent,parametresModele);
797//                                                              // numSeqPrecedent =
798//                                                              // mesureModele.getNumSequence();
799//                                                              // mesure =
800//                                                              // repartition.repartirMesure(mesureModele,
801//                                                              // fichier, plateformes);
802//                                                              //                                                             
803//                                                              // if (!fichierExiste) {
804//                                                              // // Insertion de la mesure
805//                                                              // insertion.insererMesure(mesure);
806//                                                              //                                                             
807//                                                              // valeursMesure =
808//                                                              // mesureModele.getValeursMesure();
809//                                                              // // Pour chaque valeur...
810//                                                              // for(int numValeur = 0; numValeur <
811//                                                              // valeursMesure.size() ; numValeur++){
812//                                                              // valeurModele = valeursMesure.get(numValeur);
813//                                                              // // Etape 9 : repartition de la valeur
814//                                                              // valeur =
815//                                                              // repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),valeurModele,capteurs,parametres.get(numValeur),parametresValeur.get(numValeur),codesUnite);
816//                                                              // // insertion de la valeur
817//                                                              // insertion.insererValeur(valeur);
818//                                                              //                                                                             
819//                                                              // }
820//                                                              // Pour chaque mesure...
821//                                                              for (int numMesure = 0; numMesure < listeDonnees
822//                                                                              .size(); numMesure++) {
823//                                                                      flagLocId = insertion.getFlagLocId();
824//                                                                      donneesMesure = listeDonnees.get(numMesure);
825//                                                                      // Etape 6 : Rangement des données sur la
826//                                                                      // ligne et répartition des séquences
827//                                                                      mesureModele = repartition.repartirDonnees(
828//                                                                                      donneesMesure, numSeqPrecedent,
829//                                                                                      parametresModele);
830//                                                                      numSeqPrecedent = mesureModele
831//                                                                                      .getNumSequence();
832//                                                                      // Etape 7 : repartition de la mesure
833//                                                                      mesure = repartition.repartirMesure(
834//                                                                                      mesureModele, fichier, plateformes);
835//                                                                      // Si le fichier n'existe pas encore, on
836//                                                                      // insére les mesures et les valeurs
837//                                                                      if (!insertion.isFichierExiste()) {
838//                                                                              // Etape 11 : Insertion de la mesure
839//                                                                              insertion.insererMesure(mesure,
840//                                                                                              flagLocId);
841//                                                                              valeursMesure = mesureModele
842//                                                                                              .getValeursMesure();
843//                                                                              // Pour chaque valeur...
844//                                                                              for (int numValeur = 0; numValeur < valeursMesure
845//                                                                                              .size(); numValeur++) {
846//                                                                                      flagValId = insertion
847//                                                                                                      .getFlagValId();
848//                                                                                      valeurModele = valeursMesure
849//                                                                                                      .get(numValeur);
850//                                                                                      // Etape 9 : repartition de la
851//                                                                                      // valeur
852//                                                                                      valeur = repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),
853//                                                                                                                      valeurModele,capteurs,parametres.get(numValeur),
854//                                                                                                                      parametres.get(numValeur).getUnite().getUniteCode(),
855//                                                                                                                      parametresValeur.get(numValeur),codesUnite);
856//                                                                                      // Etape 12 : insertion de la valeur
857//                                                                                      insertion.insererValeur(valeur,flagValId);
858//                                                                              }
859//                                                                      }
860//
861//                                                                      // valeursMesure =
862//                                                                      // mesureModele.getValeursMesure();
863//                                                                      // insertion.insererLoc(localisation);
864//
865//                                                              }
866//
867//                                                              // On ferme la connexion
868//                                                              CommunicationBD.close();
869//
870//                                                              EcritureLog.ecrire(
871//                                                                              "  -> Répartition-Insertion OK",
872//                                                                              "out-ln");
873//                                                      }
874//                                                      viderRepartition(listeDonnees);
875//                                              } else {
876//                                                      EcritureLog.ecrire("Fichier "
877//                                                                      + fileCourant.getName() + " non trouvé !",
878//                                                                      "err");
879//                                              }
880//                                              chronoFichier.stop();
881//                                              chronoFichier.afficheChrono("  -> FICHIER");
882//                                      }
883//                                      chronoFin = new Chrono();
884//                                      chronoFin.start();
885//                                      // Etape 8 : répartition de la derniére séquence
886//                                      repartition.repartirDerniereSequence();
887//                                      // Etape 13 : répartition et insertion des séquences
888//                                      SequenceModele sequenceModele;
889//                                      Sequence sequence;
890//                                      // On ouvre la connexion
891//                                      CommunicationBD.open();
892//                                      //int nbMesures;
893//                                      for (int numSeq = 0; numSeq < Statiques.sequencesModeles
894//                                                      .size(); numSeq++) {
895//                                              sequenceModele = Statiques.sequencesModeles.get(numSeq);
896//                                              sequence = repartition.repartirSequence(jeu,
897//                                                              sequenceModele);
898//                                               insertion.insererSequence(sequence);
899//                                              // Mise é jour des mesures appartenant é la séquence
900//                                               insertion.mettreAjourMesure(sequence);
901//                                      }
902//                                      // Mettre é jour le jeu
903//                                      insertion.mettreAjourJeu(jeu);
904//                                      // Mettre é jour les tables requetes
905//                                      // insertion.mettreAjourRequete();
906//                                      // Mettre é jour la table bilan
907//                    /**insertion.insererBilan();*/
908//                                      // On ferme la connexion
909//                                      CommunicationBD.close();
910//                                      chronoFin.stop();
911//                                      chronoFin.afficheChrono("FINAL");
912//
913//                              }
914//                      } catch (Exception e) {
915//                              e.printStackTrace();
916//                      }
917//
918//              } else {
919//                      EcritureLog.ecrire("Pas de fichiers é valider dans le jeu "
920//                                      + Constantes.nomJeuAMDAR, "err");
921//              }
922//              // ******************************Arrét du chronométre
923//              chrono.stop();
924//              chrono.afficheChrono("TOTAL");
925//      }
926//
927//      /**
928//       * Libérer la mémoire aprés la repartition d'un fichier donné.
929//       *
930//       */
931//      private static void viderRepartition(
932//                      ArrayList<ArrayList<String>> listeDonnees) {
933//              listeDonnees = null;
934//      }
935//
936//      /**
937//       * Libérer la mémoire aprés la validation d'un fichier donné.
938//       *
939//       */
940//      private static void viderValidation(Validation validation,
941//                      ArrayList<String> listeMesures) {
942//              validation = null;
943//              listeMesures = null;
944//      }
945//
946//      /**
947//       * Libérer la mémoire aprés la prévalidation d'un fichier donné.
948//       *
949//       */
950//      private static void viderPrevalidation(PreValidation preValidation,
951//                      File fichier) {
952//              preValidation = null;
953//              fichier = null;
954//      }
955//
956//}
957//
958///*******************************************************************************
959// * } }
960// *
961// * //insertion sequences //repartition.repartirDerniereSequence(); //boucler
962// * pour inserer tte les sequences modéles
963// *  // Sequence sequence = repartition.repartirSequence(jeu, sequenceModele); //
964// * //insertion.insererSequence(sequence); //
965// *
966// *  // Pour chaque mesure...
967// *
968// * //DeltaMesure deltaMesure = null; //insertion. insererDelta(deltaMesure); //
969// *  //
970// *  // On ferme la connexion CommunicationBD.close(); } } catch (Exception e) {
971// * e.printStackTrace(); } } }
972// ******************************************************************************/
973//
974///**
975// * Libérer la mémoire aprés la repartition d'un fichier donné.
976// *
977// */
978//// private static void viderRepartition(ArrayList<ArrayList<String>>
979//// listeDonnees) {
980//// listeDonnees = null;
981//// }
982///**
983// * Libérer la mémoire aprés la validation d'un fichier donné.
984// *
985// */
986//// private static void viderValidation(Validation validation,
987//// ArrayList<String> listeMesures) {
988//// validation = null;
989//// listeMesures = null;
990//// }
991///**
992// * Libérer la mémoire aprés la prévalidation d'un fichier donné.
993// *
994// */
995//// private static void viderPrevalidation(PreValidation preValidation,
996//// File fichier) {
997//// preValidation = null;
998//// fichier = null;
999//// }
1000//// }
1001//// ***********************************************//
1002//// categorie
1003//// try {
1004//// CommunicationBD.open();
1005//// List cats = CommunicationBD.getAllList(Categorie.class);
1006//// Categorie cat;
1007//// for (int i=0; i<cats.size(); i++) {
1008//// cat = (Categorie) cats.get(i);
1009//// System.out.println("cat="+cat.getCategorieNom());
1010//// }
1011//// CommunicationBD.close();
1012//// } catch (Exception e) {
1013//// TODO Auto-generated catch block
1014//// e.printStackTrace();
1015//// }
1016//// commentaire
1017//// try {
1018//// CommunicationBD.open();
1019//// List coms = CommunicationBD.getAllList(Commentaire.class);
1020//// Commentaire com;
1021//// for (int i=0; i<coms.size(); i++) {
1022//// com = (Commentaire) coms.get(i);
1023//// System.out.println("\ncommentaire = " + com.getCommentaireTxt());
1024//// }
1025//// CommunicationBD.close();
1026//// } catch (Exception e) {
1027//// // TODO Auto-generated catch block
1028//// e.printStackTrace();
1029//// }
1030//// adresses
1031//// try {
1032//// CommunicationBD.open();
1033//// List adrs = CommunicationBD.getAllList(Adresse.class);
1034//// Adresse adr;
1035//// for (int i=0; i<adrs.size(); i++) {
1036//// adr = (Adresse) adrs.get(i);
1037//// System.out.println("\nAdresseId = " + adr.getAdresseId());
1038//// System.out.println("\nAdressePays= " + adr.getAdressePays());
1039//// System.out.println("\nAdresseRue = " + adr.getAdresseRue());
1040//// System.out.println("\nAdresseVille = " + adr.getAdresseVille());
1041//// System.out.println("\nAdresseZip = " + adr.getAdresseZip());
1042//// }
1043//// CommunicationBD.close();
1044//// } catch (Exception e) {
1045//// // TODO Auto-generated catch block
1046//// e.printStackTrace();
1047//// }
1048////           
1049//// try {
1050//// CommunicationBD.open();
1051//// List plats = CommunicationBD.getAllList(Plateforme.class);
1052//// Plateforme plat;
1053//// for (int i=0; i<plats.size(); i++) {
1054//// plat = (Plateforme) plats.get(i);
1055//// System.out.println("\nPlateformesId = " + plat.getPlateformeNom());
1056////                           
1057//// }
1058//// CommunicationBD.close();
1059//// } catch (Exception e) {
1060//// // TODO Auto-generated catch block
1061//// e.printStackTrace();
1062//// }
1063//
1064//// // Argument 0 : LE NOM DE LA CATEGORIE
1065//// String nomCategorie = args[0];
1066//// // Argument 1 : LE NOM DU JEU
1067//// String nomJeu = args[1];
1068////
1069//// // ******************************Lancement du chronométre
1070//// // **********************************
1071//// Chrono chrono = new Chrono();
1072//// chrono.start();
1073//// // Fichier de log
1074//// EcritureLog.init(nomJeu, nomCategorie);
1075//// // ************ On recherche les fichiers du jeu
1076//// // ************************
1077//// String cheminJeu = Constantes.cheminDonnees + nomCategorie + "/" + nomJeu
1078//// + "/";
1079//// String cheminFichier;
1080//// PreValidation preValidation;
1081//// Validation validation;
1082//// ArrayList<String> listeMesures;
1083//// ArrayList<ArrayList<String>> listeDonnees = null;
1084//// int nbErreursValidation;
1085//// Fichier fichier;
1086//// MesureModele mesureModele;
1087//// ValeurModele valeurModele = null;
1088//// Valeur valeur = null;
1089//// ArrayList<ValeurModele> valeursMesure = null;
1090//// ArrayList<String> donneesMesure = null;
1091//// Mesure mesure = null;
1092//// String numSeqPrecedent = null;
1093////                           
1094//// // On récupére tous les fichiers du répertoire
1095//// File fileCourant = new File(cheminJeu);
1096//// String[] listeFichiers = fileCourant.list();
1097//// // S'il y a au moins un fichier dans le jeu
1098//// if (listeFichiers.length != 0) {
1099//// // Trier les fichiers par ordre alphabétique
1100//// Arrays.sort(listeFichiers);
1101//// // Etape 3 : On lit le modéle XML du jeu
1102//// LectureModeleXML lectureModeleXML = new LectureModeleXML(nomCategorie,
1103//// nomJeu);
1104//// lectureModeleXML.lireModele();
1105//// ArrayList<ParametreModele> parametresModele =
1106//// lectureModeleXML.getParametres();
1107//// ArrayList<ParametreModele> parametresValeur =
1108//// lectureModeleXML.getParametresValeur();
1109//// // Etape 4 : On lit les listes EXCEL de capteurs, paramétres, plateformes,
1110//// ...
1111//// LectureCapteurs lectureCapteurs = new LectureCapteurs();
1112//// lectureCapteurs.lireFichier();
1113//// LecturePlateformes lecturePlateformes = new LecturePlateformes();
1114//// lecturePlateformes.lireFichier();
1115//// LectureParametres lectureParametres = new LectureParametres();
1116//// lectureParametres.lireFichier();
1117//// LecturePersonnes lecturePersonnes = new LecturePersonnes();
1118//// lecturePersonnes.lireFichier();
1119//// LectureUnites lectureUnites = new LectureUnites();
1120//// lectureUnites.lireFichier();
1121//// ArrayList<String> codesUnite = lectureUnites.getCodesUni();
1122//// LectureOrganismes lectureOrganismes = new LectureOrganismes();
1123//// lectureOrganismes.lireFichier();
1124//// // Etape 5 : Répartition des métadonnées du jeu
1125//// Repartition repartition = new Repartition(lectureModeleXML, lectureCapteurs,
1126//// lecturePlateformes, lectureParametres,
1127//// lecturePersonnes, lectureUnites,
1128//// lectureOrganismes);
1129//// ArrayList<Personne> personnes = repartition.repartirPersonnes();
1130//// Jeu jeu = repartition.repartirJeu(personnes);
1131//// ArrayList<Parametre> parametres = repartition.repartirParametres();
1132//// ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
1133//// ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
1134//// Statiques.sequencesModeles = new ArrayList<SequenceModele>();
1135////                                   
1136//// //
1137//// **************************************************************************************************
1138//// // On parcourt les fichiers du jeu
1139//// //
1140//// ****************************************************************************************************
1141//// for (int numFic = 0; numFic < 2; numFic++) {
1142//// cheminFichier = cheminJeu + listeFichiers[numFic];
1143//// fileCourant = new File(cheminFichier);
1144//// // Si le fichier existe et n'est pas vide
1145//// if (fileCourant.exists()) {
1146//// EcritureLog.ecrire("Fichier " + fileCourant.getName(), "out-ln");
1147//// // Etape 1 : prévalidation : On prévalide le fichier
1148//// preValidation = new PreValidation(nomJeu, fileCourant);
1149//// listeMesures = preValidation.prevalider();
1150//// viderPrevalidation(preValidation, fileCourant);
1151//// EcritureLog.ecrire(" -> Prévalidation OK", "out-ln");
1152////
1153//// // Etape 2 : validation : On valide le fichier
1154//// validation = new Validation(listeMesures);
1155//// listeDonnees = validation.valider(lectureModeleXML);
1156//// nbErreursValidation = validation.getNbErreursTotales();
1157//// viderValidation(validation, listeMesures);
1158//// if (nbErreursValidation == 0) {
1159//// EcritureLog.ecrire(" -> Validation OK", "out-ln");
1160////
1161//// // Etape 5 : répartition du fichier
1162//// fichier = repartition.repartirFichier(jeu,fileCourant);
1163////                                                           
1164//// // TESTS 1
1165//// // System.out.println("\nCHEMIN = " + fichier.getFichierChemin());
1166//// // System.out.println("Nom = " + fichier.getFichierNom());
1167//// // System.out.println("TAILLE = " + fichier.getFichierTaille()+" ko");
1168//// // System.out.println("Jeu = " + fichier.getJeu().getJeuNom());
1169////                                                           
1170////                                                           
1171//// // Pour chaque mesure...
1172//// for(int numMesure = 0; numMesure < listeDonnees.size() ; numMesure++){
1173//// donneesMesure = listeDonnees.get(numMesure);
1174//// // Etape 6 : Rangement des données sur la ligne et répartition des séquences
1175//// mesureModele =
1176//// repartition.repartirDonnees(donneesMesure,numSeqPrecedent,parametresModele);
1177//// numSeqPrecedent = mesureModele.getNumSequence();
1178//// // Etape 7 : repartition de la mesure
1179//// mesure = repartition.repartirMesure(mesureModele, fichier, plateformes);
1180//////
1181////                                                                   
1182//// // TESTS 2
1183//// //System.out.println("\n Nom Fichier = " +
1184//// mesure.getFichier().getFichierNom());
1185//// //System.out.println(" Date Mesure = " +
1186//// DateTime.dateToString(mesure.getMesureDate(),Constantes.formatDateJJMMAAAAHHMMSS));
1187//// //System.out.println(" Nom PLateForme = " +
1188//// mesure.getPlateforme().getPlateformeNom());
1189//// //System.out.println(" Type PLateForme = " +
1190//// mesure.getPlateforme().getTypePlateforme().getTypePlateformeNom());
1191//// //System.out.println("lat="+Nombre.latIntToFloat(new
1192//// Integer(mesure.getLocalisation().getLocalisationLat())));
1193//// //System.out.println("lon="+Nombre.latIntToFloat(new
1194//// Integer(mesure.getLocalisation().getLocalisationLon())));
1195//// //System.out.println("alt="+Nombre.altIntToFloat(new
1196//// Integer(mesure.getLocalisation().getLocalisationAlt())));
1197//// valeursMesure = mesureModele.getValeursMesure();
1198//// // Pour chaque valeur...
1199//// for(int numValeur = 0; numValeur < valeursMesure.size() ; numValeur++){
1200//// valeurModele = valeursMesure.get(numValeur);
1201//// // Etape 9 : repartition de la valeur
1202//// valeur =
1203//// repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),valeurModele,capteurs,parametres.get(numValeur),parametresValeur.get(numValeur),codesUnite);
1204////
1205//// // TESTS 3
1206//// // System.out.println("\n\n date = " +
1207//// DateTime.dateToString(valeur.getMesure().getMesureDate(),Constantes.formatDateJJMMAAAAHHMMSS));
1208//// // System.out.println(" param code = " +
1209//// valeur.getParametre().getParametreCode());
1210//// // System.out.println(" param nom = " +
1211//// valeur.getParametre().getParametreNom());
1212//// // System.out.println(" cat param = " +
1213//// valeur.getParametre().getCategorieParam().getCategorieParamNom());
1214//// // System.out.println(" unite = " +
1215//// valeur.getParametre().getUnite().getUniteCode());
1216//// // System.out.println(" valeurVAL = " + valeur.getValeurVal());
1217//// // System.out.println(" capteur mod= " +
1218//// valeur.getCapteur().getCapteurModele());
1219//// // System.out.println(" capteur num= " +
1220//// valeur.getCapteur().getCapteurNumserie());
1221//// // System.out.println(" capteur fab= " +
1222//// valeur.getCapteur().getFabriquant().getFabriquantNom());
1223//// // System.out.println(" flagVALIDITE = " +
1224//// valeur.getFlagByValiditeFlag().getFlagNom());
1225//// // System.out.println(" Valeur Delta = " + valeur.getValeurDelta());
1226////                                                                           
1227////                                                                           
1228////                                                                           
1229//// }
1230//// //EcritureLog.ecrire(" -> Répartition OK", "out-ln");
1231//// }
1232//// EcritureLog.ecrire(" -> Répartition OK", "out");
1233//// }
1234//// viderRepartition(listeDonnees);
1235//// } else {
1236//// EcritureLog.ecrire("Fichier " + fileCourant.getName()
1237//// + " non trouvé !", "err");
1238//// }
1239//// }
1240//// // Etape 8 : répartition de la derniére séquence
1241//// repartition.repartirDerniereSequence();
1242//// TESTS 4
1243//// for (int i = 0; i < Statiques.sequencesModeles.size(); i++) {
1244//// SequenceModele sequenceModele = Statiques.sequencesModeles.get(i);
1245//// EcritureLog.ecrire(" DESCRIPTION = " +
1246//// sequenceModele.getDescription(),"out");
1247//// EcritureLog.ecrire(" nbMESURES = " + sequenceModele.getNbMesures(),"out");
1248//// EcritureLog.ecrire(" DTE_SEQ_MIN = " +
1249//// DateTime.dateToString(sequenceModele.getDateMinSeq(),Constantes.formatDateJJMMAAAAHHMMSS),"out");
1250//// EcritureLog.ecrire(" DTE_SEQ_MAX = " +
1251//// DateTime.dateToString(sequenceModele.getDateMaxSeq(),Constantes.formatDateJJMMAAAAHHMMSS),"out");
1252//// EcritureLog.ecrire(" ALTITUDE_SEQ_MIN = " + Nombre.altIntToFloat(new
1253//// Integer(sequenceModele.getAltMinSeq())),"out");
1254//// EcritureLog.ecrire(" ALTITUDE_SEQ_MAX = " + Nombre.altIntToFloat(new
1255//// Integer(sequenceModele.getAltMaxSeq())),"out");
1256//// EcritureLog.ecrire(" LAT_SEQ_MIN = " + Nombre.latIntToFloat(new
1257//// Integer(sequenceModele.getLatMinSeq())),"out");
1258//// EcritureLog.ecrire(" LAT_SEQ_MAX = " + Nombre.latIntToFloat(new
1259//// Integer(sequenceModele.getLatMaxSeq())),"out");
1260//// EcritureLog.ecrire(" LONG_SEQ_MIN = " + Nombre.latIntToFloat(new
1261//// Integer(sequenceModele.getLonMinSeq())),"out");
1262//// EcritureLog.ecrire(" LONG_SEQ_MAX = " + Nombre.latIntToFloat(new
1263//// Integer(sequenceModele.getLonMaxSeq())),"out");
1264//// EcritureLog.ecrire("","out");
1265////
1266////                                           
1267//// }
1268//
1269////                                   
1270//// } else {
1271//// EcritureLog.ecrire("Pas de fichiers é valider dans le jeu "
1272//// + Constantes.nomJeuAMDAR, "err");
1273//// }
1274//// // ******************************Arrét du chronométre
1275//// // **********************************
1276//// chrono.stop();
1277//// chrono.afficheChrono();
1278//// }
1279//// /**
1280//// * Libérer la mémoire aprés la repartition d'un fichier donné.
1281//// *
1282//// */
1283//// private static void viderRepartition(ArrayList<ArrayList<String>>
1284//// listeDonnees) {
1285//// listeDonnees = null;
1286//// }
1287////
1288//// /**
1289//// * Libérer la mémoire aprés la validation d'un fichier donné.
1290//// *
1291//// */
1292//// private static void viderValidation(Validation validation,
1293//// ArrayList<String> listeMesures) {
1294//// validation = null;
1295//// listeMesures = null;
1296//// }
1297////
1298//// /**
1299//// * Libérer la mémoire aprés la prévalidation d'un fichier donné.
1300//// *
1301//// */
1302//// private static void viderPrevalidation(PreValidation preValidation,
1303//// File fichier) {
1304//// preValidation = null;
1305//// fichier = null;
1306//// }
1307////             
1308//
1309//// String s = "machin";
1310//// String t = null;
1311//// System.out.println("res="+(.equals(t)));
1312//// ArrayList<ValeurModele> liste=new ArrayList<ValeurModele>();
1313//// ValeurModele val;
1314//// for (int i=0; i< 3; i++){
1315//// val = new ValeurModele();
1316//// val.setValeurVal("0");
1317//// liste.add(val);
1318//// }
1319////             
1320//// ValeurModele val2 = liste.get(1);
1321//// val2.setValeurVal("1");
1322//// //liste.get(1).setValeurVal("1");
1323////             
1324//// for (int i=0; i< liste.size(); i++){
1325//// System.out.println(liste.get(i).getValeurVal());
1326//// }
1327//// ArrayList<ArrayList<String>> listeDonnees = null;
1328//// // On lit le modéle XML du jeu
1329//// LectureModeleXML lectureModeleXML = new LectureModeleXML("AVION","AMDAR");
1330//// lectureModeleXML.lireModele();
1331//// // On lit les listes de capteurs, paramétres, plateformes, ...
1332//// LectureCapteurs lectureCapteurs = new LectureCapteurs();
1333//// lectureCapteurs.lireFichier();
1334//// LecturePlateformes lecturePlateformes = new LecturePlateformes();
1335//// lecturePlateformes.lireFichier();
1336//// LectureParametres lectureParametres = new LectureParametres();
1337//// lectureParametres.lireFichier();
1338//// LecturePersonnes lecturePersonnes = new LecturePersonnes();
1339//// lecturePersonnes.lireFichier();
1340//// LectureUnites lectureUnites = new LectureUnites();
1341//// lectureUnites.lireFichier();
1342//// LectureOrganismes lectureOrganismes = new LectureOrganismes();
1343//// lectureOrganismes.lireFichier();
1344////           
1345////             
1346//// Fichier fichier;
1347//// MesureModele mesureModele;
1348//// ArrayList<String> donneesMesure = null;
1349//// // On récupére tous les fichiers du répertoire
1350//// File fileCourant = null;
1351//// String[] listeFichiers = fileCourant.list();
1352////   
1353//// //
1354////                   
1355////                   
1356//// Repartition repartition = new Repartition(lectureModeleXML, lectureCapteurs,
1357//// lecturePlateformes, lectureParametres,
1358//// lecturePersonnes, lectureUnites,
1359//// lectureOrganismes);
1360//// ArrayList<Personne> personnes = repartition.repartirPersonnes();
1361//// Jeu jeu = repartition.repartirJeu(personnes);
1362//// ArrayList<Parametre> parametres = repartition.repartirParametres();
1363//// ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
1364//// ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
1365//// fichier = repartition.repartirFichier(jeu,fileCourant);
1366//// mesureModele = repartition.repartirDonnees(donneesMesure);
1367//// // Répartition des métadonnées du jeu
1368//// // Repartition repartition = new Repartition(listeDonnees,
1369//// // lectureModeleXML, lectureCapteurs,
1370//// // lecturePlateformes, lectureParametres,
1371//// // lecturePersonnes, lectureUnites,
1372//// // lectureOrganismes);
1373//// // ArrayList<Personne> personnes = repartition.repartirPersonnes();
1374//// // Jeu jeu = repartition.repartirJeu(personnes);
1375//// //
1376//// // ArrayList<Parametre> parametres = repartition.repartirParametres();
1377//// // ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
1378//// // ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
1379//// // mesureModele = repartition.repartirDonnees(donneesMesure);
1380////                   
1381////                   
1382//// Personne personne;
1383//// Capteur capteur;
1384//// Parametre parametre;
1385//// Plateforme plateforme;
1386//// int numCapteur;
1387//
1388///**
1389// * -------------------------------test sur
1390// * personnes------------------------------------
1391// */
1392//
1393//// for (int num=0; num< personnes.size(); num++){
1394//// personne = personnes.get(num);
1395////
1396//// System.out.println("Mail ="+ personne.getPersonneMail());
1397//// System.out.println("Nom ="+ personne.getPersonneNom());
1398//// System.out.println("Prénom ="+ personne.getPersonnePrenom());
1399//// if (personne.getCommentaire() != null) {
1400//// System.out.println("Description ="+
1401//// personne.getCommentaire().getCommentaireTxt());
1402//// }
1403//// System.out.println("nom organisme = "+
1404//// personne.getOrganisme().getOrganismeNom());
1405//// System.out.println("mail organisme = "+
1406//// personne.getOrganisme().getOrganismeMail());
1407//// System.out.println(" pyas organisme = "+
1408//// personne.getOrganisme().getAdresse().getAdressePays());
1409//// System.out.println(" rue organisme = "+
1410//// personne.getOrganisme().getAdresse().getAdresseRue());
1411//// System.out.println(" ville organisme = "+
1412//// personne.getOrganisme().getAdresse().getAdresseVille());
1413//// System.out.println("code organisme = "+
1414//// personne.getOrganisme().getAdresse().getAdresseZip());
1415//// System.out.println();
1416////                     
1417//// }
1418///**
1419// * ---------------------------fin test sur
1420// * personnes------------------------------------
1421// */
1422//
1423///**
1424// * -------------------------------test sur
1425// * capteurs------------------------------------
1426// */
1427//
1428//// Iterator<Parametre> it;
1429//// // Parametre parametre;
1430//// for (int num=0; num< capteurs.size(); num++){
1431//// capteur = capteurs.get(num);
1432////                     
1433//// System.out.println("Etalonnage Capteurs ="+ capteur.getCapteurEtalonnage());
1434//// System.out.println("MOdele Capteurs = " + capteur.getCapteurModele());
1435//// System.out.println("Nomero Serie Cpateurs = " +
1436//// capteur.getCapteurNumserie());
1437//// if (capteur.getCommentaire() != null) {
1438//// System.out.println("Description Capteurs = " +
1439//// capteur.getCommentaire().getCommentaireTxt());
1440//// }
1441//// System.out.println("Nom Fabriquant Capteurs = " +
1442//// capteur.getFabriquant().getFabriquantNom());
1443////                     
1444//// it = capteur.getParametres().iterator();
1445//// while (it.hasNext()) {
1446//// parametre = it.next();
1447//// System.out.println("Parametres Capteurs = " + parametre.getParametreCode());
1448//// }
1449////
1450//// System.out.println("Noms types Capteurs = " +
1451//// capteur.getTypeCapteur().getTypeCapteurNom());
1452////                                             
1453//// System.out.println();
1454////             
1455//// }
1456///**
1457// * ----------------------------fin test sur
1458// * capteurs------------------------------------
1459// */
1460//
1461///**
1462// * -------------------------------test sur
1463// * palteformes------------------------------------
1464// */
1465//
1466////             
1467//// Iterator<Capteur> it;
1468//// //Capteur capteur;
1469//// for (int num=0; num< plateformes.size(); num++){ plateforme =
1470//// plateformes.get(num);
1471////                     
1472//// System.out.println("Id plateforme = "+ plateforme.getPlateformeId());
1473//// System.out.println("Nom plateforme = " + plateforme.getPlateformeNom());
1474//// System.out.println("Type plateforme = " +
1475//// plateforme.getTypePlateforme().getTypePlateformeNom());
1476////                   
1477////                     
1478//// if (plateforme.getCommentaire() != null) {
1479//// System.out.println("Description Capteurs = " +
1480//// plateforme.getCommentaire().getCommentaireTxt());
1481//// }
1482////                     
1483////                     
1484//// it = plateforme.getCapteurs().iterator();
1485//// while (it.hasNext()) {
1486//// capteur = it.next();
1487//// System.out.println("Etalonnage Capteurs de Palateformes = " +
1488//// capteur.getCapteurEtalonnage());
1489//// System.out.println("Id Capteurs de Palateformes = " +
1490//// capteur.getCapteurId());
1491//// System.out.println("Modele Capteurs de Palateformes = " +
1492//// capteur.getCapteurModele());
1493//// System.out.println("Numero de Serie Capt Platformes = " +
1494//// capteur.getCapteurNumserie());
1495//// if (capteur.getCommentaire() != null) {
1496//// System.out.println(" description Capt Plateformes = " +
1497//// capteur.getCommentaire().getCommentaireTxt());
1498//// }
1499//// System.out.println("Id Fabriquant Capt PLateformes = " +
1500//// capteur.getFabriquant().getFabriquantId());
1501//// System.out.println(" Type capteur palteformes = " +
1502//// capteur.getTypeCapteur().getTypeCapteurNom());
1503//// }
1504//// System.out.println();
1505////                     
1506//// }
1507////             
1508////             
1509//
1510///**
1511// * ---------------------------fin test sur
1512// * palteformes------------------------------------
1513// */
1514//
1515///**
1516// * ---------------------------fin test sur
1517// * jeux------------------------------------
1518// */
1519//
1520//// for (int num=0; num< personnes.size(); num++){
1521//// personne = personnes.get(num);
1522////                     
1523//// System.out.println("Mail ="+ personne.getPersonneMail());
1524//// System.out.println("Nom ="+ personne.getPersonneNom());
1525//// System.out.println("Prénom ="+ personne.getPersonnePrenom());
1526//// if (personne.getCommentaire() != null) {
1527//// System.out.println("Description ="+
1528//// personne.getCommentaire().getCommentaireTxt());
1529//// }
1530//// System.out.println("nom organisme = "+
1531//// personne.getOrganisme().getOrganismeNom());
1532//// System.out.println("mail organisme = "+
1533//// personne.getOrganisme().getOrganismeMail());
1534//// System.out.println(" pyas organisme = "+
1535//// personne.getOrganisme().getAdresse().getAdressePays());
1536//// System.out.println(" rue organisme = "+
1537//// personne.getOrganisme().getAdresse().getAdresseRue());
1538//// System.out.println(" ville organisme = "+
1539//// personne.getOrganisme().getAdresse().getAdresseVille());
1540//// System.out.println("code organisme = "+
1541//// personne.getOrganisme().getAdresse().getAdresseZip());
1542//// System.out.println();
1543////                     
1544//// }
1545////             
1546////             
1547////             
1548//// System.out.println("nom jeu = "+ jeu.getJeuId());
1549//// System.out.println("nom jeu = "+ jeu.getJeuNom());
1550//// System.out.println("Categorie jeu = "+ jeu.getCategorie().getCategorieNom());
1551//// System.out.println("Description jeu = "+
1552//// jeu.getCommentaire().getCommentaireTxt());//.getJeuNom());
1553//// System.out.println("mail organisme jeu = "+
1554//// jeu.getOrganisme().getOrganismeMail());
1555//// System.out.println("nom Organisme jeu = "+
1556//// jeu.getOrganisme().getOrganismeNom());
1557//// System.out.println("description organisme jeu = " +
1558//// jeu.getOrganisme().getCommentaire().getCommentaireTxt());
1559//// System.out.println("contact jeu = " +
1560//// jeu.getPersonneByContactId().getPersonneMail());
1561//// System.out.println("mail contact jeu = " +
1562//// jeu.getPersonneByContactId().getPersonneNom());
1563//// System.out.println("nom contact jeu = " +
1564//// jeu.getPersonneByContactId().getPersonneNom());
1565//// System.out.println("prenom contact jeu = " +
1566//// jeu.getPersonneByContactId().getPersonnePrenom());
1567//// }
1568//
1569///** ---------------------------fin test jeu------------------------------------ */
1570//
1571///** ---------------------------test parametres-------------------------------- */
1572//
1573//// for (int num=0; num< parametres.size(); num++){
1574//// parametre = parametres.get(num);
1575////                     
1576//// System.out.println("Code parametre = " + parametre.getParametreCode());
1577//// System.out.println("Nom parametre = " + parametre.getParametreNom());
1578//// System.out.println("Nom Categorie parametre = " +
1579//// parametre.getCategorieParam().getCategorieParamNom());
1580//// System.out.println("Code Unite parametre = " +
1581//// parametre.getUnite().getUniteCode());
1582////             
1583////           
1584//// if (parametre.getCommentaire() != null) {
1585//// System.out.println("Description ="+
1586//// parametre.getCommentaire().getCommentaireTxt());
1587//// }
1588//// System.out.println();
1589//// }
1590///** -----------------------fin test parametres-------------------------------- */
1591//
1592//// LecturePlateformes lecturePlateformes = new LecturePlateformes();
1593//// lecturePlateformes.lireFichier();
1594//// for (int num=0; num< Constantes.nbPlateformes; num++){
1595//// System.out.print(lecturePlateformes.getNumerosPlat().get(num));
1596//// System.out.print(" * "+lecturePlateformes.getNomsPLat().get(num));
1597//// System.out.print(" * "+lecturePlateformes.getTypesPlat().get(num));
1598//// System.out.print(" * "+lecturePlateformes.getDescriptionsPLat().get(num));
1599//// System.out.print(" * "+lecturePlateformes.getLatMinsPLat().get(num));
1600//// System.out.print(" * "+lecturePlateformes.getLatMaxsPLat().get(num));
1601//// System.out.print(" * "+lecturePlateformes.getLongMinsPLat().get(num));
1602//// System.out.print(" * "+lecturePlateformes.getLongMaxsPLat().get(num));
1603//// System.out.print(" * "+lecturePlateformes.getAltMinsPLat().get(num));
1604//// System.out.print(" * "+lecturePlateformes.getAltMaxsPLat().get(num));
1605//// System.out.print(" * "+lecturePlateformes.getHautSolMinsPlat().get(num));
1606//// System.out.print(" * "+lecturePlateformes.getHautSolMaxsPlat().get(num));
1607//// System.out.print(" * ");
1608//// for (int num2=0; num2<lecturePlateformes.getNumsCaptPlat().get(num).size();
1609//// num2++){
1610//// System.out.print(" # "+
1611//// lecturePlateformes.getNumsCaptPlat().get(num).get(num2));
1612//// }
1613//// System.out.println();
1614//
1615//// **********************************************************************************
1616//// ****************************TestParametres****************************************
1617//// **********************************************************************************
1618////   
1619//// public static void main(String[] args) {
1620//// LectureParametres lectureParametres = new LectureParametres(null);
1621//// lectureParametres.lireFichier();
1622//// for (int num=0; num< Constantes.nbParametres; num++){
1623//// System.out.print(lectureParametres.getNumerosParam().get(num));
1624//// System.out.print(" ->>->>->>->>
1625//// "+lectureParametres.getNomParam().get(num));
1626//// System.out.print(" ->>->>->>->>
1627//// "+lectureParametres.getCodeMegapoliParam().get(num));
1628//// System.out.print(" ->>->>->>->>
1629//// "+lectureParametres.getNumUniteParam().get(num));
1630//// System.out.print(" ->>->>->>->>
1631//// "+lectureParametres.getDescriptionParam().get(num));
1632//// System.out.print(" ->>->>->>->>
1633//// "+lectureParametres.getCategorieParam().get(num));
1634////                   
1635//// System.out.println();
1636//// }
1637//// }
1638////
1639//// }
1640////   
1641//// **********************************************************************************
1642//// ****************************TestOrganismes****************************************
1643//// **********************************************************************************
1644////
1645//// public static void main(String[] args) {
1646//// LectureOrganismes lectureOrganismes = new LectureOrganismes(null);
1647//// lectureOrganismes.lireFichier();
1648//// for (int num=0; num< Constantes.nbParametres; num++){
1649//// System.out.print(lectureOrganismes.getNumerosOrg().get(num));
1650//// System.out.print(" ->>->>->>->>
1651//// "+lectureOrganismes.getNomsOrg().get(num));
1652//// System.out.print(" ->>->>->>->>
1653//// "+lectureOrganismes.getMailOrg().get(num));
1654//// System.out.print(" ->>->>->>->>
1655//// "+lectureOrganismes.getDescriptionOrg().get(num));
1656//// System.out.print(" ->>->>->>->>
1657//// "+lectureOrganismes.getRueOrg().get(num));
1658//// System.out.print(" ->>->>->>->>
1659//// "+lectureOrganismes.getCodePostalOrg().get(num));
1660//// System.out.print(" ->>->>->>->>
1661//// "+lectureOrganismes.getVilleOrg().get(num));
1662//// System.out.print(" ->>->>->>->>
1663//// "+lectureOrganismes.getPaysOrg().get(num));
1664//// System.out.print(" ->>->>->>->>
1665//// "+lectureOrganismes.getUrlOrg().get(num));
1666////                   
1667//// System.out.println();
1668//// }
1669//// }
1670////
1671//// }
1672////   
1673//// **********************************************************************************
1674//// ***************************TestPersonnes*****************************************
1675//// **********************************************************************************
1676////
1677//// public static void main(String[] args) {
1678//// LecturePersonnes lecturePersonnes = new LecturePersonnes(null);
1679//// lecturePersonnes.lireFichier();
1680//// for (int num=0; num< Constantes.nbPersonnes; num++){
1681//// System.out.print(lecturePersonnes.getNumerosPes().get(num));
1682//// System.out.print(" ->>->>->>->>
1683//// "+lecturePersonnes.getNomsPes().get(num));
1684//// System.out.print(" ->>->>->>->>
1685//// "+lecturePersonnes.getPrenomsPes().get(num));
1686//// System.out.print(" ->>->>->>->>
1687//// "+lecturePersonnes.getPrenomsPes().get(num));
1688//// System.out.print(" ->>->>->>->>
1689//// "+lecturePersonnes.getMailPes().get(num));
1690//// System.out.print(" ->>->>->>->>
1691//// "+lecturePersonnes.getDescriptionPes().get(num));
1692//// System.out.print(" ->>->>->>->>
1693//// "+lecturePersonnes.getNumOrgPes().get(num));
1694////                   
1695//// System.out.println();
1696//// }
1697//// }
1698////
1699//// }
1700//// ********************************************************************************
1701//// *************************TestPLateformes***************************************
1702//// ********************************************************************************
1703//// public static void main(String[] args) {
1704//// LecturePlateformes lecturePlateformes = new LecturePlateformes(null);
1705//// lecturePlateformes.lireFichier();
1706//// for (int num=0; num< Constantes.nbPlateformes; num++){
1707//// System.out.print(lecturePlateformes.getNumerosPlat().get(num));
1708//// System.out.print(" ->>->>->>->>
1709//// "+lecturePlateformes.getNomsPLat().get(num));
1710//// System.out.print(" ->>->>->>->>
1711//// "+lecturePlateformes.getTypePlat().get(num));
1712//// System.out.print(" ->>->>->>->>
1713//// "+lecturePlateformes.getDescriptionPLat().get(num));
1714//// System.out.print(" ->>->>->>->>
1715//// "+lecturePlateformes.getAltMinPLat().get(num));
1716//// System.out.print(" ->>->>->>->>
1717//// "+lecturePlateformes.getAltMaxPLat().get(num));
1718//// System.out.print(" ->>->>->>->>
1719//// "+lecturePlateformes.getAltMinPLat().get(num));
1720//// System.out.print(" ->>->>->>->>
1721//// "+lecturePlateformes.getAltMaxPLat().get(num));
1722//// System.out.print(" ->>->>->>->>
1723//// "+lecturePlateformes.getAltMaxPLat().get(num));
1724//// System.out.print(" ->>->>->>->>
1725//// "+lecturePlateformes.getAltMaxPLat().get(num));
1726//// System.out.print(" ->>->>->>->>
1727//// "+lecturePlateformes.getAltMinPLat().get(num));
1728//// System.out.print(" ->>->>->>->>
1729//// "+lecturePlateformes.getAltMaxPLat().get(num));
1730//// System.out.print(" ->>->>->>->>
1731//// "+lecturePlateformes.getNumsCaptPlat().get(num));
1732//// System.out.println();
1733//// }
1734//// }
1735//// }
1736////   
1737////
1738//// *********************************************************************************
1739//// ********************************TestUnites***************************************
1740//// *********************************************************************************
1741//// public static void main(String[] args) {
1742//// LectureUnites lectureUnites = new LectureUnites(null);
1743//// lectureUnites.lireFichier();
1744//// for (int num = 0; num < Constantes.nbUnites; num++) {
1745//// System.out.print(lectureUnites.getNumUni().get(num));
1746//// System.out.print(" ->>->>->>->> "
1747//// + lectureUnites.getNumUni().get(num));
1748//// System.out.print(" ->>->>->>->> "
1749//// + lectureUnites.getCodeUni().get(num));
1750////
1751//// System.out.println();
1752//// }
1753////}
1754/******************************************************************/
1755
Note: See TracBrowser for help on using the repository browser.