]>
Commit | Line | Data |
---|---|---|
1b2798f6 EK |
1 | /******************************************************************************* |
2 | * Copyright (c) 2000, 2011 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.util; | |
12 | ||
13 | import java.util.ArrayList; | |
14 | import java.util.Arrays; | |
15 | import java.util.Comparator; | |
16 | import java.util.HashSet; | |
17 | import java.util.List; | |
18 | import java.util.Set; | |
19 | ||
20 | import org.eclipse.core.runtime.Assert; | |
21 | ||
22 | import org.eclipse.core.resources.ResourcesPlugin; | |
23 | ||
24 | import org.eclipse.jdt.core.IClasspathEntry; | |
25 | import org.eclipse.jdt.core.ICompilationUnit; | |
26 | import org.eclipse.jdt.core.IField; | |
27 | import org.eclipse.jdt.core.IJavaElement; | |
28 | import org.eclipse.jdt.core.IJavaProject; | |
29 | import org.eclipse.jdt.core.IMember; | |
30 | import org.eclipse.jdt.core.IMethod; | |
31 | import org.eclipse.jdt.core.IPackageFragment; | |
32 | import org.eclipse.jdt.core.IPackageFragmentRoot; | |
33 | import org.eclipse.jdt.core.ISourceReference; | |
34 | import org.eclipse.jdt.core.IType; | |
35 | import org.eclipse.jdt.core.JavaCore; | |
36 | import org.eclipse.jdt.core.JavaModelException; | |
37 | import org.eclipse.jdt.core.Signature; | |
38 | import org.eclipse.jdt.core.SourceRange; | |
39 | ||
40 | import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages; | |
41 | import org.eclipse.jdt.internal.corext.util.JavaModelUtil; | |
42 | ||
43 | import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels; | |
44 | ||
45 | ||
46 | public class JavaElementUtil { | |
47 | ||
48 | //no instances | |
49 | private JavaElementUtil(){ | |
50 | } | |
51 | ||
52 | public static String createMethodSignature(IMethod method){ | |
53 | try { | |
54 | return BasicElementLabels.getJavaElementName(Signature.toString(method.getSignature(), method.getElementName(), method.getParameterNames(), false, ! method.isConstructor())); | |
55 | } catch(JavaModelException e) { | |
56 | return BasicElementLabels.getJavaElementName(method.getElementName()); //fallback | |
57 | } | |
58 | } | |
59 | ||
60 | public static String createFieldSignature(IField field){ | |
61 | return BasicElementLabels.getJavaElementName(field.getDeclaringType().getFullyQualifiedName('.') + "." + field.getElementName()); //$NON-NLS-1$ | |
62 | } | |
63 | ||
64 | public static String createSignature(IMember member){ | |
65 | switch (member.getElementType()){ | |
66 | case IJavaElement.FIELD: | |
67 | return createFieldSignature((IField)member); | |
68 | case IJavaElement.TYPE: | |
69 | return BasicElementLabels.getJavaElementName(((IType)member).getFullyQualifiedName('.')); | |
70 | case IJavaElement.INITIALIZER: | |
71 | return RefactoringCoreMessages.JavaElementUtil_initializer; | |
72 | case IJavaElement.METHOD: | |
73 | return createMethodSignature((IMethod)member); | |
74 | default: | |
75 | Assert.isTrue(false); | |
76 | return null; | |
77 | } | |
78 | } | |
79 | ||
80 | public static IJavaElement[] getElementsOfType(IJavaElement[] elements, int type){ | |
81 | Set<IJavaElement> result= new HashSet<IJavaElement>(elements.length); | |
82 | for (int i= 0; i < elements.length; i++) { | |
83 | IJavaElement element= elements[i]; | |
84 | if (element.getElementType() == type) | |
85 | result.add(element); | |
86 | } | |
87 | return result.toArray(new IJavaElement[result.size()]); | |
88 | } | |
89 | ||
90 | public static IType getMainType(ICompilationUnit cu) throws JavaModelException{ | |
91 | IType[] types= cu.getTypes(); | |
92 | for (int i = 0; i < types.length; i++) { | |
93 | if (isMainType(types[i])) | |
94 | return types[i]; | |
95 | } | |
96 | return null; | |
97 | } | |
98 | ||
99 | public static boolean isMainType(IType type) throws JavaModelException{ | |
100 | if (! type.exists()) | |
101 | return false; | |
102 | ||
103 | if (type.isBinary()) | |
104 | return false; | |
105 | ||
106 | if (type.getCompilationUnit() == null) | |
107 | return false; | |
108 | ||
109 | if (type.getDeclaringType() != null) | |
110 | return false; | |
111 | ||
112 | return isPrimaryType(type) || isCuOnlyType(type); | |
113 | } | |
114 | ||
115 | ||
116 | private static boolean isPrimaryType(IType type){ | |
117 | return type.equals(type.getCompilationUnit().findPrimaryType()); | |
118 | } | |
119 | ||
120 | ||
121 | private static boolean isCuOnlyType(IType type) throws JavaModelException{ | |
122 | return type.getCompilationUnit().getTypes().length == 1; | |
123 | } | |
124 | ||
125 | /* @see org.eclipse.jdt.internal.core.JavaElement#isAncestorOf(org.eclipse.jdt.core.IJavaElement) */ | |
126 | public static boolean isAncestorOf(IJavaElement ancestor, IJavaElement child) { | |
127 | IJavaElement parent= child.getParent(); | |
128 | while (parent != null && !parent.equals(ancestor)) { | |
129 | parent= parent.getParent(); | |
130 | } | |
131 | return parent != null; | |
132 | } | |
133 | ||
134 | public static IMethod[] getAllConstructors(IType type) throws JavaModelException { | |
135 | if (JavaModelUtil.isInterfaceOrAnnotation(type)) | |
136 | return new IMethod[0]; | |
137 | List<IMethod> result= new ArrayList<IMethod>(); | |
138 | IMethod[] methods= type.getMethods(); | |
139 | for (int i= 0; i < methods.length; i++) { | |
140 | IMethod iMethod= methods[i]; | |
141 | if (iMethod.isConstructor()) | |
142 | result.add(iMethod); | |
143 | } | |
144 | return result.toArray(new IMethod[result.size()]); | |
145 | } | |
146 | ||
147 | /** | |
148 | * @param root the package fragment root | |
149 | * @return array of projects that have the specified root on their classpath | |
150 | * @throws JavaModelException if getting the raw classpath or all Java projects fails | |
151 | */ | |
152 | public static IJavaProject[] getReferencingProjects(IPackageFragmentRoot root) throws JavaModelException { | |
153 | IClasspathEntry cpe= root.getRawClasspathEntry(); | |
154 | if (cpe.getEntryKind() == IClasspathEntry.CPE_LIBRARY) | |
155 | cpe= root.getResolvedClasspathEntry(); | |
156 | IJavaProject[] allJavaProjects= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()).getJavaProjects(); | |
157 | List<IJavaProject> result= new ArrayList<IJavaProject>(allJavaProjects.length); | |
158 | for (int i= 0; i < allJavaProjects.length; i++) { | |
159 | IJavaProject project= allJavaProjects[i]; | |
160 | IPackageFragmentRoot[] roots= project.findPackageFragmentRoots(cpe); | |
161 | if (roots.length > 0) | |
162 | result.add(project); | |
163 | } | |
164 | return result.toArray(new IJavaProject[result.size()]); | |
165 | } | |
166 | ||
167 | public static IMember[] merge(IMember[] a1, IMember[] a2) { | |
168 | // Don't use hash sets since ordering is important for some refactorings. | |
169 | List<IMember> result= new ArrayList<IMember>(a1.length + a2.length); | |
170 | for (int i= 0; i < a1.length; i++) { | |
171 | IMember member= a1[i]; | |
172 | if (!result.contains(member)) | |
173 | result.add(member); | |
174 | } | |
175 | for (int i= 0; i < a2.length; i++) { | |
176 | IMember member= a2[i]; | |
177 | if (!result.contains(member)) | |
178 | result.add(member); | |
179 | } | |
180 | return result.toArray(new IMember[result.size()]); | |
181 | } | |
182 | ||
183 | public static boolean isDefaultPackage(Object element) { | |
184 | return (element instanceof IPackageFragment) && ((IPackageFragment)element).isDefaultPackage(); | |
185 | } | |
186 | ||
187 | /** | |
188 | * @param pack a package fragment | |
189 | * @return an array containing the given package and all subpackages | |
190 | * @throws JavaModelException if getting the all sibling packages fails | |
191 | */ | |
192 | public static IPackageFragment[] getPackageAndSubpackages(IPackageFragment pack) throws JavaModelException { | |
193 | if (pack.isDefaultPackage()) | |
194 | return new IPackageFragment[] { pack }; | |
195 | ||
196 | IPackageFragmentRoot root= (IPackageFragmentRoot) pack.getParent(); | |
197 | IJavaElement[] allPackages= root.getChildren(); | |
198 | ArrayList<IPackageFragment> subpackages= new ArrayList<IPackageFragment>(); | |
199 | subpackages.add(pack); | |
200 | String prefix= pack.getElementName() + '.'; | |
201 | for (int i= 0; i < allPackages.length; i++) { | |
202 | IPackageFragment currentPackage= (IPackageFragment) allPackages[i]; | |
203 | if (currentPackage.getElementName().startsWith(prefix)) | |
204 | subpackages.add(currentPackage); | |
205 | } | |
206 | return subpackages.toArray(new IPackageFragment[subpackages.size()]); | |
207 | } | |
208 | ||
209 | /** | |
210 | * @param pack the package fragment; may not be null | |
211 | * @return the parent package fragment, or null if the given package fragment is the default package or a top level package | |
212 | */ | |
213 | public static IPackageFragment getParentSubpackage(IPackageFragment pack) { | |
214 | if (pack.isDefaultPackage()) | |
215 | return null; | |
216 | ||
217 | final int index= pack.getElementName().lastIndexOf('.'); | |
218 | if (index == -1) | |
219 | return null; | |
220 | ||
221 | final IPackageFragmentRoot root= (IPackageFragmentRoot) pack.getParent(); | |
222 | final String newPackageName= pack.getElementName().substring(0, index); | |
223 | final IPackageFragment parent= root.getPackageFragment(newPackageName); | |
224 | if (parent.exists()) | |
225 | return parent; | |
226 | else | |
227 | return null; | |
228 | } | |
229 | ||
230 | public static IMember[] sortByOffset(IMember[] members){ | |
231 | Comparator<IMember> comparator= new Comparator<IMember>(){ | |
232 | public int compare(IMember o1, IMember o2){ | |
233 | try{ | |
234 | return o1.getNameRange().getOffset() - o2.getNameRange().getOffset(); | |
235 | } catch (JavaModelException e){ | |
236 | return 0; | |
237 | } | |
238 | } | |
239 | }; | |
240 | Arrays.sort(members, comparator); | |
241 | return members; | |
242 | } | |
243 | ||
244 | public static boolean isSourceAvailable(ISourceReference sourceReference) { | |
245 | try { | |
246 | return SourceRange.isAvailable(sourceReference.getSourceRange()); | |
247 | } catch (JavaModelException e) { | |
248 | return false; | |
249 | } | |
250 | } | |
251 | } |