|
1
11 package org.eclipse.jdt.internal.corext.refactoring.reorg;
12
13 import java.util.ArrayList  ;
14 import java.util.List ;
15
16 import org.eclipse.core.runtime.Assert;
17 import org.eclipse.core.runtime.CoreException;
18
19 import org.eclipse.core.resources.IContainer;
20 import org.eclipse.core.resources.IFile;
21 import org.eclipse.core.resources.IFolder;
22 import org.eclipse.core.resources.IResource;
23
24 import org.eclipse.jdt.core.ICompilationUnit;
25 import org.eclipse.jdt.core.IJavaElement;
26 import org.eclipse.jdt.core.IJavaProject;
27 import org.eclipse.jdt.core.IPackageFragment;
28 import org.eclipse.jdt.core.IPackageFragmentRoot;
29
30 import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;
31 import org.eclipse.jdt.internal.corext.refactoring.util.ResourceUtil;
32 import org.eclipse.jdt.internal.corext.util.Messages;
33
34 class OverwriteHelper {
35 private Object fDestination;
36 private IFile[] fFiles= new IFile[0];
37 private IFolder[] fFolders= new IFolder[0];
38 private ICompilationUnit[] fCus= new ICompilationUnit[0];
39 private IPackageFragmentRoot[] fRoots= new IPackageFragmentRoot[0];
40 private IPackageFragment[] fPackageFragments= new IPackageFragment[0];
41
42 public void setFiles(IFile[] files) {
43 Assert.isNotNull(files);
44 fFiles= files;
45 }
46
47 public void setFolders(IFolder[] folders) {
48 Assert.isNotNull(folders);
49 fFolders= folders;
50 }
51
52 public void setCus(ICompilationUnit[] cus) {
53 Assert.isNotNull(cus);
54 fCus= cus;
55 }
56
57 public void setPackageFragmentRoots(IPackageFragmentRoot[] roots) {
58 Assert.isNotNull(roots);
59 fRoots= roots;
60 }
61
62 public void setPackages(IPackageFragment[] fragments) {
63 Assert.isNotNull(fragments);
64 fPackageFragments= fragments;
65 }
66
67 public IFile[] getFilesWithoutUnconfirmedOnes() {
68 return fFiles;
69 }
70
71 public IFolder[] getFoldersWithoutUnconfirmedOnes() {
72 return fFolders;
73 }
74
75 public ICompilationUnit[] getCusWithoutUnconfirmedOnes() {
76 return fCus;
77 }
78
79 public IPackageFragmentRoot[] getPackageFragmentRootsWithoutUnconfirmedOnes() {
80 return fRoots;
81 }
82
83 public IPackageFragment[] getPackagesWithoutUnconfirmedOnes() {
84 return fPackageFragments;
85 }
86
87 public void confirmOverwriting(IReorgQueries reorgQueries, IJavaElement destination) {
88 Assert.isNotNull(destination);
89 fDestination= destination;
90 confirmOverwritting(reorgQueries);
91 }
92
93 public void confirmOverwriting(IReorgQueries reorgQueries, IResource destination) {
94 Assert.isNotNull(destination);
95 Assert.isNotNull(reorgQueries);
96 fDestination= destination;
97 confirmOverwritting(reorgQueries);
98 }
99
100 private void confirmOverwritting(IReorgQueries reorgQueries) {
101 IConfirmQuery overwriteQuery= reorgQueries.createYesYesToAllNoNoToAllQuery(RefactoringCoreMessages.OverwriteHelper_0, true, IReorgQueries.CONFIRM_OVERWRITING);
102 IConfirmQuery skipQuery= reorgQueries.createSkipQuery(RefactoringCoreMessages.OverwriteHelper_2, IReorgQueries.CONFIRM_SKIPPING);
103 confirmFileOverwritting(overwriteQuery);
104 confirmFolderOverwritting(skipQuery);
105 confirmCuOverwritting(overwriteQuery);
106 confirmPackageFragmentRootOverwritting(skipQuery);
107 confirmPackageOverwritting(overwriteQuery);
108 }
109
110 private void confirmPackageFragmentRootOverwritting(IConfirmQuery overwriteQuery) {
111 List toNotOverwrite= new ArrayList (1);
112 for (int i= 0; i < fRoots.length; i++) {
113 IPackageFragmentRoot root= fRoots[i];
114 if (canOverwrite(root) && ! skip(root.getElementName(), overwriteQuery))
115 toNotOverwrite.add(root);
116 }
117 IPackageFragmentRoot[] roots= (IPackageFragmentRoot[]) toNotOverwrite.toArray(new IPackageFragmentRoot[toNotOverwrite.size()]);
118 fRoots= ArrayTypeConverter.toPackageFragmentRootArray(ReorgUtils.setMinus(fRoots, roots));
119 }
120
121 private void confirmCuOverwritting(IConfirmQuery overwriteQuery) {
122 List cusToNotOverwrite= new ArrayList (1);
123 for (int i= 0; i < fCus.length; i++) {
124 ICompilationUnit cu= fCus[i];
125 if (canOverwrite(cu) && ! overwrite(cu, overwriteQuery))
126 cusToNotOverwrite.add(cu);
127 }
128 ICompilationUnit[] cus= (ICompilationUnit[]) cusToNotOverwrite.toArray(new ICompilationUnit[cusToNotOverwrite.size()]);
129 fCus= ArrayTypeConverter.toCuArray(ReorgUtils.setMinus(fCus, cus));
130 }
131
132 private void confirmFolderOverwritting(IConfirmQuery overwriteQuery) {
133 List foldersToNotOverwrite= new ArrayList (1);
134 for (int i= 0; i < fFolders.length; i++) {
135 IFolder folder= fFolders[i];
136 if (canOverwrite(folder) && ! skip(folder.getName(), overwriteQuery))
137 foldersToNotOverwrite.add(folder);
138 }
139 IFolder[] folders= (IFolder[]) foldersToNotOverwrite.toArray(new IFolder[foldersToNotOverwrite.size()]);
140 fFolders= ArrayTypeConverter.toFolderArray(ReorgUtils.setMinus(fFolders, folders));
141 }
142
143 private void confirmFileOverwritting(IConfirmQuery overwriteQuery) {
144 List filesToNotOverwrite= new ArrayList (1);
145 for (int i= 0; i < fFiles.length; i++) {
146 IFile file= fFiles[i];
147 if (canOverwrite(file) && ! overwrite(file, overwriteQuery))
148 filesToNotOverwrite.add(file);
149 }
150 IFile[] files= (IFile[]) filesToNotOverwrite.toArray(new IFile[filesToNotOverwrite.size()]);
151 fFiles= ArrayTypeConverter.toFileArray(ReorgUtils.setMinus(fFiles, files));
152 }
153
154 private void confirmPackageOverwritting(IConfirmQuery overwriteQuery){
155 List toNotOverwrite= new ArrayList (1);
156 for (int i= 0; i < fPackageFragments.length; i++) {
157 IPackageFragment pack= fPackageFragments[i];
158 if (canOverwrite(pack) && ! overwrite(pack, overwriteQuery))
159 toNotOverwrite.add(pack);
160 }
161 IPackageFragment[] packages= (IPackageFragment[]) toNotOverwrite.toArray(new IPackageFragment[toNotOverwrite.size()]);
162 fPackageFragments= ArrayTypeConverter.toPackageArray(ReorgUtils.setMinus(fPackageFragments, packages));
163 }
164
165 private boolean canOverwrite(IPackageFragment pack) {
166 Assert.isTrue(fDestination instanceof IPackageFragmentRoot);
167 IPackageFragmentRoot destination= (IPackageFragmentRoot)fDestination;
168 return ! destination.equals(pack.getParent()) && destination.getPackageFragment(pack.getElementName()).exists();
169 }
170
171 private boolean canOverwrite(IResource resource) {
172 if (resource == null)
173 return false;
174 IResource destinationResource= ResourceUtil.getResource(fDestination);
175 if (destinationResource.equals(resource.getParent()))
176 return false;
177 if (destinationResource instanceof IContainer) {
178 IContainer container= (IContainer)destinationResource;
179 IResource member= container.findMember(resource.getName());
180 if (member == null || !member.exists())
181 return false;
182 if (member instanceof IContainer) {
183 try {
184 if (((IContainer)member).members().length == 0)
185 return false;
186 } catch (CoreException e) {
187 return true;
188 }
189 }
190 return true;
191 }
192 return false;
193 }
194
195 private boolean canOverwrite(IPackageFragmentRoot root) {
196 Assert.isTrue(fDestination instanceof IJavaProject);
197 IJavaProject destination= (IJavaProject)fDestination;
198 IFolder conflict= destination.getProject().getFolder(root.getElementName());
199 try {
200 return !destination.equals(root.getParent()) && conflict.exists() && conflict.members().length > 0;
201 } catch (CoreException e) {
202 return true;
203 }
204 }
205
206 private boolean canOverwrite(ICompilationUnit cu) {
207 if (fDestination instanceof IPackageFragment){
208 IPackageFragment destination= (IPackageFragment)fDestination;
209 return ! destination.equals(cu.getParent()) && destination.getCompilationUnit(cu.getElementName()).exists();
210 } else {
211 return canOverwrite(ReorgUtils.getResource(cu));
212 }
213 }
214
215 private static boolean overwrite(IResource resource, IConfirmQuery overwriteQuery){
216 return overwrite(resource.getName(), overwriteQuery);
217 }
218
219 private static boolean overwrite(IJavaElement element, IConfirmQuery overwriteQuery){
220 return overwrite(element.getElementName(), overwriteQuery);
221 }
222
223 private static boolean overwrite(String name, IConfirmQuery overwriteQuery){
224 String question= Messages.format(RefactoringCoreMessages.OverwriteHelper_1, name);
225 return overwriteQuery.confirm(question);
226 }
227 private static boolean skip(String name, IConfirmQuery overwriteQuery){
228 String question= Messages.format(RefactoringCoreMessages.OverwriteHelper_3, name);
229 return overwriteQuery.confirm(question);
230 }
231 }
232 |
Popular Tags |
Java API By Example, From Geeks To Geeks.