KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > aspectwerkz > aspect > AdviceInfo


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.aspect;
9
10 import org.codehaus.aspectwerkz.transform.inlining.AsmHelper;
11 import org.codehaus.aspectwerkz.expression.ExpressionInfo;
12 import org.codehaus.aspectwerkz.expression.ExpressionContext;
13 import org.codehaus.aspectwerkz.definition.AdviceDefinition;
14 import org.codehaus.aspectwerkz.DeploymentModel;
15 import org.objectweb.asm.Type;
16
17 import java.io.Serializable JavaDoc;
18
19 /**
20  * Contains advice info, like indexes describing the aspect and a method (advice or introduced),
21  * aspect manager etc.
22  *
23  * @author <a HREF="mailto:jboner@codehaus.org">Jonas Bonér </a>
24  * @author <a HREF="mailto:alex@gnilux.com">Alexandre Vasseur </a>
25  */

26 public class AdviceInfo implements Serializable JavaDoc {
27
28     public final static AdviceInfo[] EMPTY_ADVICE_INFO_ARRAY = new AdviceInfo[0];
29
30     // -- some magic index used in the m_methodToArgIndexes[] so that we know what to bind except advised target args
31
// -- those constants MUST be negative since positive values are used for args(..) binding
32
public final static int JOINPOINT_ARG = -0x1;
33     public final static int STATIC_JOINPOINT_ARG = -0x2;
34     public final static int TARGET_ARG = -0x3;
35     public final static int THIS_ARG = -0x4;
36     public final static int VALID_NON_AW_AROUND_CLOSURE_TYPE = -0x5;
37     public final static int SPECIAL_ARGUMENT = -0x6;
38     public static final int CUSTOM_JOIN_POINT_ARG = -0x7;
39
40     /**
41      * The method name.
42      */

43     private String JavaDoc m_methodName;
44
45     /**
46      * The method sig.
47      */

48     private String JavaDoc m_methodSignature;
49
50     /**
51      * The method's parameter types.
52      */

53     private Type[] m_methodParameterTypes;
54
55     /**
56      * The advice name
57      * <adviceMethodName>[(... call signature)]
58      */

59     private final String JavaDoc m_name;
60
61     /**
62      * The aspect class name where this advice is defined.
63      */

64     private String JavaDoc m_aspectClassName;
65
66     /**
67      * The aspect qualified name - <uuid>/<aspectNickName or FQNclassName>
68      */

69     private String JavaDoc m_aspectQualifiedName;
70
71     /**
72      * The aspect deployment model
73      */

74     private DeploymentModel m_aspectDeploymentModel;
75
76     /**
77      * The advice method arg index mapped to the advisED target arg index.
78      * If the value is greater or equal to 0, it is an args binding. Else, it is a magic index
79      * (see constants JOINPOINT_ARG, STATIC_JOINPOINT_ARG, THIS_ARG, TARGET_ARG)
80      */

81     private int[] m_methodToArgIndexes;
82
83     /**
84      * The "special" argument type desc for the advice.
85      */

86     private String JavaDoc m_specialArgumentTypeDesc;
87
88     /**
89      * The "special" argument type name for the advice.
90      */

91     private String JavaDoc m_specialArgumentTypeName;
92
93     /**
94      * The advice type.
95      */

96     private AdviceType m_type;
97
98     /**
99      * Runtime check flag.
100      */

101     private boolean m_targetWithRuntimeCheck;
102
103     /**
104      * The expression info.
105      */

106     private ExpressionInfo m_expressionInfo;
107
108     /**
109      * The expression context.
110      */

111     private ExpressionContext m_expressionContext;
112
113     /**
114      * The advice definition for this advice.
115      */

116     private AdviceDefinition m_adviceDef;
117
118     /**
119      * TODO refactor - many member fields holds data that is in either the adviceDef (which is in the class) or the aspectDef (which is accessible from the adviceDef)
120      * <p/>
121      * Creates a new advice info.
122      *
123      * @param aspectQualifiedName
124      * @param aspectClassName
125      * @param aspectDeploymentModel
126      * @param methodName
127      * @param methodSignature
128      * @param methodParameterTypes
129      * @param type the advice type
130      * @param specialArgumentType the special arg type
131      * @param adviceName full qualified advice method name (aspectFQN/advice(call sig))
132      * @param targetWithRuntimeCheck true if a runtime check is needed based on target instance
133      * @param expressionInfo
134      * @param expressionContext
135      * @param adviceDef
136      */

137     public AdviceInfo(final String JavaDoc aspectQualifiedName,
138                       final String JavaDoc aspectClassName,
139                       final DeploymentModel aspectDeploymentModel,
140                       final String JavaDoc methodName,
141                       final String JavaDoc methodSignature,
142                       final Type[] methodParameterTypes,
143                       final AdviceType type,
144                       final String JavaDoc specialArgumentType,
145                       final String JavaDoc adviceName,
146                       final boolean targetWithRuntimeCheck,
147                       final ExpressionInfo expressionInfo,
148                       final ExpressionContext expressionContext,
149                       final AdviceDefinition adviceDef) {
150         m_aspectQualifiedName = aspectQualifiedName;
151         m_aspectClassName = aspectClassName;
152         m_aspectDeploymentModel = aspectDeploymentModel;
153         m_methodName = methodName;
154         m_methodSignature = methodSignature;
155         m_methodParameterTypes = methodParameterTypes;
156         m_type = type;
157         if (specialArgumentType != null && specialArgumentType.length()>0) {//AW-434
158
m_specialArgumentTypeDesc = AsmHelper.convertReflectDescToTypeDesc(specialArgumentType);
159             m_specialArgumentTypeName = specialArgumentType.replace('.', '/');
160         }
161         m_name = adviceName;
162         m_targetWithRuntimeCheck = targetWithRuntimeCheck;
163         m_expressionInfo = expressionInfo;
164         m_expressionContext = expressionContext;
165         m_adviceDef = adviceDef;
166     }
167
168     /**
169      * Return the method name.
170      *
171      * @return the method name
172      */

173     public String JavaDoc getMethodName() {
174         return m_methodName;
175     }
176
177     /**
178      * Return the method signature.
179      *
180      * @return the method signature
181      */

182     public String JavaDoc getMethodSignature() {
183         return m_methodSignature;
184     }
185
186     /**
187      * Return the method name.
188      *
189      * @return the method name
190      */

191     public Type[] getMethodParameterTypes() {
192         return m_methodParameterTypes;
193     }
194
195     /**
196      * Returns the aspect qualified name.
197      *
198      * @return the aspect qualified name
199      */

200     public String JavaDoc getAspectQualifiedName() {
201         return m_aspectQualifiedName;
202     }
203
204     /**
205      * Returns the aspect FQN className.
206      *
207      * @return the aspect class name
208      */

209     public String JavaDoc getAspectClassName() {
210         return m_aspectClassName;
211     }
212
213     /**
214      * Returns the aspect deployment model
215      *
216      * @return
217      */

218     public DeploymentModel getAspectDeploymentModel() {
219         return m_aspectDeploymentModel;
220     }
221
222     /**
223      * Returns the name of the advice.
224      *
225      * @return
226      */

227     public String JavaDoc getName() {
228         return m_name;
229     }
230
231     /**
232      * Sets the advice method to target method arg mapping A value of -1 means "not mapped"
233      *
234      * @param map
235      */

236     public void setMethodToArgIndexes(final int[] map) {
237         m_methodToArgIndexes = map;
238     }
239
240     /**
241      * Returns the advice method to target method arg index mapping.
242      *
243      * @return the indexes
244      */

245     public int[] getMethodToArgIndexes() {
246         return m_methodToArgIndexes;
247     }
248
249     /**
250      * Returns the special argument type desc.
251      *
252      * @return
253      */

254     public String JavaDoc getSpecialArgumentTypeDesc() {
255         return m_specialArgumentTypeDesc;
256     }
257
258     /**
259      * Returns the special argument type name.
260      *
261      * @return
262      */

263     public String JavaDoc getSpecialArgumentTypeName() {
264         return m_specialArgumentTypeName;
265     }
266
267     /**
268      * Returns the advice type.
269      *
270      * @return
271      */

272     public AdviceType getType() {
273         return m_type;
274     }
275
276     /**
277      * Checks if the target has a runtime check.
278      *
279      * @return
280      */

281     public boolean hasTargetWithRuntimeCheck() {
282         return m_targetWithRuntimeCheck;
283     }
284
285     /**
286      * Returns the expression info.
287      *
288      * @return
289      */

290     public ExpressionInfo getExpressionInfo() {
291         return m_expressionInfo;
292     }
293
294     /**
295      * Returns the expression context.
296      *
297      * @return
298      */

299     public ExpressionContext getExpressionContext() {
300         return m_expressionContext;
301     }
302
303     /**
304      * Returns the advice definition.
305      *
306      * @return
307      */

308     public AdviceDefinition getAdviceDefinition() {
309         return m_adviceDef;
310     }
311
312     public String JavaDoc toString() {
313         StringBuffer JavaDoc sb = new StringBuffer JavaDoc("AdviceInfo[");
314         sb.append(m_type).append(',');
315         sb.append(m_aspectQualifiedName).append(',');
316         sb.append(m_name).append(',');
317         sb.append(m_methodName).append(',');
318         sb.append(m_methodSignature).append(',');
319         sb.append(m_methodParameterTypes).append(',');
320         sb.append(m_specialArgumentTypeDesc).append(',');
321         sb.append(m_expressionInfo).append(',');
322         sb.append(m_expressionContext).append(',');
323         sb.append(m_targetWithRuntimeCheck).append(']');
324         sb.append(hashCode());
325         return sb.toString();
326     }
327
328 }
Popular Tags