|
1
19
20 package org.netbeans.modules.debugger.jpda.ui.models;
21
22 import java.util.HashSet  ;
23 import org.netbeans.api.debugger.jpda.Field;
24 import org.netbeans.api.debugger.jpda.InvalidExpressionException;
25 import org.netbeans.api.debugger.jpda.ObjectVariable;
26 import org.netbeans.api.debugger.jpda.Variable;
27 import org.netbeans.spi.debugger.jpda.VariablesFilterAdapter;
28 import org.netbeans.spi.debugger.ui.Constants;
29 import org.netbeans.spi.viewmodel.TableModel;
30 import org.netbeans.spi.viewmodel.TreeModel;
31 import org.netbeans.spi.viewmodel.UnknownTypeException;
32 import org.openide.ErrorManager;
33
34
35
39 public class JavaVariablesFilter extends VariablesFilterAdapter {
40
41 public String [] getSupportedTypes () {
42 return new String [] {
43 "java.lang.String",
44 "java.lang.StringBuffer",
45
46 "java.lang.Character",
47 "java.lang.Integer",
48 "java.lang.Float",
49 "java.lang.Byte",
50 "java.lang.Boolean",
51 "java.lang.Double",
52 "java.lang.Long",
53 "java.lang.Short",
54
55 "java.lang.ref.WeakReference",
56
57 "java.util.ArrayList",
58 "java.util.HashSet",
59 "java.util.LinkedHashSet",
60 "java.util.LinkedList",
61 "java.util.Stack",
62 "java.util.TreeSet",
63 "java.util.Vector",
64 "java.util.Hashtable",
65 "java.util.Hashtable$Entry",
66 "java.util.HashMap",
67 "java.util.HashMap$Entry",
68 "java.util.IdentityHashMap",
69 "java.util.AbstractMap$SimpleEntry",
70 "java.util.TreeMap",
71 "java.util.TreeMap$Entry",
72 "java.util.WeakHashMap",
73 "java.util.LinkedHashMap",
74 "java.util.LinkedHashMap$Entry",
75
76 "java.beans.PropertyChangeSupport"
77 };
78 }
79
80 public String [] getSupportedAncestors () {
81 return new String [] {
82 };
83 }
84
85
98 public Object [] getChildren (
99 TreeModel original,
100 Variable variable,
101 int from,
102 int to
103 ) throws UnknownTypeException {
104
105 String type = variable.getType ();
106
107 if (isToArrayType (type)) {
108 ObjectVariable ov = (ObjectVariable) variable;
109 try {
110 ov = (ObjectVariable) ov.invokeMethod (
111 "toArray",
112 "()[Ljava/lang/Object;",
113 new Variable [0]
114 );
115 return original.getChildren(ov, from, to);
116 } catch (NoSuchMethodException e) {
117 Field elementData = ov.getField("elementData");
118 if (elementData != null) {
119 return original.getChildren(elementData, from, to);
120 } else {
121 ErrorManager.getDefault().notify(e);
122 }
123 } catch (InvalidExpressionException e) {
124 if ( (e.getTargetException () != null) &&
125 (e.getTargetException () instanceof
126 UnsupportedOperationException )
127 ) {
128 return original.getChildren (variable, from, to);
130 }
131 ErrorManager.getDefault().notify(e);
132 }
133 }
134 if (isMapMapType (type))
135 try {
136 ObjectVariable ov = (ObjectVariable) variable;
137 ov = (ObjectVariable) ov.invokeMethod (
138 "entrySet",
139 "()Ljava/util/Set;",
140 new Variable [0]
141 );
142 ov = (ObjectVariable) ov.invokeMethod (
143 "toArray",
144 "()[Ljava/lang/Object;",
145 new Variable [0]
146 );
147 return original.getChildren(ov, from, to);
148 } catch (InvalidExpressionException e) {
149 if ( (e.getTargetException () != null) &&
150 (e.getTargetException () instanceof
151 UnsupportedOperationException )
152 ) {
153 return original.getChildren (variable, from, to);
155 }
156 ErrorManager.getDefault().notify(e);
157 } catch (NoSuchMethodException e) {
158 ErrorManager.getDefault().notify(e);
159 }
160 if ( isMapEntryType (type)
161 ) {
162 ObjectVariable ov = (ObjectVariable) variable;
163 Field[] fs = new Field [2];
164 fs [0] = ov.getField ("key");
165 fs [1] = ov.getField ("value");
166 return fs;
167 }
168 if ( "java.beans.PropertyChangeSupport".equals (type)
169 )
170 try {
171 ObjectVariable ov = (ObjectVariable) variable;
172 return ((ObjectVariable) ov.invokeMethod (
173 "getPropertyChangeListeners",
174 "()[Ljava/beans/PropertyChangeListener;",
175 new Variable [0]
176 )).getFields (from, to);
177 } catch (InvalidExpressionException e) {
178 if ( (e.getTargetException () != null) &&
179 (e.getTargetException () instanceof
180 UnsupportedOperationException )
181 ) {
182 return original.getChildren (variable, from, to);
184 }
185 ErrorManager.getDefault().notify(e);
186 } catch (NoSuchMethodException e) {
187 ErrorManager.getDefault().notify(e);
188 }
189 if ( "java.lang.ref.WeakReference".equals (type)
202 ) {
203 ObjectVariable ov = (ObjectVariable) variable;
204 return new Object [] {ov.getField ("referent")};
205 }
206 return original.getChildren (variable, from, to);
207 }
208
209
224 public int getChildrenCount (TreeModel original, Variable variable)
225 throws UnknownTypeException {
226
227 String type = variable.getType();
228
229 if (isToArrayType (type)) {
230 ObjectVariable ov = (ObjectVariable) variable;
231 try {
232 ov = (ObjectVariable) ov.invokeMethod (
233 "toArray",
234 "()[Ljava/lang/Object;",
235 new Variable [0]
236 );
237 return original.getChildrenCount(ov);
238 } catch (NoSuchMethodException e) {
239 Field elementData = ov.getField("elementData");
240 if (elementData != null) {
241 return original.getChildrenCount(elementData);
242 } else {
243 ErrorManager.getDefault().notify(e);
244 }
245 } catch (InvalidExpressionException e) {
246 if ( (e.getTargetException () != null) &&
247 (e.getTargetException () instanceof
248 UnsupportedOperationException )
249 ) {
250 return original.getChildrenCount(variable);
252 }
253 ErrorManager.getDefault().notify(e);
254 }
255 } else if (isMapMapType (type)) {
256 try {
257 ObjectVariable ov = (ObjectVariable) variable;
258 ov = (ObjectVariable) ov.invokeMethod (
259 "entrySet",
260 "()Ljava/util/Set;",
261 new Variable [0]
262 );
263 ov = (ObjectVariable) ov.invokeMethod (
264 "toArray",
265 "()[Ljava/lang/Object;",
266 new Variable [0]
267 );
268 return original.getChildrenCount(ov);
269 } catch (InvalidExpressionException e) {
270 if ( (e.getTargetException () != null) &&
271 (e.getTargetException () instanceof
272 UnsupportedOperationException )
273 ) {
274 return original.getChildrenCount(variable);
276 }
277 ErrorManager.getDefault().notify(e);
278 } catch (NoSuchMethodException e) {
279 ErrorManager.getDefault().notify(e);
280 }
281 }
282 else if (isMapEntryType(type)) {
283 return 2;
284 }
285 else if ("java.beans.PropertyChangeSupport".equals(type)) {
286 return getChildren (original, variable, 0, 0).length;
287 }
288 else if ("java.lang.ref.WeakReference".equals(type)) {
289 return 1;
290 }
291 return original.getChildrenCount(variable);
292 }
293
294
302 public boolean isLeaf (TreeModel original, Variable variable)
303 throws UnknownTypeException {
304 String type = variable.getType ();
305
306 if ( isLeafType (type)
308 ) return true;
309 return original.isLeaf (variable);
310 }
311
312 public Object getValueAt (
313 TableModel original,
314 Variable variable,
315 String columnID
316 ) throws UnknownTypeException {
317
318 String type = variable.getType ();
319 ObjectVariable ov = (ObjectVariable) variable;
320 if ( isMapEntryType (type) &&
321 ( columnID == Constants.LOCALS_VALUE_COLUMN_ID ||
322 columnID == Constants.WATCH_VALUE_COLUMN_ID)
323 ) {
324 return ov.getField ("key").getValue () + "=>" +
325 ov.getField ("value").getValue ();
326 }
327 if ( isGetValueType (type) &&
328 ( columnID == Constants.LOCALS_VALUE_COLUMN_ID ||
329 columnID == Constants.WATCH_VALUE_COLUMN_ID)
330 ) {
331 return ov.getField ("value").getValue ();
332 }
333 if ( isToStringValueType (type) &&
334 ( columnID == Constants.LOCALS_VALUE_COLUMN_ID ||
335 columnID == Constants.WATCH_VALUE_COLUMN_ID)
336 ) {
337 try {
338 return "\""+ov.getToStringValue ()+"\"";
339 } catch (InvalidExpressionException ex) {
340 if ( (ex.getTargetException () != null) &&
341 (ex.getTargetException () instanceof
342 UnsupportedOperationException )
343 ) {
344 return original.getValueAt (variable, columnID);
346 }
347 return ex.getLocalizedMessage ();
348 }
349 }
350 return original.getValueAt (variable, columnID);
351 }
352
353 public void setValueAt(TableModel original, Variable variable,
354 String columnID, Object value) throws UnknownTypeException {
355 String type = variable.getType();
356 if (isToStringValueType(type) &&
357 (columnID == Constants.LOCALS_VALUE_COLUMN_ID ||
358 columnID == Constants.WATCH_VALUE_COLUMN_ID)) {
359 String expression = (String ) value;
360 if (expression.startsWith("\"") && expression.endsWith("\"") && expression.length() > 1) {
361 expression = "new " + type + "(\"" + convertToStringInitializer(expression.substring(1, expression.length() - 1)) + "\")";
363 original.setValueAt(variable, columnID, expression);
364 return ;
365 }
366 }
367 original.setValueAt(variable, columnID, value);
368 }
369
370 private static String convertToStringInitializer (String s) {
371 StringBuffer sb = new StringBuffer ();
372 int i, k = s.length ();
373 for (i = 0; i < k; i++)
374 switch (s.charAt (i)) {
375 case '\b':
376 sb.append ("\\b");
377 break;
378 case '\f':
379 sb.append ("\\f");
380 break;
381 case '\\':
382 sb.append ("\\\\");
383 break;
384 case '\t':
385 sb.append ("\\t");
386 break;
387 case '\r':
388 sb.append ("\\r");
389 break;
390 case '\n':
391 sb.append ("\\n");
392 break;
393 case '\"':
394 sb.append ("\\\"");
395 break;
396 default:
397 sb.append (s.charAt (i));
398 }
399 return sb.toString();
400 }
401
402
403
405 private static HashSet getValueType;
406 private static boolean isGetValueType (String type) {
407 if (getValueType == null) {
408 getValueType = new HashSet ();
409 getValueType.add ("java.lang.Character");
410 getValueType.add ("java.lang.Integer");
411 getValueType.add ("java.lang.Float");
412 getValueType.add ("java.lang.Byte");
413 getValueType.add ("java.lang.Boolean");
414 getValueType.add ("java.lang.Double");
415 getValueType.add ("java.lang.Long");
416 getValueType.add ("java.lang.Short");
417 }
418 return getValueType.contains (type);
419 }
420
421 private static HashSet leafType;
422 private static boolean isLeafType (String type) {
423 if (leafType == null) {
424 leafType = new HashSet ();
425 leafType.add ("java.lang.String");
426 leafType.add ("java.lang.Character");
427 leafType.add ("java.lang.Integer");
428 leafType.add ("java.lang.Float");
429 leafType.add ("java.lang.Byte");
430 leafType.add ("java.lang.Boolean");
431 leafType.add ("java.lang.Double");
432 leafType.add ("java.lang.Long");
433 leafType.add ("java.lang.Short");
434 }
435 return leafType.contains (type);
436 }
437
438 private static HashSet toStringValueType;
439 private static boolean isToStringValueType (String type) {
440 if (toStringValueType == null) {
441 toStringValueType = new HashSet ();
442 toStringValueType.add ("java.lang.StringBuffer");
443 }
444 return toStringValueType.contains (type);
445 }
446
447 private static HashSet mapEntryType;
448 private static boolean isMapEntryType (String type) {
449 if (mapEntryType == null) {
450 mapEntryType = new HashSet ();
451 mapEntryType.add ("java.util.HashMap$Entry");
452 mapEntryType.add ("java.util.Hashtable$Entry");
453 mapEntryType.add ("java.util.AbstractMap$SimpleEntry");
454 mapEntryType.add ("java.util.LinkedHashMap$Entry");
455 mapEntryType.add ("java.util.TreeMap$Entry");
456 }
457 return mapEntryType.contains (type);
458 }
459
460 private static HashSet mapMapType;
461 private static boolean isMapMapType (String type) {
462 if (mapMapType == null) {
463 mapMapType = new HashSet ();
464 mapMapType.add ("java.util.HashMap");
465 mapMapType.add ("java.util.IdentityHashMap");
466 mapMapType.add ("java.util.Hashtable");
467 mapMapType.add ("java.util.TreeMap");
468 mapMapType.add ("java.util.WeakHashMap");
469 mapMapType.add ("java.util.LinkedHashMap");
470 mapMapType.add ("java.util.concurrent.ConcurrentHashMap");
471 mapMapType.add ("java.util.EnumMap");
472 }
473 return mapMapType.contains (type);
474 }
475
476 private static HashSet toArrayType;
477 private static boolean isToArrayType (String type) {
478 if (toArrayType == null) {
479 toArrayType = new HashSet ();
480 toArrayType.add ("java.util.ArrayList");
481 toArrayType.add ("java.util.HashSet");
482 toArrayType.add ("java.util.LinkedHashSet");
483 toArrayType.add ("java.util.LinkedList");
484 toArrayType.add ("java.util.Stack");
485 toArrayType.add ("java.util.TreeSet");
486 toArrayType.add ("java.util.Vector");
487 toArrayType.add ("java.util.concurrent.CopyOnWriteArraySet");
488 toArrayType.add ("java.util.EnumSet");
489 }
490 return toArrayType.contains (type);
491 }
492 }
493 |
Popular Tags |
Java API By Example, From Geeks To Geeks.