1 11 package org.eclipse.jdt.internal.corext.refactoring.structure; 12 13 14 import org.eclipse.core.runtime.CoreException; 15 import org.eclipse.core.runtime.IProgressMonitor; 16 import org.eclipse.core.runtime.SubProgressMonitor; 17 18 import org.eclipse.core.resources.IFile; 19 20 import org.eclipse.jdt.core.IType; 21 import org.eclipse.jdt.core.JavaModelException; 22 23 import org.eclipse.jdt.internal.corext.Assert; 24 import org.eclipse.jdt.internal.corext.codemanipulation.CodeGenerationSettings; 25 import org.eclipse.jdt.internal.corext.refactoring.Checks; 26 import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages; 27 import org.eclipse.jdt.internal.corext.refactoring.changes.DynamicValidationStateChange; 28 import org.eclipse.jdt.internal.corext.refactoring.util.ResourceUtil; 29 import org.eclipse.jdt.internal.corext.refactoring.util.TextChangeManager; 30 import org.eclipse.jdt.internal.corext.util.JavaModelUtil; 31 import org.eclipse.jdt.internal.corext.util.WorkingCopyUtil; 32 import org.eclipse.ltk.core.refactoring.Change; 33 import org.eclipse.ltk.core.refactoring.Refactoring; 34 import org.eclipse.ltk.core.refactoring.RefactoringStatus; 35 36 public class UseSupertypeWherePossibleRefactoring extends Refactoring{ 37 38 private IType fInputType; 39 private TextChangeManager fChangeManager; 40 private IType fSuperTypeToUse; 41 private IType[] fSuperTypes; 42 private boolean fUseSupertypeInInstanceOf; 43 private CodeGenerationSettings fCodeGenerationSettings; 44 45 private UseSupertypeWherePossibleRefactoring(IType clazz, CodeGenerationSettings codeGenerationSettings){ 46 Assert.isNotNull(clazz); 47 Assert.isNotNull(codeGenerationSettings); 48 fInputType= clazz; 49 fUseSupertypeInInstanceOf= false; 50 fCodeGenerationSettings= codeGenerationSettings; 51 } 52 53 public static UseSupertypeWherePossibleRefactoring create(IType type, CodeGenerationSettings codeGenerationSettings) throws JavaModelException{ 54 if (! isAvailable(type)) 55 return null; 56 return new UseSupertypeWherePossibleRefactoring(type, codeGenerationSettings); 57 } 58 59 public static boolean isAvailable(IType type) throws JavaModelException{ 60 return Checks.isAvailable(type) && !type.isAnonymous(); 61 } 62 63 public IType getInputType(){ 64 return fInputType; 65 } 66 67 public void setUseSupertypeInInstanceOf(boolean use){ 68 fUseSupertypeInInstanceOf= use; 69 } 70 71 public boolean getUseSupertypeInInstanceOf(){ 72 return fUseSupertypeInInstanceOf; 73 } 74 75 78 public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException { 79 IType orig= (IType)WorkingCopyUtil.getOriginal(fInputType); 80 if (orig == null || ! orig.exists()){ 81 String [] keys= {fInputType.getCompilationUnit().getElementName()}; 82 String message= RefactoringCoreMessages.getFormattedString("UseSupertypeWherePossibleRefactoring.deleted", keys); return RefactoringStatus.createFatalErrorStatus(message); 84 } 85 fInputType= orig; 86 fSuperTypes= getSuperTypes(pm); 87 if (Checks.isException(fInputType, pm)){ 88 String message= RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.unavailable_on_Throwable"); return RefactoringStatus.createFatalErrorStatus(message); 90 } 91 return Checks.checkIfCuBroken(fInputType); 92 } 93 94 private IType[] getSuperTypes(IProgressMonitor pm) throws JavaModelException { 95 return JavaModelUtil.getAllSuperTypes(fInputType, pm); 96 } 97 98 public IType[] getSuperTypes(){ 99 return fSuperTypes; 100 } 101 102 public void setSuperTypeToUse(IType superType){ 103 Assert.isNotNull(superType); 104 fSuperTypeToUse= superType; 105 } 106 107 110 public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException { 111 pm.beginTask("", 1); try { 113 RefactoringStatus result= new RefactoringStatus(); 114 115 fChangeManager= createChangeManager(new SubProgressMonitor(pm, 1), result); 116 if (result.hasFatalError()) 117 return result; 118 result.merge(validateModifiesFiles()); 119 return result; 120 } finally { 121 pm.done(); 122 } 123 } 124 125 private IFile[] getAllFilesToModify(){ 126 return ResourceUtil.getFiles(fChangeManager.getAllCompilationUnits()); 127 } 128 129 private RefactoringStatus validateModifiesFiles(){ 130 return Checks.validateModifiesFiles(getAllFilesToModify(), getValidationContext()); 131 } 132 133 136 public Change createChange(IProgressMonitor pm) throws CoreException { 137 pm.beginTask("", 1); try { 139 return new DynamicValidationStateChange(RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.name"), fChangeManager.getAllChanges()); } finally { 141 pm.done(); 142 } 143 } 144 145 148 public String getName() { 149 return RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.name"); } 151 152 private TextChangeManager createChangeManager(IProgressMonitor pm, RefactoringStatus status) throws CoreException{ 153 try{ 154 pm.beginTask("", 1); pm.setTaskName(RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.analyzing...")); TextChangeManager manager= new TextChangeManager(); 157 updateReferences(manager, new SubProgressMonitor(pm, 1), status); 158 return manager; 159 } finally{ 160 pm.done(); 161 } 162 } 163 164 private void updateReferences(TextChangeManager manager, IProgressMonitor pm, RefactoringStatus status) throws CoreException { 165 pm.beginTask("", 1); try{ 167 ExtractInterfaceUtil.updateReferences(manager, fInputType, fSuperTypeToUse, 168 new RefactoringWorkingCopyOwner(), true, new SubProgressMonitor(pm, 1), 169 status, fCodeGenerationSettings); 170 } finally { 171 pm.done(); 172 } 173 } 174 } 175 | Popular Tags |