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.example.relations;
028:
029: // Imports necessaires aux relations 1-n et n-m
030: import java.util.ArrayList;
031: import java.util.Iterator;
032: import java.util.List;
033:
034: /**
035: * Classe exemple pour les relations mono ou bidirectionnelles, avec la classe BBB.
036: * Les relations peuvent etre persistantes ou non (cf. fichier de mapping repository_AAA_BBB.xml)
037: *
038: * @author Thierry Badard, Arnaud Braun & S�bastien Musti�re
039: * @version 1.0
040: *
041: */
042:
043: public class AAA extends ClasseMere {
044:
045: //////////////////////////////////////////////////////////////////////////
046: //////////////////////////////////////////////////////////////////////////
047: //////////////////////////////////////////////////////////////////////////
048: /// /////
049: /// R E L A T I O N S /////
050: /// B I D I R E C T I O N N E L L E S /////
051: /// /////
052: //////////////////////////////////////////////////////////////////////////
053: //////////////////////////////////////////////////////////////////////////
054: //////////////////////////////////////////////////////////////////////////
055:
056: //////////////////////////////////////////////////////////////////////////
057: // relation BIDIRECTIONNELLE 1-1 ////////////////////////
058: //////////////////////////////////////////////////////////////////////////
059:
060: /** Lien bidirectionnel 1-1 vers BBB.
061: * 1 objet AAA est en relation avec 1 objet BBB au plus.
062: * 1 objet BBB est en relation avec 1 objet AAA au plus.
063: *
064: * Les m�thodes get et set sont utiles pour assurer la bidirection.
065: *
066: * NB : si il n'y a pas d'objet en relation, getObjet renvoie null.
067: * Pour casser une relation: faire setObjet(null);
068: */
069: private BBB objetBBB_bi11;
070:
071: /** R�cup�re l'objet en relation */
072: public BBB getObjetBBB_bi11() {
073: return objetBBB_bi11;
074: }
075:
076: /** D�finit l'objet en relation */
077: public void setObjetBBB_bi11(BBB O) {
078: BBB old = objetBBB_bi11;
079: objetBBB_bi11 = O;
080: if (old != null)
081: old.setObjetAAA_bi11(null);
082: if (O != null) {
083: if (O.getObjetAAA_bi11() != this )
084: O.setObjetAAA_bi11(this );
085: }
086: }
087:
088: //////////////////////////////////////////////////////////////////////////
089: // relation BIDIRECTIONNELLE 1-n ////////////////////////
090: //////////////////////////////////////////////////////////////////////////
091:
092: /** Lien bidirectionnel 1-n vers BBB.
093: * 1 objet AAA est en relation avec n objets BBB (n pouvant etre nul).
094: * 1 objet BBB est en relation avec 1 objet AAA au plus.
095: *
096: * NB: un objet AAA ne doit pas �tre en relation plusieurs fois avec le m�me objet BBB :
097: * il est impossible de bien g�rer des relations 1-n bidirectionnelles avec doublons.
098: *
099: * ATTENTION: Pour assurer la bidirection, il faut modifier les listes uniquement avec
100: * les methodes fournies.
101: *
102: * NB: si il n'y a pas d'objet en relation, la liste est vide mais n'est pas "null".
103: * Pour casser toutes les relations, faire setListe(new ArrayList()) ou emptyListe().
104: */
105: private List liste_objetsBBB_bi1N = new ArrayList();
106:
107: /** R�cup�re la liste des objets en relation. */
108: public List getListe_objetsBBB_bi1N() {
109: return liste_objetsBBB_bi1N;
110: }
111:
112: /** D�finit la liste des objets en relation, et met � jour la relation inverse. */
113: public void setListe_objetsBBB_bi1N(List L) {
114: List old = new ArrayList(liste_objetsBBB_bi1N);
115: Iterator it1 = old.iterator();
116: while (it1.hasNext()) {
117: BBB O = (BBB) it1.next();
118: O.setObjetAAA_bi1N(null);
119: }
120: Iterator it2 = L.iterator();
121: while (it2.hasNext()) {
122: BBB O = (BBB) it2.next();
123: O.setObjetAAA_bi1N(this );
124: }
125: }
126:
127: /** R�cup�re le i�me �l�ment de la liste des objets en relation. */
128: public BBB getObjetBBB_bi1N(int i) {
129: return (BBB) liste_objetsBBB_bi1N.get(i);
130: }
131:
132: /** Ajoute un objet � la liste des objets en relation, et met � jour la relation inverse. */
133: public void addObjetBBB_bi1N(BBB O) {
134: if (O == null)
135: return;
136: liste_objetsBBB_bi1N.add(O);
137: O.setObjetAAA_bi1N(this );
138: }
139:
140: /** Enl�ve un �l�ment de la liste des objets en relation, et met � jour la relation inverse. */
141: public void removeObjetBBB_bi1N(BBB O) {
142: if (O == null)
143: return;
144: liste_objetsBBB_bi1N.remove(O);
145: O.setObjetAAA_bi1N(null);
146: }
147:
148: /** Vide la liste des objets en relation, et met � jour la relation inverse. */
149: public void emptyListe_objetsBBB_bi1N() {
150: List old = new ArrayList(liste_objetsBBB_bi1N);
151: Iterator it = old.iterator();
152: while (it.hasNext()) {
153: BBB O = (BBB) it.next();
154: O.setObjetAAA_bi1N(null);
155: }
156: }
157:
158: //////////////////////////////////////////////////////////////////////////
159: // relation BIDIRECTIONNELLE n-m /////////////////////
160: //////////////////////////////////////////////////////////////////////////
161:
162: /** Lien bidirectionnel n-m vers BBB.
163: * 1 objet AAA est en relation avec n objets BBB (n pouvant etre nul).
164: * 1 objet BBB est en relation avec m objets AAA (m pouvant etre nul).
165: *
166: * NB: Contrairement aux relation 1-n, on autorise ici qu'un objet soit en relation
167: * plusieurs fois avec le m�me objet BBB
168: *
169: * Les m�thodes get (sans indice) et set sont n�cessaires au mapping.
170: * Les autres m�thodes sont l� seulement pour faciliter l'utilisation de la relation.
171: * ATTENTION: Pour assurer la bidirection, il faut modifier les listes uniquement avec ces methodes.
172: * NB: si il n'y a pas d'objet en relation, la liste est vide mais n'est pas "null".
173: * Pour casser toutes les relations, faire setListe(new ArrayList()) ou emptyListe().
174: */
175: private List liste_objetsBBB_biNM = new ArrayList();
176:
177: /** R�cup�re l'objet en relation */
178: public List getListe_objetsBBB_biNM() {
179: return liste_objetsBBB_biNM;
180: }
181:
182: /** D�finit l'objet en relation, et met � jour la relation inverse. */
183: public void setListe_objetsBBB_biNM(List L) {
184: List old = new ArrayList(liste_objetsBBB_biNM);
185: Iterator it1 = old.iterator();
186: while (it1.hasNext()) {
187: BBB O = (BBB) it1.next();
188: liste_objetsBBB_biNM.remove(O);
189: O.getListe_objetsAAA_biNM().remove(this );
190: }
191: Iterator it2 = L.iterator();
192: while (it2.hasNext()) {
193: BBB O = (BBB) it2.next();
194: liste_objetsBBB_biNM.add(O);
195: O.getListe_objetsAAA_biNM().add(this );
196: }
197: }
198:
199: /** R�cup�re le i�me �l�ment de la liste des objets en relation. */
200: public BBB getObjetBBB_biNM(int i) {
201: return (BBB) liste_objetsBBB_biNM.get(i);
202: }
203:
204: /** Ajoute un objet � la liste des objets en relation, et met � jour la relation inverse. */
205: public void addObjetBBB_biNM(BBB O) {
206: if (O == null)
207: return;
208: liste_objetsBBB_biNM.add(O);
209: O.getListe_objetsAAA_biNM().add(this );
210: }
211:
212: /** Enl�ve un �l�ment de la liste des objets en relation, et met � jour la relation inverse. */
213: public void removeObjetBBB_biNM(BBB O) {
214: if (O == null)
215: return;
216: liste_objetsBBB_biNM.remove(O);
217: O.getListe_objetsAAA_biNM().remove(this );
218: }
219:
220: /** Vide la liste des objets en relation, et met � jour la relation inverse. */
221: public void emptyListe_objetsBBB_biNM() {
222: Iterator it = liste_objetsBBB_biNM.iterator();
223: while (it.hasNext()) {
224: BBB O = (BBB) it.next();
225: O.getListe_objetsAAA_biNM().remove(this );
226: }
227: liste_objetsBBB_biNM.clear();
228: }
229:
230: //////////////////////////////////////////////////////////////////////////
231: //////////////////////////////////////////////////////////////////////////
232: //////////////////////////////////////////////////////////////////////////
233: /// /////
234: /// R E L A T I O N S /////
235: /// M O N O D I R E C T I O N N E L L E S /////
236: /// /////
237: //////////////////////////////////////////////////////////////////////////
238: //////////////////////////////////////////////////////////////////////////
239: //////////////////////////////////////////////////////////////////////////
240:
241: //////////////////////////////////////////////////////////////////////////
242: // relation MONODIRECTIONNELLE VERS 1 OBJET /////////////////
243: //////////////////////////////////////////////////////////////////////////
244:
245: /** Lien monodirectionnel vers 0 ou 1 objet BBB.
246: *
247: * NB : un objet BBB peut pointer vers 1 ou N objets AAA, cela ne change rien
248: *
249: * NB : si il n'y a pas d'objet en relation, getObjet renvoie null.
250: * Pour casser une relation: faire setObjet(null);
251: */
252: private BBB objetBBB_mono11;
253:
254: public BBB getObjetBBB_mono11() {
255: return objetBBB_mono11;
256: }
257:
258: public void setObjetBBB_mono11(BBB O) {
259: objetBBB_mono11 = O;
260: }
261:
262: //////////////////////////////////////////////////////////////////////////
263: // relation MONODIRECTIONNELLE 1-N ////////////////////////////////
264: //////////////////////////////////////////////////////////////////////////
265:
266: /** Lien monodirectionnel vers n objets BBB (n pouvant etre nul) 1-n.
267: *
268: * Les relations 1-N ou N-M sont codees identiquement en Java.
269: * Mais cela change le mapping : en cas de relation 1-N, c'est une cle etrangere sur BBB.
270: * En cas de relation N-M, c'est une table de liaison externe.
271: *
272: * Les m�thodes sont l� seulement pour faciliter l'utilisation de la relation.
273: * Elle sont optionnelles et toutes les manipulations peuvent �tre faites directement
274: * � partir des get et set. Elles servent n�anmoins:
275: * 1/ � encapsuler les m�thodes de liste en harmonisant avec les relations
276: * bidirectionnelles et/ou persistantes;
277: * 2/ � rendre le code plus solide en v�rifiant la classe des objets ajout�s/enlev�s d�s la compilation.
278: *
279: * NB: si il n'y a pas d'objet en relation, la liste est vide mais n'est pas "null".
280: * Pour casser toutes les relations, faire setListe(new ArrayList()) ou emptyListe().
281: */
282: private List liste_objetsBBB_mono1N = new ArrayList();
283:
284: public List getListe_objetsBBB_mono1N() {
285: return liste_objetsBBB_mono1N;
286: }
287:
288: public void setListe_objetsBBB_mono1N(List L) {
289: liste_objetsBBB_mono1N = L;
290: }
291:
292: public BBB getObjetBBB_mono1N(int i) {
293: return (BBB) liste_objetsBBB_mono1N.get(i);
294: }
295:
296: public void addObjetBBB_mono1N(BBB O) {
297: if (O == null)
298: return;
299: liste_objetsBBB_mono1N.add(O);
300: }
301:
302: public void removeObjetBBB_mono1N(BBB O) {
303: if (O == null)
304: return;
305: liste_objetsBBB_mono1N.remove(O);
306: }
307:
308: public void emptyListe_objetsBBB_mono1N() {
309: liste_objetsBBB_mono1N.clear();
310: }
311:
312: //////////////////////////////////////////////////////////////////////////
313: // relation MONODIRECTIONNELLE N-M ////////////////////////////////
314: //////////////////////////////////////////////////////////////////////////
315:
316: /** Lien monodirectionnel vers n objets BBB (n pouvant etre nul) n-m.
317: *
318: * Les relations 1-N ou N-M sont codees identiquement en Java.
319: * Mais cela change le mapping : en cas de relation 1-N, c'est une cle etrangere sur BBB.
320: * En cas de relation N-M, c'est une table de liaison externe.
321: *
322: * Les m�thodes sont l� seulement pour faciliter l'utilisation de la relation.
323: * Elle sont optionnelles et toutes les manipulations peuvent �tre faites directement
324: * � partir des get et set. Elles servent n�anmoins:
325: * 1/ � encapsuler les m�thodes de liste en harmonisant avec les relations
326: * bidirectionnelles et/ou persistantes;
327: * 2/ � rendre le code plus solide en v�rifiant la classe des objets ajout�s/enlev�s d�s la compilation.
328: *
329: * NB: si il n'y a pas d'objet en relation, la liste est vide mais n'est pas "null".
330: * Pour casser toutes les relations, faire setListe(new ArrayList()) ou emptyListe().
331: */
332: private List liste_objetsBBB_monoNM = new ArrayList();
333:
334: public List getListe_objetsBBB_monoNM() {
335: return liste_objetsBBB_monoNM;
336: }
337:
338: public void setListe_objetsBBB_monoNM(List L) {
339: liste_objetsBBB_monoNM = L;
340: }
341:
342: public BBB getObjetBBB_monoNM(int i) {
343: return (BBB) liste_objetsBBB_monoNM.get(i);
344: }
345:
346: public void addObjetBBB_monoNM(BBB O) {
347: if (O == null)
348: return;
349: liste_objetsBBB_monoNM.add(O);
350: }
351:
352: public void removeObjetBBB_monoNM(BBB O) {
353: if (O == null)
354: return;
355: liste_objetsBBB_monoNM.remove(O);
356: }
357:
358: public void emptyListe_objetsBBB_monoNM() {
359: liste_objetsBBB_monoNM.clear();
360: }
361:
362: }
|