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 }