1 11 package org.eclipse.jdt.internal.debug.core.refactoring; 12 13 import java.util.ArrayList ; 14 import java.util.List ; 15 import java.util.Map ; 16 17 import org.eclipse.core.resources.ResourcesPlugin; 18 import org.eclipse.core.runtime.CoreException; 19 import org.eclipse.core.runtime.IProgressMonitor; 20 import org.eclipse.debug.core.DebugPlugin; 21 import org.eclipse.debug.core.model.IBreakpoint; 22 import org.eclipse.jdt.core.IJavaProject; 23 import org.eclipse.jdt.core.IPackageFragment; 24 import org.eclipse.jdt.core.IPackageFragmentRoot; 25 import org.eclipse.jdt.core.IType; 26 import org.eclipse.jdt.core.JavaCore; 27 import org.eclipse.jdt.debug.core.IJavaBreakpoint; 28 import org.eclipse.jdt.debug.core.IJavaClassPrepareBreakpoint; 29 import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint; 30 import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; 31 import org.eclipse.jdt.debug.core.IJavaMethodBreakpoint; 32 import org.eclipse.jdt.debug.core.IJavaWatchpoint; 33 import org.eclipse.jdt.debug.core.JDIDebugModel; 34 import org.eclipse.jdt.internal.debug.ui.BreakpointUtils; 35 import org.eclipse.ltk.core.refactoring.Change; 36 import org.eclipse.ltk.core.refactoring.NullChange; 37 import org.eclipse.ltk.core.refactoring.RefactoringStatus; 38 39 40 43 public abstract class JavaBreakpointTypeChange extends Change { 44 45 public static final int TYPE_RENAME= 1; 46 public static final int TYPE_MOVE= 2; 47 public static final int PROJECT_RENAME= 3; 48 public static final int PACKAGE_RENAME= 4; 49 public static final int PACKAGE_MOVE= 5; 50 51 private IJavaBreakpoint fBreakpoint; 52 private Object fChangedElement; 53 private Object fArgument; 54 private int fChangeType; 55 private IType fDeclaringType; 56 private boolean fIsEnable; 57 private Map fAttributes; 58 private int fHitCount; 59 60 63 public static Change createChangesForTypeRename(IType type, String newName) throws CoreException { 64 return createChangesForTypeChange(type, newName, TYPE_RENAME); 65 } 66 67 70 public static Change createChangesForTypeMove(IType type, Object destination) throws CoreException { 71 return createChangesForTypeChange(type, destination, TYPE_MOVE); 72 } 73 74 77 public static Change createChangesForProjectRename(IJavaProject project, String newName) throws CoreException { 78 List changes= new ArrayList (); 79 IBreakpoint[] breakpoints= DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(JDIDebugModel.getPluginIdentifier()); 80 for (int i= 0; i < breakpoints.length; i++) { 81 IBreakpoint breakpoint= breakpoints[i]; 82 if (breakpoint instanceof IJavaBreakpoint) { 83 IJavaBreakpoint javaBreakpoint= (IJavaBreakpoint) breakpoint; 84 IType breakpointType= BreakpointUtils.getType(javaBreakpoint); 85 if (breakpointType != null && project.equals(breakpointType.getJavaProject())) { 86 changes.add(createChange(javaBreakpoint, null, newName, PROJECT_RENAME)); 87 } 88 } 89 } 90 return JDTDebugRefactoringUtil.createChangeFromList(changes, RefactoringMessages.JavaBreakpointTypeChange_0); } 92 93 96 public static Change createChangesForPackageRename(IPackageFragment packageFragment, String newName) throws CoreException { 97 return createChangesForPackageChange(packageFragment, newName, PACKAGE_RENAME); 98 } 99 100 103 public static Change createChangesForPackageMove(IPackageFragment packageFragment, IPackageFragmentRoot destination) throws CoreException { 104 return createChangesForPackageChange(packageFragment, destination, PACKAGE_MOVE); 105 } 106 107 110 private static Change createChangesForTypeChange(IType changedType, Object argument, int changeType) throws CoreException { 111 List changes= new ArrayList (); 112 113 IBreakpoint[] breakpoints= DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(JDIDebugModel.getPluginIdentifier()); 114 String typeName= changedType.getFullyQualifiedName(); 115 for (int i= 0; i < breakpoints.length; i++) { 116 IBreakpoint breakpoint= breakpoints[i]; 118 if (breakpoint instanceof IJavaBreakpoint) { 119 IJavaBreakpoint javaBreakpoint= (IJavaBreakpoint) breakpoint; 120 IType breakpointType= BreakpointUtils.getType(javaBreakpoint); 121 if (breakpointType != null && javaBreakpoint.getTypeName().startsWith(typeName)) { 123 if (changedType.equals(breakpointType)) { 125 changes.add(createChange(javaBreakpoint, changedType, argument, changeType)); 126 } else { 127 Change change= createChangesForOuterTypeChange(javaBreakpoint, changedType, changedType, argument, changeType); 129 if (change != null) { 130 changes.add(change); 131 } 132 } 133 } 134 } 135 } 136 137 return JDTDebugRefactoringUtil.createChangeFromList(changes, RefactoringMessages.JavaBreakpointTypeChange_0); } 139 140 private static Change createChangesForOuterTypeChange(IJavaBreakpoint javaBreakpoint, IType type, IType changedType, Object argument, int changeType) throws CoreException { 141 IType[] innerTypes= type.getTypes(); 142 String breakpointTypeName= javaBreakpoint.getTypeName(); 143 IType breakpointType= BreakpointUtils.getType(javaBreakpoint); 144 for (int i= 0; i < innerTypes.length; i++) { 145 IType innerType= innerTypes[i]; 146 if (breakpointTypeName.startsWith(innerType.getFullyQualifiedName())) { 148 if (innerType.equals(breakpointType)) { 150 return createChange(javaBreakpoint, changedType, argument, changeType); 151 } 152 return createChangesForOuterTypeChange(javaBreakpoint, innerType, changedType, argument, changeType); 154 } 155 156 } 157 return null; 158 } 159 160 163 private static Change createChangesForPackageChange(IPackageFragment packageFragment, Object argument, int changeType) throws CoreException { 164 List changes= new ArrayList (); 165 IBreakpoint[] breakpoints= DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(JDIDebugModel.getPluginIdentifier()); 166 for (int i= 0; i < breakpoints.length; i++) { 167 IBreakpoint breakpoint= breakpoints[i]; 168 if (breakpoint instanceof IJavaBreakpoint) { 169 IJavaBreakpoint javaBreakpoint= (IJavaBreakpoint) breakpoint; 170 IType breakpointType= BreakpointUtils.getType(javaBreakpoint); 171 if (breakpointType != null && packageFragment.equals(breakpointType.getPackageFragment())) { 172 changes.add(createChange(javaBreakpoint, packageFragment, argument, changeType)); 173 } 174 } 175 } 176 return JDTDebugRefactoringUtil.createChangeFromList(changes, RefactoringMessages.JavaBreakpointTypeChange_0); } 178 179 182 private static Change createChange(IJavaBreakpoint javaBreakpoint, Object changedElement, Object argument, int changeType) throws CoreException { 183 if (javaBreakpoint instanceof IJavaClassPrepareBreakpoint) { 184 return new JavaClassPrepareBreakpointTypeChange((IJavaClassPrepareBreakpoint) javaBreakpoint, changedElement, argument, changeType); 185 } else if (javaBreakpoint instanceof IJavaExceptionBreakpoint) { 186 return new JavaExceptionBreakpointTypeChange((IJavaExceptionBreakpoint) javaBreakpoint, changedElement, argument, changeType); 187 } else if (javaBreakpoint instanceof IJavaMethodBreakpoint) { 188 return new JavaMethodBreakpointTypeChange((IJavaMethodBreakpoint) javaBreakpoint, changedElement, argument, changeType); 189 } else if (javaBreakpoint instanceof IJavaWatchpoint) { 190 return new JavaWatchpointTypeChange((IJavaWatchpoint) javaBreakpoint, changedElement, argument, changeType); 191 } else if (javaBreakpoint instanceof IJavaLineBreakpoint) { 192 return new JavaLineBreakpointTypeChange((IJavaLineBreakpoint) javaBreakpoint, changedElement, argument, changeType); 193 } else { 194 return null; 195 } 196 } 197 198 201 protected JavaBreakpointTypeChange(IJavaBreakpoint breakpoint, Object changedElement, Object argument, int changeType) throws CoreException { 202 fBreakpoint= breakpoint; 203 fChangedElement= changedElement; 204 fArgument= argument; 205 fChangeType= changeType; 206 fDeclaringType= BreakpointUtils.getType(breakpoint); 207 fAttributes= breakpoint.getMarker().getAttributes(); 208 fIsEnable= breakpoint.isEnabled(); 209 fHitCount= breakpoint.getHitCount(); 210 } 211 212 215 public void initializeValidationData(IProgressMonitor pm) { 216 } 217 218 221 public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException { 222 RefactoringStatus status= new RefactoringStatus(); 223 if (!fBreakpoint.isRegistered()) { 224 status.addFatalError(getErrorMessageNoMoreExists()); 225 } 226 return status; 227 } 228 229 232 public Change perform(IProgressMonitor pm) throws CoreException { 233 switch (fChangeType) { 234 case TYPE_RENAME: 235 return performTypeRename(); 236 case TYPE_MOVE: 237 return performTypeMove(); 238 case PROJECT_RENAME: 239 return performProjectRename(); 240 case PACKAGE_RENAME: 241 return performPackageRename(); 242 case PACKAGE_MOVE: 243 return performPackageMove(); 244 } 245 return null; 246 } 247 248 private Change performTypeRename() throws CoreException { 249 IType changedType= getChangedType(); 252 String oldChangedTypeName= changedType.getFullyQualifiedName('.'); 253 String newChangedTypeName; 254 IType parent= changedType.getDeclaringType(); 255 if (parent == null) { 256 newChangedTypeName= changedType.getPackageFragment().getElementName() + '.' + getNewName(); 257 } else { 258 newChangedTypeName= parent.getFullyQualifiedName('.') + '.' + getNewName(); 259 } 260 261 IType newChangedType; 262 IType newType; 263 IJavaProject project= fDeclaringType.getJavaProject(); 264 if (changedType.equals(fDeclaringType)) { 265 newType= project.findType(newChangedTypeName); 266 newChangedType= newType; 267 } else { 268 String typeNameSuffix= fDeclaringType.getFullyQualifiedName('.').substring(oldChangedTypeName.length()); 269 String newTypeName= newChangedTypeName + typeNameSuffix; 270 newType= project.findType(newTypeName); 271 newChangedType= project.findType(newChangedTypeName); 272 } 273 274 performChange(newType, newChangedType, changedType.getElementName(), TYPE_RENAME); 275 return new NullChange(); 276 } 277 278 private Change performTypeMove() throws CoreException { 279 IType changedType= getChangedType(); 282 Object destination= getDestination(); 283 String newChangedTypeName; 284 IJavaProject project; 285 if (destination instanceof IPackageFragment) { 286 IPackageFragment packageDestination= (IPackageFragment) destination; 287 project= packageDestination.getJavaProject(); 288 if (packageDestination.isDefaultPackage()) { 289 newChangedTypeName= changedType.getElementName(); 290 } else { 291 newChangedTypeName= ((IPackageFragment)destination).getElementName() + '.' + changedType.getElementName(); 292 } 293 } else { 294 IType type = (IType)destination; 295 newChangedTypeName= (type).getFullyQualifiedName('.') + '.' + changedType.getElementName(); 296 project= type.getJavaProject(); 297 } 298 299 IType newChangedType; 300 IType newType; 301 if (changedType == fDeclaringType) { 302 newType= project.findType(newChangedTypeName); 303 newChangedType= newType; 304 } else { 305 String oldChangedTypeName= changedType.getFullyQualifiedName('.'); 306 String typeNameSuffix= fDeclaringType.getFullyQualifiedName('.').substring(oldChangedTypeName.length()); 307 String newTypeName= newChangedTypeName + typeNameSuffix; 308 newType= project.findType(newTypeName); 309 newChangedType= project.findType(newChangedTypeName); 310 } 311 312 Object oldDestination= changedType.getDeclaringType(); 313 if (oldDestination == null) { 314 oldDestination= changedType.getPackageFragment(); 315 } 316 317 performChange(newType, newChangedType, oldDestination, TYPE_MOVE); 318 return new NullChange(); 319 } 320 321 private Change performProjectRename() throws CoreException { 322 IJavaProject project= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot().getProject(getNewName())); 324 IType newType= project.findType(fDeclaringType.getFullyQualifiedName('.')); 325 performChange(newType, null, fDeclaringType.getJavaProject().getElementName(), PROJECT_RENAME); 326 return new NullChange(); 327 } 328 329 private Change performPackageRename() throws CoreException { 330 IPackageFragment changedPackage= getChangePackage(); 333 IJavaProject project= fDeclaringType.getJavaProject(); 334 String newTypeName= getNewName() + fDeclaringType.getFullyQualifiedName('.').substring(changedPackage.getElementName().length()); 335 IType newType= project.findType(newTypeName); 336 performChange(newType, newType.getPackageFragment(), changedPackage.getElementName(), PACKAGE_RENAME); 337 return new NullChange(); 338 } 339 340 private Change performPackageMove() throws CoreException { 341 IPackageFragmentRoot destination= getPackageRootDestination(); 342 IPackageFragment changedPackage= getChangePackage(); 343 IJavaProject project= destination.getJavaProject(); 344 IType newType= project.findType(fDeclaringType.getFullyQualifiedName('.')); 345 performChange(newType, newType.getPackageFragment(), changedPackage.getParent(), PROJECT_RENAME); 346 return new NullChange(); 347 } 348 349 352 public Object getModifiedElement() { 353 return getBreakpoint(); 354 } 355 356 359 public IJavaBreakpoint getBreakpoint() { 360 return fBreakpoint; 361 } 362 363 367 public String getNewName() { 368 if (fChangeType == TYPE_RENAME || fChangeType == PROJECT_RENAME || fChangeType == PACKAGE_RENAME) { 369 return (String )fArgument; 370 } 371 return null; 372 } 373 374 377 private Object getDestination() { 378 if (fChangeType == TYPE_MOVE) { 379 return fArgument; 380 } 381 return null; 382 } 383 384 387 private IPackageFragmentRoot getPackageRootDestination() { 388 if (fChangeType == PACKAGE_MOVE) { 389 return (IPackageFragmentRoot)fArgument; 390 } 391 return null; 392 } 393 394 397 public IType getDeclaringType() { 398 return fDeclaringType; 399 } 400 401 404 public IType getChangedType() { 405 if (fChangeType == TYPE_RENAME || fChangeType == TYPE_MOVE) { 406 return (IType) fChangedElement; 407 } 408 return null; 409 } 410 411 414 public IPackageFragment getChangePackage() { 415 if (fChangeType == PACKAGE_RENAME || fChangeType == PACKAGE_MOVE) { 416 return (IPackageFragment) fChangedElement; 417 } 418 return null; 419 } 420 421 424 public boolean getEnable() { 425 return fIsEnable; 426 } 427 428 431 public Map getAttributes() { 432 return fAttributes; 433 } 434 435 438 public int getHitCount() { 439 return fHitCount; 440 } 441 442 445 public abstract String getErrorMessageNoMoreExists(); 446 447 451 public abstract Change performChange(IType newType, Object undoChangedElement, Object undoArgument, int changeType) throws CoreException; 452 453 } 454 | Popular Tags |