Source Code Cross Referenced for AAA.java in  » GIS » GeOxygene-1.3 » fr » ign » cogit » geoxygene » example » relations » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » GIS » GeOxygene 1.3 » fr.ign.cogit.geoxygene.example.relations 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.