Java > Open Source Codes > org > jacorb > ir > gui > typesystem > remote > RemoteTypeSystem


1 package org.jacorb.ir.gui.typesystem.remote;
2
3 /*
4  * JacORB - a free Java ORB
5  *
6  * Copyright (C) 1997-2004 Gerald Brose.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the Free
20  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 import org.omg.CORBA.*;
24 import javax.swing.tree.*;
25 import javax.swing.table.*;
26
27 import java.util.*;
28
29 import org.jacorb.ir.gui.typesystem.*;
30
31 /**
32  * @author Joerg v. Frantzius, Gerald Brose.
33  * $Id: RemoteTypeSystem.java,v 1.12 2004/05/06 12:39:59 nicolas Exp $
34  */
35
36 public class RemoteTypeSystem
37     extends TypeSystem
38 {
39     Repository rep;
40     ORB orb = ORB.init( new String [0], null);
41     private static Hashtable knownIRObjects = new Hashtable();
42
43     private static String test = "";
44     private static int test2;
45
46     /**
47      */
48
49     public RemoteTypeSystem ()
50     {
51         try
52         {
53             this.rep =
54                 RepositoryHelper.narrow(
55                     orb.resolve_initial_references("InterfaceRepository"));
56         }
57         catch (Exception e)
58         {
59             e.printStackTrace();
60         }
61     }
62
63     /**
64      * @param ior java.lang.String
65      */
66
67     public RemoteTypeSystem (String ior)
68     {
69         org.omg.CORBA.Object obj = orb.string_to_object(ior);
70         try
71         {
72             rep = RepositoryHelper.narrow(obj);
73         }
74         catch( org.omg.CORBA.BAD_PARAM bp )
75         {
76             System.out.println("IOR is not a Repository, sorry.");
77             System.exit(0);
78         }
79     }
80
81     /**
82      * Creates a TreeModel that contains only root enthält. To expand
83      * nodes, the TreeExpansionListener returned from
84      * getTreeExpansionListener(treeModel) needs to be registered
85      * with JTree.
86      * @return javax.swing.tree.DefaultTreeModel
87      * @param root org.jacorb.ir.gui.typesystem.ModelParticipant
88      */
89
90     public DefaultTreeModel createTreeModelRoot()
91     {
92         if (treeModel!=null)
93         {
94             return treeModel;
95         }
96         else
97         {
98             IRRepository startNode = new IRRepository(rep);
99             treeModel =
100                 ModelBuilder.getSingleton().createTreeModelRoot(startNode);
101             return treeModel;
102         }
103     }
104
105     /**
106      * @return org.jacorb.ir.gui.typesystem.TypeSystemNode
107      * @param irNode org.omg.CORBA.IRObject
108      */
109
110     public static TypeSystemNode createTypeSystemNode(java.lang.Object obj)
111     {
112         if (obj == null)
113         {
114             //Debug.output (3, "A reference from the Repository is null... (but it should not)");
115 return null;
116         }
117         IRObject irObject = null;
118         TypeSystemNode result = null;
119
120         System.out.flush();
121
122         // Typ-Unterscheidung für obj vornehmen und korrespondierendes
123 // org.jacorb.ir.gui.typesystem-Objekt erzeugen.
124 // knownIRObjects: zu jedem Objekt des IR wird das
125 // korrespondierende org.jacorb.ir.gui.typesystem-Objekt
126 // festgehalten, damit letzteres nicht mehrfach für
127 /// das selbe IR-Objekt erzeugt wird
128 // (die Abbildung von IR-Objekten auf
129 // org.jacorb.ir.gui.typesystem-Objekte wird sozusagen injektiv gehalten)
130
131         // Je nach Typ wird ein anderer Hashcode verwendet,
132 // um das obj in knownIRObjects abzulegen:
133 // die von Object geerbte hashcode() Methode reicht
134 // hier nicht, weil sie equals() verwendet und
135 // diese Methode nicht für alle möglichen Typen von
136 /// obj korrekt redefiniert wurde (testet nur auf
137 // Objekt-Identität)
138
139         if ( obj instanceof IRObject )
140         {
141             try
142             {
143                 irObject = IRObjectHelper.narrow((org.omg.CORBA.Object )obj);
144             }
145             catch( org.omg.CORBA.BAD_PARAM bp )
146             {
147             }
148         }
149         if( irObject != null )
150         {
151             // insbesondere "echte" IRObjects können beim Aufbau
152 // des Trees mehrmals referenziert
153 // und dieser Methode als Argument übergeben werden
154 // if (knownIRObjects.get(ORB.init().object_to_string((org.omg.CORBA.Object)irObject))!=null) {
155 // return (TypeSystemNode)knownIRObjects.get(ORB.init().object_to_string((org.omg.CORBA.Object)irObject));
156 // }
157
158             result = (TypeSystemNode)knownIRObjects.get(irObject);
159
160             if( result != null )
161             {
162 // Debug.output(2, result.getInstanceNodeTypeName()+" "+
163 // result.getAbsoluteName()+" (cached)");
164 return result;
165             }
166
167             // try again using Repository-ID
168 try
169             {
170                 Contained contained =
171                     ContainedHelper.narrow((org.omg.CORBA.Object )irObject);
172
173                 result = (TypeSystemNode)knownIRObjects.get(contained.id());
174                 if (result != null)
175                 {
176 // Debug.output(2,
177 // result.getInstanceNodeTypeName()+" "+
178 // result.getAbsoluteName()+" (cached by id)");
179 return result;
180                 }
181             }
182             catch( org.omg.CORBA.BAD_PARAM bp )
183             {}
184
185             try
186             {
187                 switch(irObject.def_kind().value())
188                 {
189                     // create IRObjects
190 case DefinitionKind._dk_Module:
191                         result = new IRModule(irObject);
192                         break;
193                     case DefinitionKind._dk_Interface:
194                         result = new IRInterface(irObject);
195                         break;
196                     case DefinitionKind._dk_Constant:
197                         result = new IRConstant(irObject);
198                         break;
199                     case DefinitionKind._dk_Attribute:
200                         result = new IRAttribute(irObject);
201                         break;
202                     case DefinitionKind._dk_Operation:
203                         result = new IROperation(irObject);
204                         break;
205                         /* Typedef ist eine abstrakte Oberklasse,
206                              theoretisch dürfte es kein Objekt mit
207                              DefinitionKind._dk_Typedef geben case
208                              DefinitionKind._dk_Typedef: result = new
209                              IRTypedef(irObject); break; */
210                     case DefinitionKind._dk_Exception:
211                         result = new IRException(irObject);
212                         break;
213                     case DefinitionKind._dk_Struct:
214                         result = new IRStruct(irObject);
215                         break;
216                     case DefinitionKind._dk_Union:
217                         result = new IRUnion(irObject);
218                         break;
219                     case DefinitionKind._dk_Primitive:
220                         result = new IRPrimitive(irObject);
221                         break;
222                     case DefinitionKind._dk_Fixed:
223                         result = new IRFixed(irObject);
224                         break;
225                     case DefinitionKind._dk_String:
226                         result = new IRString(irObject);
227                         break;
228                     case DefinitionKind._dk_Wstring:
229                         result = new IRWstring(irObject);
230                         break;
231                     case DefinitionKind._dk_Alias:
232                         result = new IRAlias(irObject);
233                         break;
234                     case DefinitionKind._dk_Sequence:
235                         result = new IRSequence(irObject);
236                         break;
237                     case DefinitionKind._dk_Enum:
238                         result = new IREnum(irObject);
239                         break;
240                     case DefinitionKind._dk_Array:
241                         result = new IRArray(irObject);
242                         break;
243                     case DefinitionKind._dk_ValueBox:
244                         result = new IRValueBox(irObject);
245                         break;
246                     case DefinitionKind._dk_Value:
247                         result = new IRValue(irObject);
248                         break;
249                     case DefinitionKind._dk_ValueMember:
250                         result = new IRValueMember(irObject);
251                         break;
252                     default:
253                         System.out.println("Unknown/senseless DefinitionKind returned from Repository: "+irObject.def_kind().value());
254                         break;
255                 } // switch
256 }
257             catch( Exception exc )
258             {
259                 //Debug.output( 3, exc );
260 }
261
262             if ( result instanceof IRInterface &&
263                  ((IRInterface)result).getName().equals("Container"))
264             {
265                 int nanu = ((IRNode)result).irObject.hashCode();
266                 int nanu2 = irObject.hashCode();
267                 if (test.equals(((IRInterface)result).getAbsoluteName()))
268                 {
269                     System.out.println("bug!");
270                 }
271                 test = ((IRInterface)result).getAbsoluteName();
272                 test2=((IRNode)result).irObject.hashCode();
273             }
274
275             if (result != null)
276             {
277                 // knownIRObjects.put(ORB.init().object_to_string((org.omg.CORBA.Object)irObject),result);
278 knownIRObjects.put(irObject,result);
279
280                 if (knownIRObjects.get(irObject) == null)
281                 {
282                     System.out.println( "wasislos?");
283                 }
284
285                 if (result instanceof IRNode &&
286                     (!((IRNode)result).repositoryID.equals("")))
287                 {
288                     knownIRObjects.put(((IRNode)result).repositoryID,result);
289                 }
290             }
291         } // if (irObjectHelper.narrow...)
292 else
293         {
294             // kein IRObject sondern lokales Objekt
295 // members von Structs, Unions und Enums können nicht
296 // von anderen IRObjects referenziert werden,
297 // wir wollen trotzdem für mögliche mehrfache Aufrufe
298 // das selbe org.jacorb.ir.gui.typesystem-Objekt zurückgeben
299 if (knownIRObjects.get(obj)!=null) {
300                 return (TypeSystemNode)knownIRObjects.get(obj);
301             }
302
303             if (obj instanceof StructMember)
304             {
305                 // als Hash-Key nehmen wir einen IR-weit eindeutigen String
306 StructMember structMember = (StructMember)obj;
307                 if (knownIRObjects.get("structmember" + structMember.name +
308                                        structMember.type.kind().toString())!=null)
309                 {
310                     return (TypeSystemNode)knownIRObjects.get("structmember" +
311                                                               structMember.name +
312                                                               structMember.type.kind().toString());
313                 }
314                 result = new IRStructMember((StructMember)obj);
315                 knownIRObjects.put("structmember" + structMember.name +
316                                    structMember.type.kind().toString(),result);
317             }
318             else if (obj instanceof UnionMember)
319             {
320                 UnionMember unionMember = (UnionMember)obj;
321                 if (knownIRObjects.get("unionmember" +
322                                        unionMember.name +
323                                        unionMember.type.kind().toString())!=null)
324                 {
325                     return (TypeSystemNode)knownIRObjects.get("unionmember" +
326                                                               unionMember.name +
327                                                               unionMember.type.kind().toString());
328                 }
329                 result = new IRUnionMember((UnionMember)obj);
330                 knownIRObjects.put("unionmember" + unionMember.name +
331                                    unionMember.type.kind().toString(),result);
332             }
333             else
334                 if (obj instanceof ParameterDescription)
335                 {
336                     ParameterDescription parDesc = (ParameterDescription)obj;
337                     if (knownIRObjects.get("parameter" + parDesc.name +
338                                            parDesc.type.kind().toString())!=null)
339                     {
340                         return (TypeSystemNode)knownIRObjects.get("parameter" +
341                                                                   parDesc.name +
342                                                                   parDesc.type.kind().toString());
343                     }
344                     result = new IRParameter(parDesc);
345                     knownIRObjects.put("parameter" + parDesc.name +
346                                        parDesc.type.kind().toString(),result);
347                 }
348                 else if (obj instanceof String )
349                 {
350                     if (knownIRObjects.get((String )obj)!=null)
351                     {
352                         return (IREnumMember)knownIRObjects.get((String )obj);
353                     }
354                     result = new IREnumMember((String )obj);
355                     knownIRObjects.put(obj,result);
356                 }
357         } // else (obj war kein IRObject)
358
359         if( result != null )
360         {
361 // Debug.output( 2, result.getInstanceNodeTypeName()+" "+
362 // result.getAbsoluteName());
363 }
364 // else
365 // Debug.output( 2, "result is null ");
366 return result;
367     }
368
369     /**
370      * @return TableModel
371      * @param node org.jacorb.ir.gui.typesystem.TypeSystemNode
372      */
373
374     public DefaultTableModel getTableModel(DefaultMutableTreeNode treeNode)
375     {
376         DefaultTableModel tableModel = new DefaultTableModel();
377         java.lang.Object [] colIdentifiers = {"Item","Type","Name"};
378
379         tableModel.setColumnIdentifiers(colIdentifiers);
380
381         if (treeNode!=null)
382         {
383             if (treeNode.getUserObject() instanceof AbstractContainer)
384             {
385                 for (int i=0; i<treeModel.getChildCount(treeNode); i++)
386                 {
387                     TypeSystemNode childNode =
388                         (TypeSystemNode)((DefaultMutableTreeNode)(treeNode.getChildAt(i))).getUserObject();
389                     String type = "";
390                     if (childNode instanceof TypeAssociator)
391                     {
392                         type = ((TypeAssociator)childNode).getAssociatedType();
393                     }
394                     java.lang.Object [] row = {new NodeMapper(childNode,childNode.getInstanceNodeTypeName()),
395                                               new NodeMapper(childNode,type),
396                                               new NodeMapper(childNode,childNode.getName())};
397                     tableModel.addRow(row);
398                 }
399             }
400         }
401         return tableModel;
402     }
403
404     /**
405      * @return javax.swing.event.TreeExpansionListener
406      * @param treeModel javax.swing.tree.DefaultTreeModel
407      */
408     public javax.swing.event.TreeExpansionListener getTreeExpansionListener(TreeModel treeModel) {
409         return ModelBuilder.getSingleton().getTreeExpansionListener(treeModel);
410     }
411
412     /**
413      * @return javax.swing.tree.TreeModel
414      * @param rootModPart org.jacorb.ir.gui.typesystem.ModelParticipant
415      */
416
417     public TreeModel getTreeModel()
418     {
419         if (treeModel!=null)
420         {
421             return treeModel;
422         }
423         else
424         {
425             try
426             {
427                 IRRepository startNode = new IRRepository(rep);
428                 treeModel = ModelBuilder.getSingleton().buildTreeModelAsync(startNode);
429                 return treeModel;
430             }
431             catch (Exception e)
432             {
433                 e.printStackTrace();
434             }
435         }
436         return null;
437     }
438
439     /**
440      * @param args java.lang.String[]
441      */
442
443     public static void main(String args[])
444     {
445         TreeModel dummy = new RemoteTypeSystem().getTreeModel();
446         return;
447     }
448
449 }
450

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags