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.reflect.impl.java;
9   
10  import org.codehaus.aspectwerkz.annotation.Annotations;
11  import org.codehaus.aspectwerkz.reflect.ClassInfo;
12  import org.codehaus.aspectwerkz.reflect.MethodInfo;
13  import org.codehaus.aspectwerkz.transform.ReflectHelper;
14  
15  import java.lang.reflect.Method;
16  import java.util.List;
17  
18  /***
19   * Implementation of the MethodInfo interface for java.lang.reflect.*.
20   * 
21   * @author <a href="mailto:jboner@codehaus.org">Jonas Bonér </a>
22   */
23  public class JavaMethodInfo extends JavaMemberInfo implements MethodInfo {
24      /***
25       * The return type.
26       */
27      private ClassInfo m_returnType = null;
28  
29      /***
30       * A list with the parameter types.
31       */
32      private ClassInfo[] m_parameterTypes = null;
33  
34      /***
35       * A list with the exception types.
36       */
37      private ClassInfo[] m_exceptionTypes = null;
38  
39      /***
40       * Creates a new method meta data instance.
41       * 
42       * @param method
43       * @param declaringType
44       */
45      JavaMethodInfo(final Method method, final JavaClassInfo declaringType) {
46          super(method, declaringType);
47      }
48  
49      /***
50       * Returns the method info for the method specified.
51       * 
52       * @param method the method
53       * @return the method info
54       */
55      public static MethodInfo getMethodInfo(final Method method) {
56          Class declaringClass = method.getDeclaringClass();
57          JavaClassInfoRepository repository = JavaClassInfoRepository.getRepository(declaringClass.getClassLoader());
58          ClassInfo classInfo = repository.getClassInfo(declaringClass.getName());
59          if (classInfo == null) {
60              classInfo = JavaClassInfo.getClassInfo(declaringClass);
61          }
62          return classInfo.getMethod(ReflectHelper.calculateHash(method));
63      }
64  
65      /***
66       * Returns the annotations.
67       * 
68       * @return the annotations
69       */
70      public List getAnnotations() {
71          if (m_annotations == null) {
72              m_annotations = Annotations.getAnnotationInfos((Method) m_member);
73          }
74          return m_annotations;
75      }
76  
77      /***
78       * Returns the return type.
79       * 
80       * @return the return type
81       */
82      public ClassInfo getReturnType() {
83          if (m_returnType == null) {
84              Class returnTypeClass = ((Method) m_member).getReturnType();
85              if (m_classInfoRepository.hasClassInfo(returnTypeClass.getName())) {
86                  m_returnType = m_classInfoRepository.getClassInfo(returnTypeClass.getName());
87              } else {
88                  m_returnType = JavaClassInfo.getClassInfo(returnTypeClass);
89                  m_classInfoRepository.addClassInfo(m_returnType);
90              }
91          }
92          return m_returnType;
93      }
94  
95      /***
96       * Returns the parameter types.
97       * 
98       * @return the parameter types
99       */
100     public ClassInfo[] getParameterTypes() {
101         if (m_parameterTypes == null) {
102             Class[] parameterTypes = ((Method) m_member).getParameterTypes();
103             m_parameterTypes = new ClassInfo[parameterTypes.length];
104             for (int i = 0; i < parameterTypes.length; i++) {
105                 Class parameterType = parameterTypes[i];
106                 ClassInfo metaData;
107                 if (m_classInfoRepository.hasClassInfo(parameterType.getName())) {
108                     metaData = m_classInfoRepository.getClassInfo(parameterType.getName());
109                 } else {
110                     metaData = JavaClassInfo.getClassInfo(parameterType);
111                     m_classInfoRepository.addClassInfo(metaData);
112                 }
113                 m_parameterTypes[i] = metaData;
114             }
115         }
116         return m_parameterTypes;
117     }
118 
119     /***
120      * Returns the exception types.
121      * 
122      * @return the exception types
123      */
124     public ClassInfo[] getExceptionTypes() {
125         if (m_exceptionTypes == null) {
126             Class[] exceptionTypes = ((Method) m_member).getExceptionTypes();
127             m_exceptionTypes = new ClassInfo[exceptionTypes.length];
128             for (int i = 0; i < exceptionTypes.length; i++) {
129                 Class exceptionType = exceptionTypes[i];
130                 ClassInfo metaData;
131                 if (m_classInfoRepository.hasClassInfo(exceptionType.getName())) {
132                     metaData = m_classInfoRepository.getClassInfo(exceptionType.getName());
133                 } else {
134                     metaData = JavaClassInfo.getClassInfo(exceptionType);
135                     m_classInfoRepository.addClassInfo(metaData);
136                 }
137                 m_exceptionTypes[i] = metaData;
138             }
139         }
140         return m_exceptionTypes;
141     }
142 
143     public boolean equals(Object o) {
144         if (this == o) {
145             return true;
146         }
147         if (!(o instanceof MethodInfo)) {
148             return false;
149         }
150         MethodInfo methodInfo = (MethodInfo) o;
151         if (!m_declaringType.getName().equals(methodInfo.getDeclaringType().getName())) {
152             return false;
153         }
154         if (!m_member.getName().equals(methodInfo.getName())) {
155             return false;
156         }
157         Class[] parameterTypes1 = ((Method) m_member).getParameterTypes();
158         ClassInfo[] parameterTypes2 = methodInfo.getParameterTypes();
159         if (parameterTypes1.length != parameterTypes2.length) {
160             return false;
161         }
162         for (int i = 0; i < parameterTypes1.length; i++) {
163             if (!parameterTypes1[i].getName().equals(parameterTypes2[i].getName())) {
164                 return false;
165             }
166         }
167         return true;
168     }
169 
170     public int hashCode() {
171         int result = 29;
172         result = (29 * result) + m_declaringType.getName().hashCode();
173         result = (29 * result) + m_member.getName().hashCode();
174         Class[] parameterTypes = ((Method) m_member).getParameterTypes();
175         for (int i = 0; i < parameterTypes.length; i++) {
176             result = (29 * result) + parameterTypes[i].getName().hashCode();
177         }
178         return result;
179     }
180 
181     public String toString() {
182         return m_member.toString();
183     }
184 }