View Javadoc

1   /***************************************************************************************
2    * Copyright (c) Jonas Bonér, Alexandre Vasseur. All rights reserved.                 *
3    * http://aspectwerkz.codehaus.org                                                    *
4    * ---------------------------------------------------------------------------------- *
5    * The software in this package is published under the terms of the LGPL license      *
6    * a copy of which has been included with this distribution in the license.txt file.  *
7    **************************************************************************************/
8   package org.codehaus.aspectwerkz.expression;
9   
10  import org.codehaus.aspectwerkz.annotation.AnnotationInfo;
11  import org.codehaus.aspectwerkz.expression.ast.ASTAnd;
12  import org.codehaus.aspectwerkz.expression.ast.ASTAttribute;
13  import org.codehaus.aspectwerkz.expression.ast.ASTCall;
14  import org.codehaus.aspectwerkz.expression.ast.ASTCflow;
15  import org.codehaus.aspectwerkz.expression.ast.ASTCflowBelow;
16  import org.codehaus.aspectwerkz.expression.ast.ASTClassPattern;
17  import org.codehaus.aspectwerkz.expression.ast.ASTConstructorPattern;
18  import org.codehaus.aspectwerkz.expression.ast.ASTExecution;
19  import org.codehaus.aspectwerkz.expression.ast.ASTExpression;
20  import org.codehaus.aspectwerkz.expression.ast.ASTFieldPattern;
21  import org.codehaus.aspectwerkz.expression.ast.ASTGet;
22  import org.codehaus.aspectwerkz.expression.ast.ASTHandler;
23  import org.codehaus.aspectwerkz.expression.ast.ASTMethodPattern;
24  import org.codehaus.aspectwerkz.expression.ast.ASTModifier;
25  import org.codehaus.aspectwerkz.expression.ast.ASTNot;
26  import org.codehaus.aspectwerkz.expression.ast.ASTOr;
27  import org.codehaus.aspectwerkz.expression.ast.ASTParameter;
28  import org.codehaus.aspectwerkz.expression.ast.ASTPointcutReference;
29  import org.codehaus.aspectwerkz.expression.ast.ASTRoot;
30  import org.codehaus.aspectwerkz.expression.ast.ASTSet;
31  import org.codehaus.aspectwerkz.expression.ast.ASTStaticInitialization;
32  import org.codehaus.aspectwerkz.expression.ast.ASTWithin;
33  import org.codehaus.aspectwerkz.expression.ast.ASTWithinCode;
34  import org.codehaus.aspectwerkz.expression.ast.ExpressionParserVisitor;
35  import org.codehaus.aspectwerkz.expression.ast.Node;
36  import org.codehaus.aspectwerkz.expression.ast.SimpleNode;
37  import org.codehaus.aspectwerkz.expression.ast.ASTArgs;
38  import org.codehaus.aspectwerkz.expression.ast.ASTArgParameter;
39  import org.codehaus.aspectwerkz.expression.regexp.TypePattern;
40  import org.codehaus.aspectwerkz.reflect.ClassInfo;
41  import org.codehaus.aspectwerkz.reflect.ClassInfoHelper;
42  import org.codehaus.aspectwerkz.reflect.ConstructorInfo;
43  import org.codehaus.aspectwerkz.reflect.FieldInfo;
44  import org.codehaus.aspectwerkz.reflect.MemberInfo;
45  import org.codehaus.aspectwerkz.reflect.MethodInfo;
46  import org.codehaus.aspectwerkz.reflect.ReflectionInfo;
47  
48  import java.lang.reflect.Modifier;
49  import java.util.ArrayList;
50  import java.util.Iterator;
51  import java.util.List;
52  import org.codehaus.aspectwerkz.expression.ast.ASTHasField;
53  import org.codehaus.aspectwerkz.expression.ast.ASTHasMethod;
54  import org.codehaus.aspectwerkz.util.Strings;
55  
56  /***
57   * The visitor that extract all possible arguments referenced by the expression.
58   *
59   * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur </a>
60   */
61  public class ExpressionValidateVisitor implements ExpressionParserVisitor {
62  
63      protected ASTRoot m_root;
64      protected String m_expression;
65      protected String m_namespace;
66  
67      /***
68       * Creates a new expression.
69       *
70       * @param expression the expression as a string
71       * @param namespace the namespace
72       * @param root the AST root
73       */
74      public ExpressionValidateVisitor(final String expression,
75                               final String namespace,
76                               final ASTRoot root) {
77          m_expression = expression;
78          m_namespace = namespace;
79          m_root = root;
80      }
81  
82      /***
83       * Populate data with the possible arguments
84       *
85       * @param data a list to feed with Strings
86       */
87      public void populate(List data) {
88          visit(m_root, data);
89      }
90  
91      // ============ Boot strap =============
92      public Object visit(SimpleNode node, Object data) {
93          return node.jjtGetChild(0).jjtAccept(this, data);
94      }
95  
96      public Object visit(ASTRoot node, Object data) {
97          return node.jjtGetChild(0).jjtAccept(this, data);
98      }
99  
100     public Object visit(ASTExpression node, Object data) {
101         return node.jjtGetChild(0).jjtAccept(this, data);
102     }
103 
104     // ============ Logical operators =============
105     public Object visit(ASTOr node, Object data) {
106         for (int i = 0; i < node.jjtGetNumChildren(); i++) {
107             List args = (List) node.jjtGetChild(i).jjtAccept(this, data);
108             ((List)data).addAll(args);
109         }
110         return data;
111     }
112 
113     public Object visit(ASTAnd node, Object data) {
114         for (int i = 0; i < node.jjtGetNumChildren(); i++) {
115             List args = (List) node.jjtGetChild(i).jjtAccept(this, data);
116             ((List)data).addAll(args);
117         }
118         return data;
119     }
120 
121     public Object visit(ASTNot node, Object data) {
122         for (int i = 0; i < node.jjtGetNumChildren(); i++) {
123             List args = (List) node.jjtGetChild(i).jjtAccept(this, data);
124             ((List)data).addAll(args);
125         }
126         return data;
127     }
128 
129     // ============ Pointcut types =============
130     public Object visit(ASTPointcutReference node, Object data) {
131         // visit the args - if any
132         for (int i = 0; i < node.jjtGetNumChildren(); i++) {
133             List args = (List) node.jjtGetChild(i).jjtAccept(this, data);
134             ((List)data).addAll(args);
135         }
136         return data;
137     }
138 
139     public Object visit(ASTExecution node, Object data) {
140         return data;
141     }
142 
143     public Object visit(ASTCall node, Object data) {
144         return data;
145     }
146 
147     public Object visit(ASTSet node, Object data) {
148         return data;
149     }
150 
151     public Object visit(ASTGet node, Object data) {
152         return data;
153     }
154 
155     public Object visit(ASTHandler node, Object data) {
156         return data;
157     }
158 
159     public Object visit(ASTStaticInitialization node, Object data) {
160         return data;
161     }
162 
163     public Object visit(ASTWithin node, Object data) {
164         return data;
165     }
166 
167     public Object visit(ASTWithinCode node, Object data) {
168         return data;
169     }
170 
171 
172     public Object visit(ASTHasMethod node, Object data) {
173         return data;
174     }
175 
176     public Object visit(ASTHasField node, Object data) {
177         return data;
178     }
179 
180     public Object visit(ASTCflow node, Object data) {
181         return data;
182     }
183 
184     public Object visit(ASTCflowBelow node, Object data) {
185         return data;
186     }
187 
188     // ============ Patterns =============
189     public Object visit(ASTClassPattern node, Object data) {
190         return data;
191     }
192 
193     public Object visit(ASTMethodPattern node, Object data) {
194         return data;
195     }
196 
197     public Object visit(ASTConstructorPattern node, Object data) {
198         return data;
199     }
200 
201     public Object visit(ASTFieldPattern node, Object data) {
202         return data;
203     }
204 
205     public Object visit(ASTParameter node, Object data) {
206         return data;
207     }
208 
209     public Object visit(ASTArgs node, Object data) {
210         for (int i = 0; i < node.jjtGetNumChildren(); i++) {
211             List args = (List) node.jjtGetChild(i).jjtAccept(this, data);
212             ((List)data).addAll(args);
213         }
214         return data;
215     }
216 
217     public Object visit(ASTArgParameter node, Object data) {
218         TypePattern typePattern = node.getTypePattern();
219         ((List)data).add(typePattern.getPattern());
220         return data;
221     }
222 
223     public Object visit(ASTAttribute node, Object data) {
224         return data;
225     }
226 
227     public Object visit(ASTModifier node, Object data) {
228         return data;
229     }
230 
231     /***
232      * Returns the string representation of the expression.
233      *
234      * @return
235      */
236     public String toString() {
237         return m_expression;
238     }
239 
240 }