KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > corext > refactoring > reorg > DeleteModifications


1 /*******************************************************************************
2  * Copyright (c) 2000, 2006 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package org.eclipse.jdt.internal.corext.refactoring.reorg;
12
13 import java.util.ArrayList JavaDoc;
14 import java.util.Arrays JavaDoc;
15 import java.util.Iterator JavaDoc;
16 import java.util.List JavaDoc;
17
18 import org.eclipse.core.runtime.CoreException;
19
20 import org.eclipse.core.resources.IContainer;
21 import org.eclipse.core.resources.IFile;
22 import org.eclipse.core.resources.IFolder;
23 import org.eclipse.core.resources.IResource;
24 import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
25
26 import org.eclipse.ltk.core.refactoring.RefactoringStatus;
27 import org.eclipse.ltk.core.refactoring.participants.DeleteArguments;
28 import org.eclipse.ltk.core.refactoring.participants.ParticipantManager;
29 import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant;
30 import org.eclipse.ltk.core.refactoring.participants.RefactoringProcessor;
31 import org.eclipse.ltk.core.refactoring.participants.SharableParticipants;
32
33 import org.eclipse.jdt.core.ICompilationUnit;
34 import org.eclipse.jdt.core.IJavaElement;
35 import org.eclipse.jdt.core.IJavaProject;
36 import org.eclipse.jdt.core.IPackageFragment;
37 import org.eclipse.jdt.core.IPackageFragmentRoot;
38 import org.eclipse.jdt.core.IType;
39 import org.eclipse.jdt.core.JavaCore;
40 import org.eclipse.jdt.core.JavaModelException;
41
42 import org.eclipse.jdt.internal.corext.refactoring.util.JavaElementUtil;
43
44 /**
45  * A modification collector for Java element delete operations.
46  */
47 public class DeleteModifications extends RefactoringModifications {
48     
49     private List JavaDoc/*<IJavaElement>*/ fDelete;
50     
51     /**
52      * Contains the actual packages when executing
53      * <code>handlePackageFragmentDelete</code>. This is part of the
54      * algorithm to check if a parent folder can be deleted.
55      */
56     private List JavaDoc/*<IPackageFragment>*/ fPackagesToDelete;
57     
58     public DeleteModifications() {
59         fDelete= new ArrayList JavaDoc();
60         fPackagesToDelete= new ArrayList JavaDoc();
61     }
62     
63     public void delete(IResource resource) {
64         getResourceModifications().addDelete(resource);
65     }
66     
67     public void delete(IResource[] resources) {
68         for (int i= 0; i < resources.length; i++) {
69             delete(resources[i]);
70         }
71     }
72     
73     public void delete(IJavaElement[] elements) throws CoreException {
74         for (int i= 0; i < elements.length; i++) {
75             delete(elements[i]);
76         }
77     }
78     
79     public void delete(IJavaElement element) throws CoreException {
80         switch(element.getElementType()) {
81             case IJavaElement.JAVA_MODEL:
82                 return;
83             case IJavaElement.JAVA_PROJECT:
84                 fDelete.add(element);
85                 if (element.getResource() != null)
86                     getResourceModifications().addDelete(element.getResource());
87                 return;
88             case IJavaElement.PACKAGE_FRAGMENT_ROOT:
89                 fDelete.add(element);
90                 IResource resource= element.getResource();
91                 // Flag an resource change even if we have an archive. If it is
92 // internal (we have a underlying resource then we have a resource
93 // change.
94 if (resource != null)
95                     getResourceModifications().addDelete(resource);
96                 IJavaProject[] referencingProjects= JavaElementUtil.getReferencingProjects((IPackageFragmentRoot) element);
97                 for (int i= 0; i < referencingProjects.length; i++) {
98                     IFile classpath= referencingProjects[i].getProject().getFile(".classpath"); //$NON-NLS-1$
99 getResourceModifications().addChanged(classpath);
100                 }
101                 return;
102             case IJavaElement.PACKAGE_FRAGMENT:
103                 fDelete.add(element);
104                 fPackagesToDelete.add(element);
105                 return;
106             case IJavaElement.COMPILATION_UNIT:
107                 fDelete.add(element);
108                 IType[] types= ((ICompilationUnit)element).getTypes();
109                 fDelete.addAll(Arrays.asList(types));
110                 if (element.getResource() != null)
111                     getResourceModifications().addDelete(element.getResource());
112                 return;
113             default:
114                 fDelete.add(element);
115         }
116         
117     }
118     
119     /**
120      * @return a List of IResources that are removed by package deletes
121      */
122     public List JavaDoc/*<IResource>*/ postProcess() throws CoreException {
123         ArrayList JavaDoc resourcesCollector= new ArrayList JavaDoc();
124         for (Iterator JavaDoc iter= fPackagesToDelete.iterator(); iter.hasNext();) {
125             IPackageFragment pack= (IPackageFragment) iter.next();
126             handlePackageFragmentDelete(pack, resourcesCollector);
127         }
128         return resourcesCollector;
129     }
130     
131     public void buildDelta(IResourceChangeDescriptionFactory deltaFactory) {
132         getResourceModifications().buildDelta(deltaFactory);
133     }
134     
135     public RefactoringParticipant[] loadParticipants(RefactoringStatus status, RefactoringProcessor owner, String JavaDoc[] natures, SharableParticipants shared) {
136         List JavaDoc result= new ArrayList JavaDoc();
137         for (Iterator JavaDoc iter= fDelete.iterator(); iter.hasNext();) {
138             result.addAll(Arrays.asList(ParticipantManager.loadDeleteParticipants(status,
139                 owner, iter.next(),
140                 new DeleteArguments(), natures, shared)));
141         }
142         result.addAll(Arrays.asList(getResourceModifications().getParticipants(status, owner, natures, shared)));
143         return (RefactoringParticipant[]) result.toArray(new RefactoringParticipant[result.size()]);
144     }
145     
146     /**
147      * This method collects file and folder deletion for notifying
148      * participants. Participants will get notified of
149      *
150      * * deletion of the package (in any case)
151      * * deletion of files within the package if only the files are deleted without
152      * the package folder ("package cleaning")
153      * * deletion of the package folder if it is not only cleared and if its parent
154      * is not removed as well.
155      *
156      * All deleted resources are added to <code>resourcesCollector</code>
157      *
158      * @param resourcesCollector a collector for IResources to be deleted
159      */
160     private void handlePackageFragmentDelete(IPackageFragment pack, ArrayList JavaDoc resourcesCollector) throws CoreException {
161         final IContainer container= (IContainer)pack.getResource();
162         if (container == null)
163             return;
164         
165         final IResource[] members= container.members();
166
167         /*
168          * Check whether this package is removed completely or only cleared.
169          * The default package can never be removed completely.
170          */
171         if (!pack.isDefaultPackage() && canRemoveCompletely(pack)) {
172             // This package is removed completely, which means its folder will be
173 // deleted as well. We only notify participants of the folder deletion
174 // if the parent folder of this folder will not be deleted as well:
175 boolean parentIsMarked= false;
176             final IPackageFragment parent= JavaElementUtil.getParentSubpackage(pack);
177             if (parent == null) {
178                 // "Parent" is the default package which will never be
179 // deleted physically
180 parentIsMarked= false;
181             } else {
182                 // Parent is marked if it is in the list
183 parentIsMarked= fPackagesToDelete.contains(parent);
184             }
185             
186             if (parentIsMarked) {
187                 // Parent is marked, but is it really deleted or only cleared?
188 if (canRemoveCompletely(parent)) {
189                     // Parent can be removed completely, so we do not add
190 // this folder to the list.
191 } else {
192                     // Parent cannot be removed completely, but as this folder
193 // can be removed, we notify the participant
194 resourcesCollector.add(container);
195                     getResourceModifications().addDelete(container);
196                 }
197             } else {
198                 // Parent will not be removed, but we will
199 resourcesCollector.add(container);
200                 getResourceModifications().addDelete(container);
201             }
202         } else {
203             // This package is only cleared because it has subpackages (=subfolders)
204 // which are not deleted. As the package is only cleared, its folder
205 // will not be removed and so we must notify the participant of the deleted children.
206 for (int m= 0; m < members.length; m++) {
207                 IResource member= members[m];
208                 if (member instanceof IFile) {
209                     IFile file= (IFile)member;
210                     if ("class".equals(file.getFileExtension()) && file.isDerived()) //$NON-NLS-1$
211 continue;
212                     if (pack.isDefaultPackage() && ! JavaCore.isJavaLikeFileName(file.getName()))
213                         continue;
214                     resourcesCollector.add(member);
215                     getResourceModifications().addDelete(member);
216                 }
217                 if (!pack.isDefaultPackage() && member instanceof IFolder) {
218                     // Normally, folder children of packages are packages
219 // as well, but in case they have been removed from the build
220 // path, notify the participant
221 IPackageFragment frag= (IPackageFragment) JavaCore.create(member);
222                     if (frag == null) {
223                         resourcesCollector.add(member);
224                         getResourceModifications().addDelete(member);
225                     }
226                 }
227             }
228         }
229     }
230     
231     /**
232      * Returns true if this initially selected package is really deletable
233      * (if it has non-selected sub packages, it may only be cleared).
234      */
235     private boolean canRemoveCompletely(IPackageFragment pack) throws JavaModelException {
236         final IPackageFragment[] subPackages= JavaElementUtil.getPackageAndSubpackages(pack);
237         for (int i= 0; i < subPackages.length; i++) {
238             if (!(subPackages[i].equals(pack)) && !(fPackagesToDelete.contains(subPackages[i])))
239                 return false;
240         }
241         return true;
242     }
243 }
244
Popular Tags