KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > spoon > examples > analysis > processing > ReferenceProcessor


1 package spoon.examples.analysis.processing;
2
3 import java.util.ArrayList JavaDoc;
4 import java.util.HashMap JavaDoc;
5 import java.util.List JavaDoc;
6 import java.util.Map JavaDoc;
7 import java.util.Set JavaDoc;
8 import java.util.Stack JavaDoc;
9 import java.util.TreeSet JavaDoc;
10
11 import spoon.processing.AbstractProcessor;
12 import spoon.processing.Environment;
13 import spoon.processing.FactoryAccessor;
14 import spoon.processing.Severity;
15 import spoon.reflect.Factory;
16 import spoon.reflect.declaration.CtPackage;
17 import spoon.reflect.declaration.CtSimpleType;
18 import spoon.reflect.reference.CtPackageReference;
19 import spoon.reflect.reference.CtTypeReference;
20 import spoon.reflect.visitor.Query;
21 import spoon.support.query.ReferenceTypeFilter;
22
23 /**
24  * Finds circular dependencies between packages and report warnings when found.
25  */
26 public class ReferenceProcessor extends AbstractProcessor<CtPackage> {
27
28     List JavaDoc<CtTypeReference> ignoredTypes = new ArrayList JavaDoc<CtTypeReference>();
29
30     @Override JavaDoc
31     public void init() {
32         ignoredTypes
33                 .add(getFactory().Type().createReference(Environment.class));
34         ignoredTypes.add(getFactory().Type().createReference(Factory.class));
35         ignoredTypes.add(getFactory().Type().createReference(
36                 FactoryAccessor.class));
37     }
38
39     Map JavaDoc<CtPackageReference, Set JavaDoc<CtPackageReference>> packRefs = new HashMap JavaDoc<CtPackageReference, Set JavaDoc<CtPackageReference>>();
40
41     public void process(CtPackage element) {
42         CtPackageReference pack = element.getReference();
43         Set JavaDoc<CtPackageReference> refs = new TreeSet JavaDoc<CtPackageReference>();
44         for (CtSimpleType t : element.getTypes()) {
45             for (CtTypeReference<?> tref : Query.getReferences(t,
46                     new ReferenceTypeFilter<CtTypeReference>(
47                             CtTypeReference.class))) {
48                 if (tref.getPackage() != null
49                         && !tref.getPackage().equals(pack)) {
50                     if (ignoredTypes.contains(tref))
51                         continue;
52                     refs.add(tref.getPackage());
53                 }
54             }
55         }
56         if (refs.size() > 0)
57             packRefs.put(pack, refs);
58         // if (getFactory().getEnvironment().isVerbose())
59 // System.out.println(refs);
60 }
61
62     @Override JavaDoc
63     public void processingDone() {
64         // getFactory().getEnvironment().reportMessage(
65 // "package dependencies: " + packRefs);
66 // getFactory().getEnvironment().reportMessage(
67 // "looking for circular package dependencies...");
68 // looking for circular dependecies
69 for (CtPackageReference p : packRefs.keySet()) {
70             Stack JavaDoc<CtPackageReference> path = new Stack JavaDoc<CtPackageReference>();
71             path.push(p);
72             scanDependencies(path);
73         }
74     }
75
76     Set JavaDoc<CtPackageReference> scanned = new TreeSet JavaDoc<CtPackageReference>();
77
78     void scanDependencies(Stack JavaDoc<CtPackageReference> path) {
79         // getFactory().getEnvironment().reportMessage("scanning " + path);
80 CtPackageReference ref = path.peek();
81         // return if already scanned
82 if (scanned.contains(ref))
83             return;
84         scanned.add(ref);
85         Set JavaDoc<CtPackageReference> refs = packRefs.get(ref);
86         if (refs != null) {
87             for (CtPackageReference p : refs) {
88                 if (path.contains(p)) {
89                     List JavaDoc<CtPackageReference> circularPath = new ArrayList JavaDoc<CtPackageReference>(
90                             path.subList(path.indexOf(p), path.size()));
91                     circularPath.add(p);
92                     getFactory().getEnvironment().report(this,
93                             Severity.WARNING,
94                             "circular dependency " + circularPath);
95                     break;
96                 } else {
97                     path.push(p);
98                     scanDependencies(path);
99                     path.pop();
100                 }
101             }
102         }
103     }
104
105 }
106
Popular Tags