KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > mountainminds > eclemma > internal > core > analysis > TypeTraverser


1 /*******************************************************************************
2  * Copyright (c) 2006 Mountainminds GmbH & Co. KG
3  * This software is provided under the terms of the Eclipse Public License v1.0
4  * See http://www.eclipse.org/legal/epl-v10.html.
5  *
6  * $Id$
7  ******************************************************************************/

8 package com.mountainminds.eclemma.internal.core.analysis;
9
10 import org.eclipse.core.runtime.IProgressMonitor;
11 import org.eclipse.core.runtime.SubProgressMonitor;
12 import org.eclipse.jdt.core.IClassFile;
13 import org.eclipse.jdt.core.ICompilationUnit;
14 import org.eclipse.jdt.core.IJavaElement;
15 import org.eclipse.jdt.core.IMember;
16 import org.eclipse.jdt.core.IPackageFragment;
17 import org.eclipse.jdt.core.IPackageFragmentRoot;
18 import org.eclipse.jdt.core.IType;
19 import org.eclipse.jdt.core.JavaModelException;
20
21 /**
22  * Internal utility class for traversal of all types within a list of package
23  * fragment roots.
24  *
25  * @author Marc R. Hoffmann
26  * @version $Revision$
27  */

28 public class TypeTraverser {
29
30   private final IPackageFragmentRoot[] roots;
31
32   /**
33    * Creates a traverser for the given list of package fragment roots.
34    *
35    * @param roots
36    * list of package fragment roots for traversal
37    */

38   public TypeTraverser(IPackageFragmentRoot[] roots) {
39     this.roots = roots;
40   }
41
42   /**
43    * Processes all types and methods reporting all types found to the given
44    * {@link ITypeVisitor} instance.
45    *
46    * @param visitor
47    * type visitor
48    * @param monitor
49    * progress monitor to report progress and allow cancelation
50    * @throws JavaModelException
51    * thrown by the underlying Java model
52    */

53   public void process(ITypeVisitor visitor, IProgressMonitor monitor)
54       throws JavaModelException {
55     monitor.beginTask("", roots.length); //$NON-NLS-1$
56
for (int i = 0; i < roots.length && !monitor.isCanceled(); i++) {
57       processPackageFragmentRoot(visitor, roots[i], new SubProgressMonitor(
58           monitor, 1));
59     }
60     visitor.done();
61     monitor.done();
62   }
63
64   private void processPackageFragmentRoot(ITypeVisitor visitor,
65       IPackageFragmentRoot root, IProgressMonitor monitor)
66       throws JavaModelException {
67     IJavaElement[] fragments = root.getChildren();
68     monitor.beginTask("", fragments.length); //$NON-NLS-1$
69
for (int i = 0; i < fragments.length && !monitor.isCanceled(); i++) {
70       IPackageFragment fragment = (IPackageFragment) fragments[i];
71       IProgressMonitor submonitor = new SubProgressMonitor(monitor, 1);
72       processPackageFragment(visitor, fragment, submonitor);
73     }
74     monitor.done();
75   }
76
77   private void processPackageFragment(ITypeVisitor visitor,
78       IPackageFragment fragment, IProgressMonitor monitor)
79       throws JavaModelException {
80     switch (fragment.getKind()) {
81     case IPackageFragmentRoot.K_SOURCE:
82       ICompilationUnit[] units = fragment.getCompilationUnits();
83       monitor.beginTask("", units.length); //$NON-NLS-1$
84
for (int i = 0; i < units.length && !monitor.isCanceled(); i++) {
85         processCompilationUnit(visitor, units[i], monitor);
86         monitor.worked(1);
87       }
88       break;
89     case IPackageFragmentRoot.K_BINARY:
90       IClassFile[] classfiles = fragment.getClassFiles();
91       monitor.beginTask("", classfiles.length); //$NON-NLS-1$
92
for (int i = 0; i < classfiles.length && !monitor.isCanceled(); i++) {
93         processClassFile(visitor, classfiles[i], monitor);
94         monitor.worked(1);
95       }
96       break;
97     }
98     monitor.done();
99   }
100
101   private void processCompilationUnit(ITypeVisitor visitor,
102       ICompilationUnit unit, IProgressMonitor monitor)
103       throws JavaModelException {
104     IType[] types = unit.getTypes();
105     for (int i = 0; i < types.length && !monitor.isCanceled(); i++) {
106       IType type = types[i];
107       processType(visitor, new BinaryTypeName(type), type, monitor);
108     }
109   }
110
111   private void processClassFile(ITypeVisitor visitor, IClassFile file,
112       IProgressMonitor monitor) throws JavaModelException {
113     IType type = file.getType();
114     processType(visitor, new BinaryTypeName(type), type, monitor);
115   }
116
117   private void processType(ITypeVisitor visitor, BinaryTypeName btn,
118       IType type, IProgressMonitor monitor) throws JavaModelException {
119     String JavaDoc binaryname = btn.toString();
120     monitor.subTask(binaryname);
121     visitor.visit(type, binaryname);
122     IJavaElement[] children = type.getChildren();
123     for (int i = 0; i < children.length && !monitor.isCanceled(); i++) {
124       IJavaElement child = children[i];
125       switch (child.getElementType()) {
126         case IJavaElement.TYPE:
127           IType nestedtype = (IType) child;
128           processType(visitor, btn.nest(nestedtype), nestedtype, monitor);
129           break;
130         case IJavaElement.METHOD:
131         case IJavaElement.INITIALIZER:
132         case IJavaElement.FIELD:
133           processAnonymousInnerTypes(visitor, btn, (IMember) child, monitor);
134           break;
135       }
136     }
137   }
138
139   private void processAnonymousInnerTypes(ITypeVisitor visitor,
140       BinaryTypeName btn, IMember member, IProgressMonitor monitor)
141       throws JavaModelException {
142     IJavaElement[] types = member.getChildren();
143     for (int i = 0; i < types.length && !monitor.isCanceled(); i++) {
144       IType type = (IType) types[i];
145       processType(visitor, btn.nest(type), type, monitor);
146     }
147   }
148   
149   /**
150    * Internal utility to calculate binary names of nested classes.
151    */

152   private static class BinaryTypeName {
153     
154     private static class Ctr {
155       private int i = 0;
156       public int inc() {
157         return ++i;
158       }
159     }
160     
161     private final String JavaDoc rootname;
162     private final String JavaDoc typename;
163     private final Ctr ctr;
164
165     private BinaryTypeName(String JavaDoc rootname, String JavaDoc typename, Ctr ctr) {
166       this.rootname = rootname;
167       this.typename = typename;
168       this.ctr = ctr;
169     }
170     
171     public BinaryTypeName(IType roottype) {
172       this.rootname = roottype.getFullyQualifiedName().replace('.', '/');
173       this.typename = this.rootname;
174       this.ctr = new Ctr();
175     }
176     
177     public BinaryTypeName nest(IType type) throws JavaModelException {
178       if (type.isAnonymous()) {
179         return new BinaryTypeName(rootname, rootname + '$' + ctr.inc(), ctr);
180       } else {
181         return new BinaryTypeName(rootname, typename + '$' + type.getElementName(), ctr);
182       }
183     }
184     
185     public String JavaDoc toString() {
186       return typename;
187     }
188     
189   }
190   
191 }
192
Popular Tags