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