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  ;
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   {
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   m_methodName;
44  
45      /**
46       * The method sig.
47       */
48      private String   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   m_name;
60  
61      /**
62       * The aspect class name where this advice is defined.
63       */
64      private String   m_aspectClassName;
65  
66      /**
67       * The aspect qualified name - <uuid>/<aspectNickName or FQNclassName>
68       */
69      private String   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   m_specialArgumentTypeDesc;
87  
88      /**
89       * The "special" argument type name for the advice.
90       */
91      private String   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   aspectQualifiedName,
138                       final String   aspectClassName,
139                       final DeploymentModel aspectDeploymentModel,
140                       final String   methodName,
141                       final String   methodSignature,
142                       final Type[] methodParameterTypes,
143                       final AdviceType type,
144                       final String   specialArgumentType,
145                       final String   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   getMethodName() {
174         return m_methodName;
175     }
176 
177     /**
178      * Return the method signature.
179      *
180      * @return the method signature
181      */
182     public String   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   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   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   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   getSpecialArgumentTypeDesc() {
255         return m_specialArgumentTypeDesc;
256     }
257 
258     /**
259      * Returns the special argument type name.
260      *
261      * @return
262      */
263     public String   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   toString() {
313         StringBuffer   sb = new StringBuffer  ("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 }
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags