001: package spoon.aval.processing;
002:
003: import java.awt.Color;
004: import java.awt.Component;
005: import java.util.ArrayList;
006: import java.util.HashMap;
007: import java.util.List;
008: import java.util.Map;
009:
010: import javax.swing.JFrame;
011: import javax.swing.JLabel;
012: import javax.swing.JScrollPane;
013: import javax.swing.JTree;
014: import javax.swing.event.TreeModelListener;
015: import javax.swing.tree.TreeCellRenderer;
016: import javax.swing.tree.TreeModel;
017: import javax.swing.tree.TreePath;
018:
019: import spoon.processing.AbstractProcessor;
020: import spoon.processing.Severity;
021: import spoon.reflect.cu.SourcePosition;
022: import spoon.reflect.declaration.CtAnnotationType;
023: import spoon.reflect.declaration.CtElement;
024: import spoon.reflect.declaration.CtExecutable;
025: import spoon.reflect.declaration.CtField;
026: import spoon.reflect.declaration.CtPackage;
027: import spoon.reflect.declaration.CtSimpleType;
028: import spoon.reflect.reference.CtExecutableReference;
029: import spoon.reflect.reference.CtReference;
030: import spoon.reflect.reference.CtTypeReference;
031: import spoon.reflect.visitor.CtStackScanner;
032:
033: /**
034: * This processor maps annotations with their corresponding uses in a given
035: * package
036: * <p>
037: * ********************* UNSTABLE ***************************
038: * <p>
039: */
040: public class AnnotationProcessingMapProcessor extends
041: AbstractProcessor<CtAnnotationType<?>> {
042:
043: private List<CtPackage> framework;
044:
045: private List<APPoint> report;
046:
047: @Override
048: public void init() {
049: super .init();
050: framework = new ArrayList<CtPackage>();
051: framework.addAll(getFactory().Package().getAll());
052: framework.remove(getFactory().Package().get(
053: "org.hibernate.annotations"));
054: framework.remove(getFactory().Package().get(
055: "org.hibernate.validator"));
056: // System.out.println(framework);
057: // framework.add(getFactory().Package().getCreatedPackage("spoon.aval.processing"));
058: // framework.add(getFactory().Package().getCreatedPackage("org.objectweb.fractal.fraclet.annotation.processor"));
059: report = new ArrayList<APPoint>();
060: }
061:
062: public void process(CtAnnotationType<?> element) {
063: APPoint point = new APPoint();
064: point.ap = element;
065: point.apPosition = checkTypeUse(element);
066: point.attribsPosition = new HashMap<CtField<?>, List<CtElement>>();
067: List<CtField<?>> fields = element.getFields();
068:
069: for (CtField<?> field : fields) {
070: point.attribsPosition.put(field, checkAccess(field));
071: }
072: report.add(point);
073: }
074:
075: private List<CtElement> checkAccess(final CtField<?> field) {
076: final boolean[] found = new boolean[1];
077: final List<CtElement> users = new ArrayList<CtElement>();
078: found[0] = false;
079: for (CtPackage pack : framework) {
080: new CtStackScanner() {
081: @Override
082: public void scan(CtReference reference) {
083: if (reference instanceof CtExecutableReference) {
084: CtExecutableReference ref = (CtExecutableReference) reference;
085: if (ref.getSimpleName().equals(
086: field.getSimpleName())
087: && ref.getDeclaringType().equals(
088: field.getDeclaringType()
089: .getReference())
090: && this .elementStack.peek().getParent(
091: CtExecutable.class) != null) {
092: users.add(this .elementStack.peek());
093: }
094: }
095: super .scan(reference);
096: }
097: }.scan(pack);
098: }
099:
100: return users;
101: }
102:
103: private List<CtElement> checkTypeUse(
104: final CtAnnotationType<?> element) {
105: final List<CtElement> users = new ArrayList<CtElement>();
106: for (CtPackage pack : framework) {
107: new CtStackScanner() {
108: @Override
109: public void scan(CtReference reference) {
110: if (reference instanceof CtTypeReference<?>) {
111: CtTypeReference<?> ref = (CtTypeReference<?>) reference;
112: if (ref.equals(element.getReference())
113: && this .elementStack.peek().getParent(
114: CtExecutable.class) != null) {
115: if (!users.contains(this .elementStack
116: .peek()))
117: users.add(this .elementStack.peek());
118: }
119: }
120: super .scan(reference);
121: }
122:
123: }.scan(pack);
124: }
125: return users;
126: }
127:
128: @Override
129: public void processingDone() {
130: super .processingDone();
131: // new ReportFrame(report).setVisible(true);
132: for (APPoint point : report) {
133: point.ap.getFactory().getEnvironment().report(this ,
134: Severity.MESSAGE, point.ap,
135: "Annotation " + point.ap.getSimpleName());
136: for (CtElement p : point.apPosition) {
137: p.getFactory().getEnvironment().report(this ,
138: Severity.MESSAGE, p, "is processed ");
139: }
140: }
141: }
142: }
143:
144: class APPoint {
145: CtAnnotationType ap;
146:
147: List<CtElement> apPosition;
148:
149: Map<CtField<?>, List<CtElement>> attribsPosition;
150: }
151:
152: class ReportFrame extends JFrame {
153: /**
154: * generated ID
155: */
156: private static final long serialVersionUID = -5118768893183502357L;
157:
158: class Renderer implements TreeCellRenderer {
159:
160: JLabel lbl = new JLabel();
161:
162: public Component getTreeCellRendererComponent(JTree tree,
163: Object value, boolean selected, boolean expanded,
164: boolean leaf, int row, boolean hasFocus) {
165:
166: if (selected) {
167: lbl.setBackground(Color.green);
168: } else {
169: lbl.setBackground(Color.white);
170: }
171:
172: if (value instanceof CtSimpleType) {
173: CtSimpleType stV = (CtSimpleType) value;
174: lbl.setText(stV.getSimpleName());
175: } else if (value instanceof CtElement) {
176: SourcePosition sp = (SourcePosition) ((CtElement) value)
177: .getPosition();
178: lbl.setText(sp.getFile() + " : " + sp.getLine());
179: } else if (value instanceof List) {
180: lbl.setText("Report");
181: } else
182: lbl.setText(value.toString());
183: return lbl;
184: }
185:
186: }
187:
188: JTree tree;
189:
190: public ReportFrame(List<APPoint> r) {
191: tree = new JTree();
192: tree.setModel(new ReportModel(r));
193: tree.setCellRenderer(new Renderer());
194: JScrollPane jsp = new JScrollPane(tree);
195: tree.setScrollsOnExpand(true);
196: // DefaultTreeSelectionModel tsm = new DefaultTreeSelectionModel();
197: this .getContentPane().add(jsp);
198: this .setSize(640, 480);
199: }
200:
201: class ReportModel implements TreeModel {
202: List<APPoint> rep;
203:
204: List<TreeModelListener> list;
205:
206: public ReportModel(List<APPoint> r) {
207: super ();
208: rep = r;
209: list = new ArrayList<TreeModelListener>();
210:
211: }
212:
213: public void addTreeModelListener(TreeModelListener l) {
214: list.add(l);
215: }
216:
217: public Object getChild(Object parent, int index) {
218: if (parent instanceof List) {
219: return rep.get(index).ap;
220: }
221: for (APPoint point : rep) {
222: if (point.ap.equals(parent)) {
223: return point.apPosition.get(index);
224: }
225: // for (iterable_type iterable_element : iterable) {
226: //
227: // }
228: }
229: return null;
230: }
231:
232: public int getChildCount(Object parent) {
233: if (parent instanceof List) {
234: return rep.size();
235: }
236: for (APPoint point : rep) {
237: if (point.ap.equals(parent)) {
238: return point.apPosition.size();
239: }
240: // for (iterable_type iterable_element : iterable) {
241: //
242: // }
243: }
244: return 0;
245: }
246:
247: public int getIndexOfChild(Object parent, Object child) {
248: for (APPoint point : rep) {
249: if (point.ap.equals(parent)) {
250: }
251: // for (iterable_type iterable_element : iterable) {
252: //
253: // }
254: }
255: return 0;
256: }
257:
258: public Object getRoot() {
259: // TODO Auto-generated method stub
260: return rep;
261: }
262:
263: public boolean isLeaf(Object node) {
264: return node instanceof SourcePosition;
265: }
266:
267: public void removeTreeModelListener(TreeModelListener l) {
268: list.remove(l);
269: }
270:
271: public void valueForPathChanged(TreePath path, Object newValue) {
272: // TODO Auto-generated method stub
273:
274: }
275:
276: }
277: }
|