|
1
11 package org.eclipse.jdt.internal.corext.refactoring.reorg;
12
13 import java.net.URI  ;
14 import java.util.ArrayList ;
15 import java.util.Arrays ;
16 import java.util.Collection ;
17 import java.util.HashMap ;
18 import java.util.HashSet ;
19 import java.util.Iterator ;
20 import java.util.List ;
21 import java.util.Map ;
22 import java.util.Set ;
23
24 import org.eclipse.core.runtime.Assert;
25
26 import org.eclipse.core.resources.IFile;
27 import org.eclipse.core.resources.IFolder;
28 import org.eclipse.core.resources.IProject;
29 import org.eclipse.core.resources.IResource;
30
31 import org.eclipse.ui.IWorkingSet;
32
33 import org.eclipse.jdt.core.IClassFile;
34 import org.eclipse.jdt.core.ICompilationUnit;
35 import org.eclipse.jdt.core.IJavaElement;
36 import org.eclipse.jdt.core.IJavaProject;
37 import org.eclipse.jdt.core.IMember;
38 import org.eclipse.jdt.core.IMethod;
39 import org.eclipse.jdt.core.IPackageFragment;
40 import org.eclipse.jdt.core.IPackageFragmentRoot;
41 import org.eclipse.jdt.core.ISourceRange;
42 import org.eclipse.jdt.core.IType;
43 import org.eclipse.jdt.core.JavaCore;
44 import org.eclipse.jdt.core.JavaModelException;
45 import org.eclipse.jdt.core.Signature;
46
47 import org.eclipse.jdt.internal.corext.SourceRange;
48 import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;
49 import org.eclipse.jdt.internal.corext.refactoring.util.JavaElementUtil;
50 import org.eclipse.jdt.internal.corext.refactoring.util.ResourceUtil;
51 import org.eclipse.jdt.internal.corext.util.Messages;
52
53
54 public class ReorgUtils {
55
56 private static final ISourceRange fgUnknownRange= new SourceRange(-1, 0);
58
59 private ReorgUtils() {
60 }
61
62 public static boolean isArchiveMember(IJavaElement[] elements) {
63 for (int i= 0; i < elements.length; i++) {
64 IJavaElement element= elements[i];
65 IPackageFragmentRoot root= (IPackageFragmentRoot)element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
66 if (root != null && root.isArchive())
67 return true;
68 }
69 return false;
70 }
71
72 public static boolean containsOnlyProjects(List elements){
73 if (elements.isEmpty())
74 return false;
75 for(Iterator iter= elements.iterator(); iter.hasNext(); ) {
76 if (! isProject(iter.next()))
77 return false;
78 }
79 return true;
80 }
81
82 public static boolean isProject(Object element){
83 return (element instanceof IJavaProject) || (element instanceof IProject);
84 }
85
86 public static boolean isInsideCompilationUnit(IJavaElement element) {
87 return !(element instanceof ICompilationUnit) &&
88 hasAncestorOfType(element, IJavaElement.COMPILATION_UNIT);
89 }
90
91 public static boolean isInsideClassFile(IJavaElement element) {
92 return !(element instanceof IClassFile) &&
93 hasAncestorOfType(element, IJavaElement.CLASS_FILE);
94 }
95
96 public static boolean hasAncestorOfType(IJavaElement element, int type){
97 return element.getAncestor(type) != null;
98 }
99
100
103 public static ICompilationUnit getCompilationUnit(IJavaElement javaElement){
104 if (javaElement instanceof ICompilationUnit)
105 return (ICompilationUnit) javaElement;
106 return (ICompilationUnit) javaElement.getAncestor(IJavaElement.COMPILATION_UNIT);
107 }
108
109
112 public static ICompilationUnit[] getCompilationUnits(IJavaElement[] javaElements){
113 ICompilationUnit[] result= new ICompilationUnit[javaElements.length];
114 for (int i= 0; i < javaElements.length; i++) {
115 result[i]= getCompilationUnit(javaElements[i]);
116 }
117 return result;
118 }
119
120 public static IResource getResource(IJavaElement element){
121 if (element instanceof ICompilationUnit)
122 return ((ICompilationUnit)element).getPrimary().getResource();
123 else
124 return element.getResource();
125 }
126
127 public static IResource[] getResources(IJavaElement[] elements) {
128 IResource[] result= new IResource[elements.length];
129 for (int i= 0; i < elements.length; i++) {
130 result[i]= ReorgUtils.getResource(elements[i]);
131 }
132 return result;
133 }
134
135 public static String getName(IResource resource) {
136 String pattern= createNamePattern(resource);
137 String [] args= createNameArguments(resource);
138 return Messages.format(pattern, args);
139 }
140
141 private static String createNamePattern(IResource resource) {
142 switch(resource.getType()){
143 case IResource.FILE:
144 return RefactoringCoreMessages.ReorgUtils_0;
145 case IResource.FOLDER:
146 return RefactoringCoreMessages.ReorgUtils_1;
147 case IResource.PROJECT:
148 return RefactoringCoreMessages.ReorgUtils_2;
149 default:
150 Assert.isTrue(false);
151 return null;
152 }
153 }
154
155 private static String [] createNameArguments(IResource resource) {
156 return new String []{resource.getName()};
157 }
158
159 public static String getName(IJavaElement element) throws JavaModelException {
160 String pattern= createNamePattern(element);
161 String [] args= createNameArguments(element);
162 return Messages.format(pattern, args);
163 }
164
165 private static String [] createNameArguments(IJavaElement element) throws JavaModelException {
166 switch(element.getElementType()){
167 case IJavaElement.CLASS_FILE:
168 return new String []{element.getElementName()};
169 case IJavaElement.COMPILATION_UNIT:
170 return new String []{element.getElementName()};
171 case IJavaElement.FIELD:
172 return new String []{element.getElementName()};
173 case IJavaElement.IMPORT_CONTAINER:
174 return new String [0];
175 case IJavaElement.IMPORT_DECLARATION:
176 return new String []{element.getElementName()};
177 case IJavaElement.INITIALIZER:
178 return new String [0];
179 case IJavaElement.JAVA_PROJECT:
180 return new String []{element.getElementName()};
181 case IJavaElement.METHOD:
182 return new String []{element.getElementName()};
183 case IJavaElement.PACKAGE_DECLARATION:
184 if (JavaElementUtil.isDefaultPackage(element))
185 return new String [0];
186 else
187 return new String []{element.getElementName()};
188 case IJavaElement.PACKAGE_FRAGMENT:
189 return new String []{element.getElementName()};
190 case IJavaElement.PACKAGE_FRAGMENT_ROOT:
191 return new String []{element.getElementName()};
192 case IJavaElement.TYPE:
193 IType type= (IType)element;
194 String name= type.getElementName();
195 if (name.length() == 0 && type.isAnonymous()) {
196 String superclassName= Signature.getSimpleName(type.getSuperclassName());
197 return new String []{Messages.format(RefactoringCoreMessages.ReorgUtils_19, superclassName)};
198 }
199 return new String []{element.getElementName()};
200 default:
201 Assert.isTrue(false);
202 return null;
203 }
204 }
205
206 private static String createNamePattern(IJavaElement element) throws JavaModelException {
207 switch(element.getElementType()){
208 case IJavaElement.CLASS_FILE:
209 return RefactoringCoreMessages.ReorgUtils_3;
210 case IJavaElement.COMPILATION_UNIT:
211 return RefactoringCoreMessages.ReorgUtils_4;
212 case IJavaElement.FIELD:
213 return RefactoringCoreMessages.ReorgUtils_5;
214 case IJavaElement.IMPORT_CONTAINER:
215 return RefactoringCoreMessages.ReorgUtils_6;
216 case IJavaElement.IMPORT_DECLARATION:
217 return RefactoringCoreMessages.ReorgUtils_7;
218 case IJavaElement.INITIALIZER:
219 return RefactoringCoreMessages.ReorgUtils_8;
220 case IJavaElement.JAVA_PROJECT:
221 return RefactoringCoreMessages.ReorgUtils_9;
222 case IJavaElement.METHOD:
223 if (((IMethod)element).isConstructor())
224 return RefactoringCoreMessages.ReorgUtils_10;
225 else
226 return RefactoringCoreMessages.ReorgUtils_11;
227 case IJavaElement.PACKAGE_DECLARATION:
228 return RefactoringCoreMessages.ReorgUtils_12;
229 case IJavaElement.PACKAGE_FRAGMENT:
230 if (JavaElementUtil.isDefaultPackage(element))
231 return RefactoringCoreMessages.ReorgUtils_13;
232 else
233 return RefactoringCoreMessages.ReorgUtils_14;
234 case IJavaElement.PACKAGE_FRAGMENT_ROOT:
235 if (isSourceFolder(element))
236 return RefactoringCoreMessages.ReorgUtils_15;
237 if (isClassFolder(element))
238 return RefactoringCoreMessages.ReorgUtils_16;
239 return RefactoringCoreMessages.ReorgUtils_17;
240 case IJavaElement.TYPE:
241 IType type= (IType)element;
242 if (type.getElementName().length() == 0 && type.isAnonymous())
243 return RefactoringCoreMessages.ReorgUtils_20;
244 return RefactoringCoreMessages.ReorgUtils_18;
245 default:
246 Assert.isTrue(false);
247 return null;
248 }
249 }
250
251 public static IResource[] getResources(List elements) {
252 List resources= new ArrayList (elements.size());
253 for (Iterator iter= elements.iterator(); iter.hasNext();) {
254 Object element= iter.next();
255 if (element instanceof IResource)
256 resources.add(element);
257 }
258 return (IResource[]) resources.toArray(new IResource[resources.size()]);
259 }
260
261 public static IJavaElement[] getJavaElements(List elements) {
262 List resources= new ArrayList (elements.size());
263 for (Iterator iter= elements.iterator(); iter.hasNext();) {
264 Object element= iter.next();
265 if (element instanceof IJavaElement)
266 resources.add(element);
267 }
268 return (IJavaElement[]) resources.toArray(new IJavaElement[resources.size()]);
269 }
270
271 public static IWorkingSet[] getWorkingSets(List elements) {
272 List result= new ArrayList (1);
273 for (Iterator iter= elements.iterator(); iter.hasNext();) {
274 Object element= iter.next();
275 if (element instanceof IWorkingSet) {
276 result.add(element);
277 }
278 }
279 return (IWorkingSet[])result.toArray(new IWorkingSet[result.size()]);
280 }
281
282 public static boolean hasSourceAvailable(IMember member) throws JavaModelException{
283 return ! member.isBinary() ||
284 (member.getSourceRange() != null && ! fgUnknownRange.equals(member.getSourceRange()));
285 }
286
287 public static IResource[] setMinus(IResource[] setToRemoveFrom, IResource[] elementsToRemove) {
288 Set setMinus= new HashSet (setToRemoveFrom.length - setToRemoveFrom.length);
289 setMinus.addAll(Arrays.asList(setToRemoveFrom));
290 setMinus.removeAll(Arrays.asList(elementsToRemove));
291 return (IResource[]) setMinus.toArray(new IResource[setMinus.size()]);
292 }
293
294 public static IJavaElement[] setMinus(IJavaElement[] setToRemoveFrom, IJavaElement[] elementsToRemove) {
295 Set setMinus= new HashSet (setToRemoveFrom.length - setToRemoveFrom.length);
296 setMinus.addAll(Arrays.asList(setToRemoveFrom));
297 setMinus.removeAll(Arrays.asList(elementsToRemove));
298 return (IJavaElement[]) setMinus.toArray(new IJavaElement[setMinus.size()]);
299 }
300
301 public static IJavaElement[] union(IJavaElement[] set1, IJavaElement[] set2) {
302 List union= new ArrayList (set1.length + set2.length); addAll(set1, union);
304 addAll(set2, union);
305 return (IJavaElement[]) union.toArray(new IJavaElement[union.size()]);
306 }
307
308 public static IResource[] union(IResource[] set1, IResource[] set2) {
309 List union= new ArrayList (set1.length + set2.length); addAll(ReorgUtils.getNotNulls(set1), union);
311 addAll(ReorgUtils.getNotNulls(set2), union);
312 return (IResource[]) union.toArray(new IResource[union.size()]);
313 }
314
315 private static void addAll(Object [] array, List list) {
316 for (int i= 0; i < array.length; i++) {
317 if (! list.contains(array[i]))
318 list.add(array[i]);
319 }
320 }
321
322 public static Set union(Set set1, Set set2){
323 Set union= new HashSet (set1.size() + set2.size());
324 union.addAll(set1);
325 union.addAll(set2);
326 return union;
327 }
328
329 public static IType[] getMainTypes(IJavaElement[] javaElements) throws JavaModelException {
330 List result= new ArrayList ();
331 for (int i= 0; i < javaElements.length; i++) {
332 IJavaElement element= javaElements[i];
333 if (element instanceof IType && JavaElementUtil.isMainType((IType)element))
334 result.add(element);
335 }
336 return (IType[]) result.toArray(new IType[result.size()]);
337 }
338
339 public static IFolder[] getFolders(IResource[] resources) {
340 Set result= getResourcesOfType(resources, IResource.FOLDER);
341 return (IFolder[]) result.toArray(new IFolder[result.size()]);
342 }
343
344 public static IFile[] getFiles(IResource[] resources) {
345 Set result= getResourcesOfType(resources, IResource.FILE);
346 return (IFile[]) result.toArray(new IFile[result.size()]);
347 }
348
349 public static Set getResourcesOfType(IResource[] resources, int typeMask){
351 Set result= new HashSet (resources.length);
352 for (int i= 0; i < resources.length; i++) {
353 if (isOfType(resources[i], typeMask))
354 result.add(resources[i]);
355 }
356 return result;
357 }
358
359 public static List getElementsOfType(IJavaElement[] javaElements, int type){
362 List result= new ArrayList (javaElements.length);
363 for (int i= 0; i < javaElements.length; i++) {
364 if (isOfType(javaElements[i], type))
365 result.add(javaElements[i]);
366 }
367 return result;
368 }
369
370 public static boolean hasElementsNotOfType(IResource[] resources, int typeMask) {
371 for (int i= 0; i < resources.length; i++) {
372 IResource resource= resources[i];
373 if (resource != null && ! isOfType(resource, typeMask))
374 return true;
375 }
376 return false;
377 }
378
379 public static boolean hasElementsNotOfType(IJavaElement[] javaElements, int type) {
381 for (int i= 0; i < javaElements.length; i++) {
382 IJavaElement element= javaElements[i];
383 if (element != null && ! isOfType(element, type))
384 return true;
385 }
386 return false;
387 }
388
389 public static boolean hasElementsOfType(IJavaElement[] javaElements, int type) {
391 for (int i= 0; i < javaElements.length; i++) {
392 IJavaElement element= javaElements[i];
393 if (element != null && isOfType(element, type))
394 return true;
395 }
396 return false;
397 }
398
399 public static boolean hasElementsOfType(IJavaElement[] javaElements, int[] types) {
400 for (int i= 0; i < types.length; i++) {
401 if (hasElementsOfType(javaElements, types[i])) return true;
402 }
403 return false;
404 }
405
406 public static boolean hasElementsOfType(IResource[] resources, int typeMask) {
407 for (int i= 0; i < resources.length; i++) {
408 IResource resource= resources[i];
409 if (resource != null && isOfType(resource, typeMask))
410 return true;
411 }
412 return false;
413 }
414
415 private static boolean isOfType(IJavaElement element, int type) {
416 return element.getElementType() == type; }
418
419 private static boolean isOfType(IResource resource, int type) {
420 return resource != null && isFlagSet(resource.getType(), type);
421 }
422
423 private static boolean isFlagSet(int flags, int flag){
424 return (flags & flag) != 0;
425 }
426
427 public static boolean isSourceFolder(IJavaElement javaElement) throws JavaModelException {
428 return (javaElement instanceof IPackageFragmentRoot) &&
429 ((IPackageFragmentRoot)javaElement).getKind() == IPackageFragmentRoot.K_SOURCE;
430 }
431
432 public static boolean isClassFolder(IJavaElement javaElement) throws JavaModelException {
433 return (javaElement instanceof IPackageFragmentRoot) &&
434 ((IPackageFragmentRoot)javaElement).getKind() == IPackageFragmentRoot.K_BINARY;
435 }
436
437 public static boolean isPackageFragmentRoot(IJavaProject javaProject) throws JavaModelException{
438 return getCorrespondingPackageFragmentRoot(javaProject) != null;
439 }
440
441 private static boolean isPackageFragmentRootCorrespondingToProject(IPackageFragmentRoot root) {
442 return root.getResource() instanceof IProject;
443 }
444
445 public static IPackageFragmentRoot getCorrespondingPackageFragmentRoot(IJavaProject p) throws JavaModelException {
446 IPackageFragmentRoot[] roots= p.getPackageFragmentRoots();
447 for (int i= 0; i < roots.length; i++) {
448 if (isPackageFragmentRootCorrespondingToProject(roots[i]))
449 return roots[i];
450 }
451 return null;
452 }
453
454 public static boolean containsLinkedResources(IResource[] resources){
455 for (int i= 0; i < resources.length; i++) {
456 if (resources[i] != null && resources[i].isLinked()) return true;
457 }
458 return false;
459 }
460
461 public static boolean containsLinkedResources(IJavaElement[] javaElements){
462 for (int i= 0; i < javaElements.length; i++) {
463 IResource res= getResource(javaElements[i]);
464 if (res != null && res.isLinked()) return true;
465 }
466 return false;
467 }
468
469 public static boolean canBeDestinationForLinkedResources(IResource resource) {
470 return resource.isAccessible() && resource instanceof IProject;
471 }
472
473 public static boolean canBeDestinationForLinkedResources(IJavaElement javaElement) {
474 if (javaElement instanceof IPackageFragmentRoot){
475 return isPackageFragmentRootCorrespondingToProject((IPackageFragmentRoot)javaElement);
476 } else if (javaElement instanceof IJavaProject){
477 return true; } else return false;
479 }
480
481 public static boolean isParentInWorkspaceOrOnDisk(IPackageFragment pack, IPackageFragmentRoot root){
482 if (pack == null)
483 return false;
484 IJavaElement packParent= pack.getParent();
485 if (packParent == null)
486 return false;
487 if (packParent.equals(root))
488 return true;
489 IResource packageResource= ResourceUtil.getResource(pack);
490 IResource packageRootResource= ResourceUtil.getResource(root);
491 return isParentInWorkspaceOrOnDisk(packageResource, packageRootResource);
492 }
493
494 public static boolean isParentInWorkspaceOrOnDisk(IPackageFragmentRoot root, IJavaProject javaProject){
495 if (root == null)
496 return false;
497 IJavaElement rootParent= root.getParent();
498 if (rootParent == null)
499 return false;
500 if (rootParent.equals(root))
501 return true;
502 IResource packageResource= ResourceUtil.getResource(root);
503 IResource packageRootResource= ResourceUtil.getResource(javaProject);
504 return isParentInWorkspaceOrOnDisk(packageResource, packageRootResource);
505 }
506
507 public static boolean isParentInWorkspaceOrOnDisk(ICompilationUnit cu, IPackageFragment dest){
508 if (cu == null)
509 return false;
510 IJavaElement cuParent= cu.getParent();
511 if (cuParent == null)
512 return false;
513 if (cuParent.equals(dest))
514 return true;
515 IResource cuResource= cu.getResource();
516 IResource packageResource= ResourceUtil.getResource(dest);
517 return isParentInWorkspaceOrOnDisk(cuResource, packageResource);
518 }
519
520 public static boolean isParentInWorkspaceOrOnDisk(IResource res, IResource maybeParent){
521 if (res == null)
522 return false;
523 return areEqualInWorkspaceOrOnDisk(res.getParent(), maybeParent);
524 }
525
526 public static boolean areEqualInWorkspaceOrOnDisk(IResource r1, IResource r2){
527 if (r1 == null || r2 == null)
528 return false;
529 if (r1.equals(r2))
530 return true;
531 URI r1Location= r1.getLocationURI();
532 URI r2Location= r2.getLocationURI();
533 if (r1Location == null || r2Location == null)
534 return false;
535 return r1Location.equals(r2Location);
536 }
537
538 public static IResource[] getNotNulls(IResource[] resources) {
539 Collection result= new ArrayList (resources.length);
540 for (int i= 0; i < resources.length; i++) {
541 IResource resource= resources[i];
542 if (resource != null && ! result.contains(resource))
543 result.add(resource);
544 }
545 return (IResource[]) result.toArray(new IResource[result.size()]);
546 }
547
548 public static IResource[] getNotLinked(IResource[] resources) {
549 Collection result= new ArrayList (resources.length);
550 for (int i= 0; i < resources.length; i++) {
551 IResource resource= resources[i];
552 if (resource != null && ! result.contains(resource) && ! resource.isLinked())
553 result.add(resource);
554 }
555 return (IResource[]) result.toArray(new IResource[result.size()]);
556 }
557
558
561 public static Map groupByCompilationUnit(List javaElements){
562 Map result= new HashMap ();
563 for (Iterator iter= javaElements.iterator(); iter.hasNext();) {
564 IJavaElement element= (IJavaElement) iter.next();
565 ICompilationUnit cu= ReorgUtils.getCompilationUnit(element);
566 if (cu != null){
567 if (! result.containsKey(cu))
568 result.put(cu, new ArrayList (1));
569 ((List )result.get(cu)).add(element);
570 }
571 }
572 return result;
573 }
574
575 public static void splitIntoJavaElementsAndResources(Object [] elements, List javaElementResult, List resourceResult) {
576 for (int i= 0; i < elements.length; i++) {
577 Object element= elements[i];
578 if (element instanceof IJavaElement) {
579 javaElementResult.add(element);
580 } else if (element instanceof IResource) {
581 IResource resource= (IResource)element;
582 IJavaElement jElement= JavaCore.create(resource);
583 if (jElement != null && jElement.exists())
584 javaElementResult.add(jElement);
585 else
586 resourceResult.add(resource);
587 }
588 }
589 }
590
591 public static boolean containsElementOrParent(Set elements, IJavaElement element) {
592 IJavaElement curr= element;
593 do {
594 if (elements.contains(curr))
595 return true;
596 curr= curr.getParent();
597 } while (curr != null);
598 return false;
599 }
600
601 public static boolean containsElementOrParent(Set elements, IResource element) {
602 IResource curr= element;
603 do {
604 if (elements.contains(curr))
605 return true;
606 IJavaElement jElement= JavaCore.create(curr);
607 if (jElement != null && jElement.exists()) {
608 return containsElementOrParent(elements, jElement);
609 }
610 curr= curr.getParent();
611 } while (curr != null);
612 return false;
613 }
614 }
615 |
Popular Tags |
Java API By Example, From Geeks To Geeks.