KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > aspectwerkz > reflect > impl > java > JavaConstructorInfo


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.ConstructorInfo;
13 import org.codehaus.aspectwerkz.reflect.ReflectHelper;
14 import org.codehaus.aspectwerkz.reflect.ReflectHelper;
15
16 import java.lang.reflect.Constructor JavaDoc;
17 import java.util.List JavaDoc;
18
19 /**
20  * Implementation of the ConstructorInfo interface for java.lang.reflect.*.
21  *
22  * @author <a HREF="mailto:jboner@codehaus.org">Jonas Bonér </a>
23  */

24 public class JavaConstructorInfo extends JavaMemberInfo implements ConstructorInfo {
25     /**
26      * A list with the parameter types.
27      */

28     private ClassInfo[] m_parameterTypes = null;
29
30     /**
31      * A list with the exception types.
32      */

33     private ClassInfo[] m_exceptionTypes = null;
34
35     /**
36      * The signature of the class.
37      */

38     private String JavaDoc m_signature;
39
40     /**
41      * Creates a new method meta data instance.
42      *
43      * @param constructor
44      * @param declaringType
45      */

46     JavaConstructorInfo(final Constructor JavaDoc constructor, final JavaClassInfo declaringType) {
47         super(constructor, declaringType);
48         m_signature = ReflectHelper.getConstructorSignature(constructor);
49     }
50
51     /**
52      * Returns the constructor info for the constructor specified.
53      *
54      * @param constructor the constructor
55      * @return the constructor info
56      */

57     public static ConstructorInfo getConstructorInfo(final Constructor JavaDoc constructor) {
58         Class JavaDoc declaringClass = constructor.getDeclaringClass();
59         JavaClassInfoRepository repository = JavaClassInfoRepository.getRepository(declaringClass.getClassLoader());
60         ClassInfo classInfo = repository.getClassInfo(declaringClass.getName());
61         if (classInfo == null) {
62             classInfo = JavaClassInfo.getClassInfo(declaringClass);
63         }
64         return classInfo.getConstructor(ReflectHelper.calculateHash(constructor));
65     }
66
67     /**
68      * Returns the signature for the element.
69      *
70      * @return the signature for the element
71      */

72     public String JavaDoc getSignature() {
73         return m_signature;
74     }
75
76     /**
77      * Returns the attributes.
78      *
79      * @return the attributes
80      * @TODO: fix constructor annotations
81      */

82     public List JavaDoc getAnnotations() {
83         if (m_annotations == null) {
84             m_annotations = Annotations.getAnnotationInfos((Constructor JavaDoc) m_member);
85         }
86         return m_annotations;
87     }
88
89     /**
90      * Returns the parameter types.
91      *
92      * @return the parameter types
93      */

94     public ClassInfo[] getParameterTypes() {
95         if (m_parameterTypes == null) {
96             Class JavaDoc[] parameterTypes = ((Constructor JavaDoc) m_member).getParameterTypes();
97             m_parameterTypes = new ClassInfo[parameterTypes.length];
98             for (int i = 0; i < parameterTypes.length; i++) {
99                 Class JavaDoc parameterType = parameterTypes[i];
100                 ClassInfo metaData;
101                 if (m_classInfoRepository.hasClassInfo(parameterType.getName())) {
102                     metaData = m_classInfoRepository.getClassInfo(parameterType.getName());
103                 } else {
104                     metaData = JavaClassInfo.getClassInfo(parameterType);
105                     m_classInfoRepository.addClassInfo(metaData);
106                 }
107                 m_parameterTypes[i] = metaData;
108             }
109         }
110         return m_parameterTypes;
111     }
112
113     /**
114      * Returns the exception types.
115      *
116      * @return the exception types
117      */

118     public ClassInfo[] getExceptionTypes() {
119         if (m_exceptionTypes == null) {
120             Class JavaDoc[] exceptionTypes = ((Constructor JavaDoc) m_member).getExceptionTypes();
121             m_exceptionTypes = new ClassInfo[exceptionTypes.length];
122             for (int i = 0; i < exceptionTypes.length; i++) {
123                 Class JavaDoc exceptionType = exceptionTypes[i];
124                 ClassInfo metaData;
125                 if (m_classInfoRepository.hasClassInfo(exceptionType.getName())) {
126                     metaData = m_classInfoRepository.getClassInfo(exceptionType.getName());
127                 } else {
128                     metaData = JavaClassInfo.getClassInfo(exceptionType);
129                     m_classInfoRepository.addClassInfo(metaData);
130                 }
131                 m_exceptionTypes[i] = metaData;
132             }
133         }
134         return m_exceptionTypes;
135     }
136
137     public boolean equals(Object JavaDoc o) {
138         if (this == o) {
139             return true;
140         }
141         if (!(o instanceof ConstructorInfo)) {
142             return false;
143         }
144         ConstructorInfo constructorInfo = (ConstructorInfo) o;
145         if (!m_declaringType.getName().equals(constructorInfo.getDeclaringType().getName())) {
146             return false;
147         }
148         if (!m_member.getName().equals(constructorInfo.getName())) {
149             return false;
150         }
151         Class JavaDoc[] parameterTypes1 = ((Constructor JavaDoc) m_member).getParameterTypes();
152         ClassInfo[] parameterTypes2 = constructorInfo.getParameterTypes();
153         if (parameterTypes1.length != parameterTypes2.length) {
154             return false;
155         }
156         for (int i = 0; i < parameterTypes1.length; i++) {
157             if (!parameterTypes1[i].getName().equals(parameterTypes2[i].getName())) {
158                 return false;
159             }
160         }
161         return true;
162     }
163
164     public int hashCode() {
165         int result = 29;
166         result = (29 * result) + m_declaringType.getName().hashCode();
167         result = (29 * result) + m_member.getName().hashCode();
168         Class JavaDoc[] parameterTypes = ((Constructor JavaDoc) m_member).getParameterTypes();
169         for (int i = 0; i < parameterTypes.length; i++) {
170             result = (29 * result) + parameterTypes[i].getName().hashCode();
171         }
172         return result;
173     }
174 }
Popular Tags