KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > spoon > examples > fieldaccess > processing > WriteAccessProcessor


1 package spoon.examples.fieldaccess.processing;
2
3 import spoon.examples.fieldaccess.annotation.Setter;
4 import spoon.examples.fieldaccess.template.FieldAccessTemplate;
5 import spoon.processing.AbstractProcessor;
6 import spoon.reflect.code.CtAssignment;
7 import spoon.reflect.code.CtBlock;
8 import spoon.reflect.code.CtFieldAccess;
9 import spoon.reflect.declaration.CtClass;
10 import spoon.reflect.declaration.CtMethod;
11 import spoon.reflect.reference.CtFieldReference;
12 import spoon.template.Substitution;
13 import spoon.template.Template;
14 import spoon.template.TemplateMatcher;
15
16 /**
17  * This processor replaces all the write accesses of the form
18  * <code>field = expr</code> or <code>expr1.field = expr2</code> by calls to
19  * the setters (<code>setField(expr)</code> or
20  * <code>expr1.setField(expr2)</code>). It uses the template matching
21  * facility ({@link spoon.template.TemplateMatcher}) to avoid doing
22  * this transformation when the written field is done within a setter
23  * implementation (to avoid infinite runtime recursions).
24  */

25 public class WriteAccessProcessor<_FieldType_> extends
26         AbstractProcessor<CtAssignment<_FieldType_, _FieldType_>> {
27
28     public boolean isToBeProcessed(
29             CtAssignment<_FieldType_, _FieldType_> candidate) {
30         return true;
31     }
32
33     public void process(CtAssignment<_FieldType_, _FieldType_> assignment) {
34         if (assignment.getAssigned() instanceof CtFieldAccess) {
35             CtFieldAccess<_FieldType_> fa = ((CtFieldAccess<_FieldType_>) assignment
36                     .getAssigned());
37             CtFieldReference<_FieldType_> field = fa.getVariable();
38             if (ServerAccessProcessor.fields.contains(field)) {
39
40                 // if (assignment.getParent(CtMethod.class).getSimpleName()
41
// .compareToIgnoreCase("set" + field.getSimpleName()) == 0)
42
// return;
43
CtClass<FieldAccessTemplate> templateType = getFactory().Template()
44                         .get(FieldAccessTemplate.class);
45                 TemplateMatcher matcher = new TemplateMatcher(templateType);
46                 CtMethod setter = (CtMethod) templateType.getAnnotatedChildren(
47                         Setter.class).get(0);
48                 if (!matcher
49                         .match(assignment.getParent(CtMethod.class), setter)) {
50                     Template t = new FieldAccessTemplate<_FieldType_>(field
51                             .getType(), field.getSimpleName(), fa, assignment
52                             .getAssignment());
53
54                     CtBlock<?> b = Substitution.substituteMethodBody(assignment
55                             .getParent(CtClass.class), t, "setterInvocation");
56                     assignment.replace(b.getStatements().get(0));
57                 }
58             }
59         }
60     }
61 }
62
Popular Tags