|
1
11 package org.eclipse.jdt.internal.corext.refactoring;
12
13 import java.util.ArrayList  ;
14 import java.util.Collection ;
15 import java.util.HashSet ;
16 import java.util.Iterator ;
17 import java.util.List ;
18 import java.util.Set ;
19
20 import org.eclipse.core.runtime.Assert;
21 import org.eclipse.core.runtime.CoreException;
22 import org.eclipse.core.runtime.IPath;
23
24 import org.eclipse.core.resources.IProject;
25
26 import org.eclipse.jdt.core.IClasspathEntry;
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.IPackageFragmentRoot;
31 import org.eclipse.jdt.core.JavaCore;
32 import org.eclipse.jdt.core.JavaModelException;
33 import org.eclipse.jdt.core.search.IJavaSearchScope;
34 import org.eclipse.jdt.core.search.SearchEngine;
35
36 import org.eclipse.jdt.internal.corext.util.JdtFlags;
37
38 public class RefactoringScopeFactory {
39
40
43 private static void addReferencingProjects(IJavaProject focus, Set projects) throws JavaModelException {
44 IProject[] referencingProjects= focus.getProject().getReferencingProjects();
45 for (int i= 0; i < referencingProjects.length; i++) {
46 IJavaProject candidate= JavaCore.create(referencingProjects[i]);
47 if (candidate == null || projects.contains(candidate) || !candidate.exists())
48 continue; IClasspathEntry entry= getReferencingClassPathEntry(candidate, focus);
50 if (entry != null) {
51 projects.add(candidate);
52 if (entry.isExported())
53 addReferencingProjects(candidate, projects);
54 }
55 }
56 }
57
58 private static void addRelatedReferencing(IJavaProject focus, Set projects) throws CoreException {
59 IProject[] referencingProjects= focus.getProject().getReferencingProjects();
60 for (int i= 0; i < referencingProjects.length; i++) {
61 IJavaProject candidate= JavaCore.create(referencingProjects[i]);
62 if (candidate == null || projects.contains(candidate) || !candidate.exists())
63 continue; IClasspathEntry entry= getReferencingClassPathEntry(candidate, focus);
65 if (entry != null) {
66 projects.add(candidate);
67 if (entry.isExported()) {
68 addRelatedReferencing(candidate, projects);
69 addRelatedReferenced(candidate, projects);
70 }
71 }
72 }
73 }
74
75 private static void addRelatedReferenced(IJavaProject focus, Set projects) throws CoreException {
76 IProject[] referencedProjects= focus.getProject().getReferencedProjects();
77 for (int i= 0; i < referencedProjects.length; i++) {
78 IJavaProject candidate= JavaCore.create(referencedProjects[i]);
79 if (candidate == null || projects.contains(candidate) || !candidate.exists())
80 continue; IClasspathEntry entry= getReferencingClassPathEntry(focus, candidate);
82 if (entry != null) {
83 projects.add(candidate);
84 if (entry.isExported()) {
85 addRelatedReferenced(candidate, projects);
86 addRelatedReferencing(candidate, projects);
87 }
88 }
89 }
90 }
91
92
100 public static IJavaSearchScope create(IJavaElement javaElement) throws JavaModelException {
101 return RefactoringScopeFactory.create(javaElement, true);
102 }
103
104
112 public static IJavaSearchScope create(IJavaElement javaElement, boolean considerVisibility) throws JavaModelException {
113 if (considerVisibility & javaElement instanceof IMember) {
114 IMember member= (IMember) javaElement;
115 if (JdtFlags.isPrivate(member)) {
116 if (member.getCompilationUnit() != null)
117 return SearchEngine.createJavaSearchScope(new IJavaElement[] { member.getCompilationUnit()});
118 else
119 return SearchEngine.createJavaSearchScope(new IJavaElement[] { member});
120 }
121 }
125 return create(javaElement.getJavaProject());
126 }
127
128 private static IJavaSearchScope create(IJavaProject javaProject) throws JavaModelException {
129 return SearchEngine.createJavaSearchScope(getAllScopeElements(javaProject), false);
130 }
131
132
139 public static IJavaSearchScope create(IMember[] members) throws JavaModelException {
140 Assert.isTrue(members != null && members.length > 0);
141 IMember candidate= members[0];
142 int visibility= getVisibility(candidate);
143 for (int i= 1; i < members.length; i++) {
144 int mv= getVisibility(members[i]);
145 if (mv > visibility) {
146 visibility= mv;
147 candidate= members[i];
148 }
149 }
150 return create(candidate);
151 }
152
153
160 public static IJavaSearchScope createReferencedScope(IJavaElement[] javaElements) {
161 Set projects= new HashSet ();
162 for (int i= 0; i < javaElements.length; i++) {
163 projects.add(javaElements[i].getJavaProject());
164 }
165 IJavaProject[] prj= (IJavaProject[]) projects.toArray(new IJavaProject[projects.size()]);
166 return SearchEngine.createJavaSearchScope(prj, true);
167 }
168
169
177 public static IJavaSearchScope createReferencedScope(IJavaElement[] javaElements, int includeMask) {
178 Set projects= new HashSet ();
179 for (int i= 0; i < javaElements.length; i++) {
180 projects.add(javaElements[i].getJavaProject());
181 }
182 IJavaProject[] prj= (IJavaProject[]) projects.toArray(new IJavaProject[projects.size()]);
183 return SearchEngine.createJavaSearchScope(prj, includeMask);
184 }
185
186
194 public static IJavaSearchScope createRelatedProjectsScope(IJavaProject project, int includeMask) throws CoreException {
195 IJavaProject[] projects= getRelatedProjects(project);
196 return SearchEngine.createJavaSearchScope(projects, includeMask);
197 }
198
199 private static IJavaElement[] getAllScopeElements(IJavaProject project) throws JavaModelException {
200 Collection sourceRoots= getAllSourceRootsInProjects(getReferencingProjects(project));
201 return (IPackageFragmentRoot[]) sourceRoots.toArray(new IPackageFragmentRoot[sourceRoots.size()]);
202 }
203
204
207 private static Collection getAllSourceRootsInProjects(Collection projects) throws JavaModelException {
208 List result= new ArrayList ();
209 for (Iterator it= projects.iterator(); it.hasNext();)
210 result.addAll(getSourceRoots((IJavaProject) it.next()));
211 return result;
212 }
213
214
217 private static IClasspathEntry getReferencingClassPathEntry(IJavaProject referencingProject, IJavaProject referencedProject) throws JavaModelException {
218 IClasspathEntry result= null;
219 IPath path= referencedProject.getProject().getFullPath();
220 IClasspathEntry[] classpath= referencingProject.getResolvedClasspath(true);
221 for (int i= 0; i < classpath.length; i++) {
222 IClasspathEntry entry= classpath[i];
223 if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT && path.equals(entry.getPath())) {
224 if (entry.isExported())
225 return entry;
226 result= entry;
229 }
230 }
231 return result;
232 }
233
234 private static IJavaProject[] getRelatedProjects(IJavaProject focus) throws CoreException {
235 final Set projects= new HashSet ();
236
237 addRelatedReferencing(focus, projects);
238 addRelatedReferenced(focus, projects);
239
240 projects.add(focus);
241 return (IJavaProject[]) projects.toArray(new IJavaProject[projects.size()]);
242 }
243
244 private static Collection getReferencingProjects(IJavaProject focus) throws JavaModelException {
245 Set projects= new HashSet ();
246
247 addReferencingProjects(focus, projects);
248 projects.add(focus);
249 return projects;
250 }
251
252 private static List getSourceRoots(IJavaProject javaProject) throws JavaModelException {
253 List elements= new ArrayList ();
254 IPackageFragmentRoot[] roots= javaProject.getPackageFragmentRoots();
255 for (int i= 0; i < roots.length; i++) {
257 IPackageFragmentRoot root= roots[i];
258 if (!root.isArchive())
259 elements.add(root);
260 }
261 return elements;
262 }
263
264 private static int getVisibility(IMember member) throws JavaModelException {
265 if (JdtFlags.isPrivate(member))
266 return 0;
267 if (JdtFlags.isPackageVisible(member))
268 return 1;
269 if (JdtFlags.isProtected(member))
270 return 2;
271 return 4;
272 }
273
274 private RefactoringScopeFactory() {
275 }
277 }
278 |
Popular Tags |
Java API By Example, From Geeks To Geeks.