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;
17 import java.util.List;
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 m_signature;
39
40 /***
41 * Creates a new method meta data instance.
42 *
43 * @param constructor
44 * @param declaringType
45 */
46 JavaConstructorInfo(final Constructor 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 constructor) {
58 Class 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 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 getAnnotations() {
83 if (m_annotations == null) {
84 m_annotations = Annotations.getAnnotationInfos((Constructor) 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[] parameterTypes = ((Constructor) m_member).getParameterTypes();
97 m_parameterTypes = new ClassInfo[parameterTypes.length];
98 for (int i = 0; i < parameterTypes.length; i++) {
99 Class 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[] exceptionTypes = ((Constructor) m_member).getExceptionTypes();
121 m_exceptionTypes = new ClassInfo[exceptionTypes.length];
122 for (int i = 0; i < exceptionTypes.length; i++) {
123 Class 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 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[] parameterTypes1 = ((Constructor) 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[] parameterTypes = ((Constructor) 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 }