KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > corext > refactoring > structure > UseSupertypeWherePossibleRefactoring


1 /*******************************************************************************
2  * Copyright (c) 2000, 2004 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/

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     /*
76      * @see org.eclipse.jdt.internal.corext.refactoring.base.Refactoring#checkActivation(IProgressMonitor)
77      */

78     public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
79         IType orig= (IType)WorkingCopyUtil.getOriginal(fInputType);
80         if (orig == null || ! orig.exists()){
81             String JavaDoc[] keys= {fInputType.getCompilationUnit().getElementName()};
82             String JavaDoc message= RefactoringCoreMessages.getFormattedString("UseSupertypeWherePossibleRefactoring.deleted", keys); //$NON-NLS-1$
83
return RefactoringStatus.createFatalErrorStatus(message);
84         }
85         fInputType= orig;
86         fSuperTypes= getSuperTypes(pm);
87         if (Checks.isException(fInputType, pm)){
88             String JavaDoc message= RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.unavailable_on_Throwable"); //$NON-NLS-1$
89
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     /*
108      * @see org.eclipse.jdt.internal.corext.refactoring.base.Refactoring#checkInput(IProgressMonitor)
109      */

110     public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException {
111         pm.beginTask("", 1);//$NON-NLS-1$
112
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     /*
134      * @see org.eclipse.jdt.internal.corext.refactoring.base.IRefactoring#createChange(IProgressMonitor)
135      */

136     public Change createChange(IProgressMonitor pm) throws CoreException {
137         pm.beginTask("", 1); //$NON-NLS-1$
138
try {
139             return new DynamicValidationStateChange(RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.name"), fChangeManager.getAllChanges());//$NON-NLS-1$
140
} finally {
141             pm.done();
142         }
143     }
144
145     /*
146      * @see org.eclipse.jdt.internal.corext.refactoring.base.IRefactoring#getName()
147      */

148     public String JavaDoc getName() {
149         return RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.name"); //$NON-NLS-1$
150
}
151
152     private TextChangeManager createChangeManager(IProgressMonitor pm, RefactoringStatus status) throws CoreException{
153         try{
154             pm.beginTask("", 1); //$NON-NLS-1$
155
pm.setTaskName(RefactoringCoreMessages.getString("UseSupertypeWherePossibleRefactoring.analyzing...")); //$NON-NLS-1$
156
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); //$NON-NLS-1$
166
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