Context Navigation

source: ether_megapoli/trunk/service/implementation/com/medias/integration_old/principal/Test.java @ 486

Last change on this file since 486 was 486, checked in by vmipsl, 12 years ago
BO insertion données _ ajout code medias clean
Property svn:executable set to ``*
File size: 68.6 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: