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.joinpoint.management;
9   
10  import java.lang.reflect.Constructor;
11  import java.lang.reflect.Field;
12  import java.lang.reflect.Method;
13  
14  import org.codehaus.aspectwerkz.joinpoint.EnclosingStaticJoinPoint;
15  import org.codehaus.aspectwerkz.joinpoint.impl.CatchClauseSignatureImpl;
16  import org.codehaus.aspectwerkz.joinpoint.impl.ConstructorSignatureImpl;
17  import org.codehaus.aspectwerkz.joinpoint.impl.EnclosingStaticJoinPointImpl;
18  import org.codehaus.aspectwerkz.joinpoint.impl.FieldSignatureImpl;
19  import org.codehaus.aspectwerkz.joinpoint.impl.MethodSignatureImpl;
20  import org.codehaus.aspectwerkz.joinpoint.impl.StaticInitializerSignatureImpl;
21  import org.codehaus.aspectwerkz.reflect.ReflectHelper;
22  import org.codehaus.aspectwerkz.transform.TransformationConstants;
23  import org.codehaus.aspectwerkz.transform.inlining.AsmHelper;
24  
25  /***
26   * Factory class for the signature hierarchy.
27   * The helper methods here are called by the JIT jp.
28   *
29   * TODO may be worth having a cache
30   *
31   * @author <a href="mailto:jboner@codehaus.org">Jonas BonŽr </a>
32   * @author <a href="mailto:the_mindstorm@evolva.ro">Alex Popescu</a>
33   */
34  public final class SignatureFactory {
35  
36      /***
37       * Method signature factory
38       *
39       * @param declaringClass
40       * @param joinPointHash
41       * @return
42       */
43      public static final MethodSignatureImpl newMethodSignature(final Class declaringClass, final int joinPointHash) {
44          Method[] methods = declaringClass.getDeclaredMethods();
45          for (int i = 0; i < methods.length; i++) {
46              Method method = methods[i];
47              if (ReflectHelper.calculateHash(method) == joinPointHash) {
48                  return new MethodSignatureImpl(declaringClass, method);
49              }
50          }
51          // lookup in the hierarchy
52          MethodSignatureImpl signature = null;
53          for (int i = 0; i < declaringClass.getInterfaces().length; i++) {
54              signature = newMethodSignature(declaringClass.getInterfaces()[i], joinPointHash);
55              if (signature != null) {
56                  return signature;
57              }
58          }
59          if (declaringClass.getSuperclass() != null) {
60              signature = newMethodSignature(declaringClass.getSuperclass(), joinPointHash);
61          } else {
62              return null;
63          }
64          return signature;
65      }
66      
67      /***
68       * Field signature factory
69       *
70       * @param declaringClass
71       * @param joinPointHash
72       * @return
73       */
74      public static final FieldSignatureImpl newFieldSignature(final Class declaringClass, final int joinPointHash) {
75          Field[] fields = declaringClass.getDeclaredFields();
76          for (int i = 0; i < fields.length; i++) {
77              Field field = fields[i];
78              if (ReflectHelper.calculateHash(field) == joinPointHash) {
79                  return new FieldSignatureImpl(declaringClass, field);
80              }
81          }
82          // lookup in the hierarchy
83          if (declaringClass.getSuperclass() != null) {
84              return newFieldSignature(declaringClass.getSuperclass(), joinPointHash);
85          } else {
86              return null;
87          }
88      }
89  
90      /***
91       * Constructor signature factory
92       *
93       * @param declaringClass
94       * @param joinPointHash
95       * @return
96       */
97      public static final ConstructorSignatureImpl newConstructorSignature(final Class declaringClass,
98                                                                           final int joinPointHash) {
99          Constructor constructor = null;
100         for (int i = 0; i < declaringClass.getDeclaredConstructors().length; i++) {
101             Constructor c = declaringClass.getDeclaredConstructors()[i];
102             if (ReflectHelper.calculateHash(c) == joinPointHash) {
103                 return new ConstructorSignatureImpl(declaringClass, c);
104             }
105         }
106         // lookup in the hierarchy
107         if (declaringClass.getSuperclass() != null) {
108             return newConstructorSignature(declaringClass.getSuperclass(), joinPointHash);
109         } else {
110             return null;
111         }
112     }
113 
114     /***
115      * Handler signature factory
116      *
117      * @param exceptionClass
118      * @return
119      */
120     public static final CatchClauseSignatureImpl newCatchClauseSignature(final Class exceptionClass) {
121         return new CatchClauseSignatureImpl(exceptionClass);
122     }
123 
124     /***
125      * Enclosing signature factory, wrapped behind an EnclosingStaticJoinPoint for syntax consistency
126      *
127      * @param declaringClass
128      * @param name
129      * @param description
130      * @return
131      */
132     public static EnclosingStaticJoinPoint newEnclosingStaticJoinPoint(
133     		final Class declaringClass,
134     		final String name,
135     		final String description) {
136         if (TransformationConstants.CLINIT_METHOD_NAME.equals(name)) {
137             return new EnclosingStaticJoinPointImpl(
138                     new StaticInitializerSignatureImpl(declaringClass),
139                     JoinPointType.STATIC_INITIALIZATION
140             );
141         } else if (TransformationConstants.INIT_METHOD_NAME.equals(name)) {
142             return new EnclosingStaticJoinPointImpl(
143                     newConstructorSignature(declaringClass, AsmHelper.calculateConstructorHash(description)),
144                     JoinPointType.CONSTRUCTOR_EXECUTION
145             );
146         } else {
147             // regular method
148             return new EnclosingStaticJoinPointImpl(
149                     newMethodSignature(declaringClass, AsmHelper.calculateMethodHash(name, description)),
150                     JoinPointType.METHOD_EXECUTION
151             );
152         }
153     }
154 
155     /***
156      * Static initialization factory
157      * 
158      * @param declaringClass
159      * @return
160      */
161     public static StaticInitializerSignatureImpl newStaticInitializationSignature(final Class declaringClass) {
162         return new StaticInitializerSignatureImpl(declaringClass);
163     }
164     
165 }