001: /*
002: * This file is part of the GeOxygene project source files.
003: *
004: * GeOxygene aims at providing an open framework which implements OGC/ISO specifications for
005: * the development and deployment of geographic (GIS) applications. It is a open source
006: * contribution of the COGIT laboratory at the Institut Géographique National (the French
007: * National Mapping Agency).
008: *
009: * See: http://oxygene-project.sourceforge.net
010: *
011: * Copyright (C) 2005 Institut Géographique National
012: *
013: * This library is free software; you can redistribute it and/or modify it under the terms
014: * of the GNU Lesser General Public License as published by the Free Software Foundation;
015: * either version 2.1 of the License, or any later version.
016: *
017: * This library is distributed in the hope that it will be useful, but WITHOUT ANY
018: * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
019: * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
020: *
021: * You should have received a copy of the GNU Lesser General Public License along with
022: * this library (see file LICENSE if present); if not, write to the Free Software
023: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
024: *
025: */
026:
027: package fr.ign.cogit.geoxygene.contrib.appariement.stockageLiens;
028:
029: import java.util.ArrayList;
030: import java.util.GregorianCalendar;
031: import java.util.HashSet;
032: import java.util.Iterator;
033: import java.util.List;
034: import java.util.StringTokenizer;
035:
036: import fr.ign.cogit.geoxygene.contrib.appariement.EnsembleDeLiens;
037: import fr.ign.cogit.geoxygene.contrib.appariement.Lien;
038: import fr.ign.cogit.geoxygene.datatools.Geodatabase;
039: import fr.ign.cogit.geoxygene.datatools.ojb.GeodatabaseOjbFactory;
040: import fr.ign.cogit.geoxygene.feature.Population;
041:
042: /**
043: * Structure permettant le stockage des Résultats de la réalisation
044: * d'un appariement au sein du SGBD
045: *
046: * @author Eric Grosso - IGN / Laboratoire COGIT
047: * @version 1.0
048: *
049: */
050:
051: @SuppressWarnings("unchecked")
052: public class EnsembleDeLiensSGBD extends Population {
053:
054: public EnsembleDeLiensSGBD() {
055: super (false, "Ensemble de liens SGBD", LienSGBD.class, true);
056: }
057:
058: public EnsembleDeLiensSGBD(boolean persistant) {
059: super (persistant, "Ensemble de liens SGBD", LienSGBD.class,
060: true);
061: }
062:
063: /** Nom du l'ensemble des liens d'appariement (ex: "Appariement des routes par la méthode XX")*/
064: private String nom;
065:
066: public String getNom() {
067: return nom;
068: }
069:
070: public void setNom(String nom) {
071: this .nom = nom;
072: }
073:
074: /** Description textuelle des paramètres utilisés pour l'appariement */
075: private String parametrage;
076:
077: public String getParametrage() {
078: return parametrage;
079: }
080:
081: public void setParametrage(String parametrage) {
082: this .parametrage = parametrage;
083: }
084:
085: /** Description textuelle du résultat de l'auto-évaluation des liens */
086: private String evaluationInterne;
087:
088: public String getEvaluationInterne() {
089: return evaluationInterne;
090: }
091:
092: public void setEvaluationInterne(String evaluation) {
093: evaluationInterne = evaluation;
094: }
095:
096: /** Description textuelle du résultat de l'évaluation globale des liens */
097: private String evaluationGlobale;
098:
099: public String getEvaluationGlobale() {
100: return evaluationGlobale;
101: }
102:
103: public void setEvaluationGlobale(String evaluation) {
104: evaluationGlobale = evaluation;
105: }
106:
107: /** Liste des populations auxquelles les objets ref et comp des liens sont attachés
108: * sous forme de string*/
109: private String populations;
110:
111: public String getPopulations() {
112: return populations;
113: }
114:
115: public void setPopulations(String populations) {
116: this .populations = populations;
117: }
118:
119: /** Liste aidant à instancier la variable populations*/
120: private HashSet<String> listePop;
121:
122: public HashSet<String> getListePop() {
123: return listePop;
124: }
125:
126: public void setListePop(HashSet<String> listePop) {
127: this .listePop = listePop;
128: }
129:
130: /** Liste des populations réelles*/
131: private List<Population> listePopulations;
132:
133: public List<Population> getListePopulations() {
134: return listePopulations;
135: }
136:
137: public void setListePopulations(List<Population> listePopulations) {
138: this .listePopulations = listePopulations;
139: }
140:
141: /** Date de l'enregistrement*/
142: private String date;
143:
144: public String getDate() {
145: return date;
146: }
147:
148: public void setDate(String date) {
149: this .date = date;
150: }
151:
152: /**Couleur du lien : rouge */
153: private int rouge;
154:
155: public int getRouge() {
156: return rouge;
157: }
158:
159: public void setRouge(int rouge) {
160: this .rouge = rouge;
161: }
162:
163: /**Couleur du lien : vert */
164: private int vert;
165:
166: public int getVert() {
167: return vert;
168: }
169:
170: public void setVert(int vert) {
171: this .vert = vert;
172: }
173:
174: /**Couleur du lien : bleu */
175: private int bleu;
176:
177: public int getBleu() {
178: return bleu;
179: }
180:
181: public void setBleu(int bleu) {
182: this .bleu = bleu;
183: }
184:
185: //////////////////////////////////////////////////////////////////////////
186: // relation BIDIRECTIONNELLE 1-n ////////////////////////
187: //////////////////////////////////////////////////////////////////////////
188:
189: /** Lien bidirectionnel 1-n vers Lien.
190: * 1 objet EnsembleDeLiens est en relation avec n objets LienSGBD (n pouvant etre nul).
191: * 1 objet LienSGBD est en relation avec 1 objet EnsembleDeLiens au plus.
192: *
193: * NB: un objet EnsembleDeLiens ne doit pas être en relation plusieurs fois avec le même objet LienSGBD :
194: * il est impossible de bien gérer des relations 1-n bidirectionnelles avec doublons.
195: *
196: * ATTENTION: Pour assurer la bidirection, il faut modifier les listes uniquement avec
197: * les methodes fournies.
198: *
199: * NB: si il n'y a pas d'objet en relation, la liste est vide mais n'est pas "null".
200: * Pour casser toutes les relations, faire setListe(new ArrayList()) ou emptyListe().
201: */
202: private List<LienSGBD> liensSGBD = this .getElements();
203:
204: /** Récupère la liste des objets en relation. */
205: public List<LienSGBD> getLiensSGBD() {
206: return liensSGBD;
207: }
208:
209: /** Définit la liste des objets en relation, et met à jour la relation inverse. */
210: public void setLiensSGBD(List<LienSGBD> L) {
211: List old = new ArrayList(liensSGBD);
212: Iterator it1 = old.iterator();
213: while (it1.hasNext()) {
214: LienSGBD lien = (LienSGBD) it1.next();
215: lien.setEnsembleLiensSGBD(null);
216: }
217: Iterator it2 = L.iterator();
218: while (it2.hasNext()) {
219: LienSGBD lien = (LienSGBD) it2.next();
220: lien.setEnsembleLiensSGBD(this );
221: }
222: }
223:
224: /** Récupère le ième élément de la liste des objets en relation. */
225: public LienSGBD getLienSGBD(int i) {
226: return (LienSGBD) liensSGBD.get(i);
227: }
228:
229: /** Ajoute un objet à la liste des objets en relation, et met à jour la relation inverse. */
230: public void addLienSGBD(LienSGBD lien) {
231: if (lien == null)
232: return;
233: liensSGBD.add(lien);
234: lien.setEnsembleLiensSGBD(this );
235: }
236:
237: /** Enlève un élément de la liste des objets en relation, et met à jour la relation inverse. */
238: public void removeLienSGBD(LienSGBD lien) {
239: if (lien == null)
240: return;
241: liensSGBD.remove(lien);
242: lien.setEnsembleLiensSGBD(null);
243: }
244:
245: /** Vide la liste des objets en relation, et met à jour la relation inverse. */
246: public void emptyLiensSGBD() {
247: List old = new ArrayList(liensSGBD);
248: Iterator it = old.iterator();
249: while (it.hasNext()) {
250: LienSGBD lien = (LienSGBD) it.next();
251: lien.setEnsembleLiensSGBD(null);
252: }
253: }
254:
255: /** Détruit dans le SGBD l'ensemble de liens SGBD et les liens d'appariement SGBD
256: * en correspondance (attention: il faut que les objets soient persistants) */
257: public void detruitEnsembleDeLiensSGBD(Geodatabase geodatabase) {
258: Iterator<LienSGBD> it = this .getLiensSGBD().iterator();
259: while (it.hasNext()) {
260: LienSGBD lien = it.next();
261: geodatabase.deletePersistent(lien);
262: }
263: geodatabase.deletePersistent(this );
264: }
265:
266: ////////////////////////////////////////////////////////////////////////////////////
267: ////////// CONVERSION ENTRE ENSEMBLE DE LIENS ET ENSEMBLE DE LIENS SGBD //////////
268: ////////////////////////////////////////////////////////////////////////////////////
269:
270: /**Methode de conversion entre les ensembles de liens d'appariement vers les ensemebles
271: * de liens SGBD */
272: public EnsembleDeLiensSGBD conversionEnsembleLiensVersSGBD(
273: EnsembleDeLiens ensemble, int rouge, int vert, int bleu) {
274: //nom
275: if (ensemble.getNom() == null
276: || ensemble.getNom().length() == 0)
277: this .setNom("Non renseigné");
278: else
279: this .setNom(ensemble.getNom());
280:
281: //parametrage
282: if (ensemble.getParametrage() == null
283: || ensemble.getParametrage().length() == 0) {
284: this .setParametrage("Non renseigné");
285: } else
286: this .setParametrage(ensemble.getParametrage());
287:
288: //evaluationInterne
289: if (ensemble.getEvaluationInterne() == null
290: || ensemble.getEvaluationInterne().length() == 0)
291: this .setEvaluationInterne("Non renseigné");
292: else
293: this .setEvaluationInterne(ensemble.getEvaluationInterne());
294:
295: //evaluationGlobale
296: if (ensemble.getEvaluationGlobale() == null
297: || ensemble.getEvaluationGlobale().length() == 0)
298: this .setEvaluationGlobale("Non renseigné");
299: else
300: this .setEvaluationGlobale(ensemble.getEvaluationGlobale());
301:
302: //date
303: this .setDate(new GregorianCalendar().getTime().toString());
304:
305: //couleur
306: this .setRouge(rouge);
307: this .setVert(vert);
308: this .setBleu(bleu);
309:
310: //liensSGBD
311: this .setListePop(new HashSet<String>());
312: Iterator it = ensemble.getElements().iterator();
313: while (it.hasNext()) {
314: LienSGBD lienSGBD = (LienSGBD) this .nouvelElement();
315: this .addLienSGBD(lienSGBD);
316: lienSGBD.conversionLiensVersSGBD((Lien) it.next());
317: }
318:
319: Iterator<String> itPop = listePop.iterator();
320: String pop = "";
321: while (itPop.hasNext()) {
322: pop = pop.concat(itPop.next() + "|");
323: }
324: this .setPopulations(pop.substring(0, pop.length() - 1));
325:
326: return this ;
327: }
328:
329: /**Methode de conversion entre les ensembles de liens SGBD vers les ensembles de
330: * liens d'appariement */
331: public void conversionSGBDVersEnsembleLiens(EnsembleDeLiens ensemble) {
332: //nom
333: ensemble.setNom(this .getNom());
334:
335: //parametrage
336: ensemble.setParametrage(this .getParametrage());
337:
338: //evaluationInterne
339: ensemble.setEvaluationInterne(this .getEvaluationInterne());
340:
341: //evaluationGlobale
342: ensemble.setEvaluationGlobale(this .getEvaluationGlobale());
343:
344: //chargement des populations concernées par les liens d'appariement en mémoire
345: StringTokenizer token = new StringTokenizer(this
346: .getPopulations(), "|");
347: String pop;
348: Geodatabase geodb = GeodatabaseOjbFactory.newInstance();
349: this .setListePopulations(new ArrayList());
350: while (token.hasMoreElements()) {
351: pop = token.nextToken();
352: try {
353: Class classe = Class.forName(pop);
354: Population population = new Population(false,
355: "Population", classe, true);
356: population.addCollection(geodb.loadAllFeatures(classe));
357: this .getListePopulations().add(population);
358: } catch (Exception e) {
359: e.printStackTrace();
360: System.out.println("ATTENTION: la classe " + pop
361: + " stockée dans LIENS ne semble plus existée");
362: System.out
363: .println("RESOLUTION: recréer cette classe ou refaire un appariement pour un stockage adapté de vos liens");
364: }
365: }
366:
367: //liensSGBD
368: Iterator<LienSGBD> it = this .getLiensSGBD().iterator();
369: while (it.hasNext()) {
370: LienSGBD lienSGBD = it.next();
371: //ensemble.getElements().add(lienSGBD.conversionSGBDVersLiens());
372: //meilleure solution dans le sens où précise la population du lien
373: //mais plantage au niveau du stockage au moment de la création de la population
374: //de l'ensemble de liens SGBD
375: ensemble.add(lienSGBD.conversionSGBDVersLiens());
376: }
377: }
378:
379: }
|