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 |