| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.lang; |
| |
| import static org.apache.harmony.vm.ClassFormat.ACC_ANNOTATION; |
| import static org.apache.harmony.vm.ClassFormat.ACC_ENUM; |
| import static org.apache.harmony.vm.ClassFormat.ACC_INTERFACE; |
| import static org.apache.harmony.vm.ClassFormat.ACC_SYNTHETIC; |
| |
| import java.io.Externalizable; |
| import java.io.InputStream; |
| import java.io.Serializable; |
| import java.lang.annotation.Annotation; |
| import java.lang.annotation.Inherited; |
| import java.lang.ref.SoftReference; |
| import java.lang.reflect.AnnotatedElement; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.GenericDeclaration; |
| import java.lang.reflect.GenericSignatureFormatError; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.MalformedParameterizedTypeException; |
| import java.lang.reflect.Member; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.lang.reflect.Type; |
| import java.lang.reflect.TypeVariable; |
| import java.net.URL; |
| import java.security.AccessController; |
| import java.security.AllPermission; |
| import java.security.Permissions; |
| import java.security.PrivilegedAction; |
| import java.security.ProtectionDomain; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.LinkedHashSet; |
| import java.util.Map; |
| |
| import org.apache.harmony.lang.RuntimePermissionCollection; |
| import org.apache.harmony.lang.reflect.Reflection; |
| import org.apache.harmony.lang.reflect.parser.Parser; |
| import org.apache.harmony.vm.VMGenericsAndAnnotations; |
| import org.apache.harmony.vm.VMStack; |
| |
| /** |
| * Runtime representation of a class |
| * |
| * @author Evgueni Brevnov, Serguei S. Zapreyev, Alexey V. Varlamov |
| */ |
| public final class Class<T> implements Serializable, AnnotatedElement, GenericDeclaration, Type { |
| |
| /** |
| * Global/system assertion status |
| * |
| * package private to access from the java.lang.ClassLoader class. |
| */ |
| static volatile boolean disableAssertions = |
| VMExecutionEngine.getAssertionStatus(null, false, 0) <= 0; |
| |
| static ProtectionDomain systemDomain; |
| |
| private static final long serialVersionUID = 3206093459760846163L; |
| |
| private static final Class<Cloneable> CLONEABLE_CLASS = Cloneable.class; |
| @SuppressWarnings("unchecked") |
| private static final Class<Enum> ENUM_CLASS = Enum.class; |
| private static final Class<Externalizable> EXTERNALIZABLE_CLASS = Externalizable.class; |
| private static final Class<Inherited> INHERITED_CLASS = Inherited.class; |
| private static final Class<Object> OBJECT_CLASS = Object.class; |
| private static final Class<Serializable> SERIALIZABLE_CLASS = Serializable.class; |
| |
| |
| public static Class<?> forName(String name) throws ClassNotFoundException { |
| return forName(name, true, VMClassRegistry.getClassLoader(VMStack |
| .getCallerClass(0))); |
| } |
| |
| public static Class<?> forName(String name, boolean initialize, |
| ClassLoader classLoader) throws ClassNotFoundException { |
| if (name == null) { |
| throw new NullPointerException(); |
| } |
| if(name.indexOf("/") != -1) { |
| throw new ClassNotFoundException(name); |
| } |
| |
| Class<?> clazz = null; |
| |
| if (classLoader == null) { |
| SecurityManager sc = System.getSecurityManager(); |
| if (sc != null && |
| VMClassRegistry.getClassLoader(VMStack.getCallerClass(0)) != null) { |
| sc.checkPermission(RuntimePermissionCollection.GET_CLASS_LOADER_PERMISSION); |
| } |
| clazz = VMClassRegistry.loadBootstrapClass(name); |
| } else { |
| int dims = 0; |
| int len = name.length(); |
| while (dims < len && name.charAt(dims) == '[') dims++; |
| if (dims > 0 && len > dims + 1 |
| && name.charAt(dims) == 'L' && name.endsWith(";")) { |
| /* |
| * an array of a reference type is requested. |
| * do not care of arrays of primitives as |
| * they are perfectly loaded by bootstrap classloader. |
| */ |
| try { |
| clazz = classLoader.loadClass(name.substring(dims + 1, len - 1)); |
| } catch (ClassNotFoundException ignore) {} |
| if (clazz != null ) { |
| clazz = VMClassRegistry.loadArray(clazz, dims); |
| } |
| } else { |
| clazz = classLoader.loadClass(name); |
| } |
| } |
| if(clazz == null) { |
| throw new ClassNotFoundException(name); |
| } |
| if(classLoader != null) { |
| /* |
| * Although class loader may have had a chance to register itself as |
| * initiating for requested class, there may occur a classloader |
| * which overloads loadClass method (though it is not recommended by |
| * J2SE specification). Try to register initiating loader for clazz |
| * from here again |
| */ |
| classLoader.registerInitiatedClass(clazz); |
| } |
| if (initialize) { |
| VMClassRegistry.initializeClass(clazz); |
| } else { |
| VMClassRegistry.linkClass(clazz); |
| } |
| return clazz; |
| } |
| |
| /** |
| * VMI method |
| */ |
| static final Class<?>[] getStackClasses(int maxDepth, boolean stopAtPrivileged) { |
| return VMStack.getClasses(maxDepth, stopAtPrivileged); |
| } |
| |
| /** |
| * Answers whether the arrays are equal |
| */ |
| static boolean isTypeMatches(Class<?>[] t1, Class<?>[] t2) { |
| if (t1 == null) { |
| return t2 == null || t2.length == 0; |
| } |
| if (t2 == null) { |
| return t1 == null || t1.length == 0; |
| } |
| if (t1.length != t2.length) { |
| return false; |
| } |
| for (int i = 0; i < t2.length; i++) { |
| if (t1[i] != t2[i]) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private static Method findMatchingMethod(Method[] methods, |
| String methodName, Class<?>[] argumentTypes) |
| throws NoSuchMethodException { |
| Method matcher = null; |
| for (int i = 0; i < methods.length; i++) { |
| Method m = methods[i]; |
| if (matcher != null |
| && matcher.getDeclaringClass() != m.getDeclaringClass()) { |
| return matcher; |
| } |
| try { |
| if (methodName.equals(m.getName()) |
| && isTypeMatches(argumentTypes, m.getParameterTypes()) |
| && (matcher == null || matcher.getReturnType() |
| .isAssignableFrom(m.getReturnType()))) { |
| matcher = m; |
| } |
| } catch (LinkageError ignore) { |
| } |
| } |
| if (matcher == null) { |
| throw new NoSuchMethodException(methodName.toString() |
| + printMethodSignature(argumentTypes)); |
| } |
| return matcher; |
| } |
| |
| private static String getParentName(String name) { |
| int dotPosition = name.lastIndexOf('.'); |
| return dotPosition == -1 ? "" : name.substring(0, dotPosition); |
| } |
| |
| private static String printMethodSignature(Class<?>[] types) { |
| StringBuffer sb = new StringBuffer("("); |
| if (types != null && types.length > 0) { |
| sb.append(types[0] != null ? types[0].getName() : "null"); |
| for (int i = 1; i < types.length; i++) { |
| sb.append(", "); |
| sb.append(types[i] != null ? types[i].getName() : "null"); |
| } |
| } |
| sb.append(")"); |
| return sb.toString(); |
| } |
| |
| /** |
| * Provides strong referencing between the classloader |
| * and it's defined classes. Intended for class unloading implementation. |
| * @see java.lang.ClassLoader#loadedClasses |
| */ |
| ClassLoader definingLoader; |
| |
| transient SoftReference<GACache> softCache; |
| |
| private transient volatile ReflectionData _reflectionData; |
| |
| private transient ProtectionDomain domain; |
| |
| /** It is required for synchronization in newInstance method. */ |
| private volatile boolean isDefaultConstructorInitialized; |
| |
| /** |
| * Only VM can instantiate this class. |
| */ |
| private Class() { |
| } |
| |
| /** |
| * Accessor for the reflection data field, which needs to have |
| * minimal thread-safety for consistency; this method encapsulates |
| * that. |
| */ |
| private ReflectionData getReflectionData() { |
| // read the volatile field once |
| final ReflectionData localData = _reflectionData; |
| if (localData == null){ |
| // if null, construct, write to the field and return |
| return _reflectionData = new ReflectionData(); |
| } |
| // else, just return the field |
| return localData; |
| } |
| |
| private GACache getCache() { |
| GACache cache = null; |
| if (softCache != null) { |
| cache = softCache.get(); |
| } |
| if (cache == null) { |
| softCache = new SoftReference<GACache>(cache = new GACache()); |
| } |
| return cache; |
| } |
| |
| public boolean desiredAssertionStatus() { |
| if (disableAssertions) { |
| return false; |
| } |
| |
| ClassLoader loader = getClassLoaderImpl(); |
| if (loader == null) { |
| // system class, status is controlled via cmdline only |
| return VMExecutionEngine.getAssertionStatus(this, true, 0) > 0; |
| } |
| |
| // First check exact class name |
| String name = null; |
| Map<String, Boolean> m = loader.classAssertionStatus; |
| if (m != null && m.size() != 0) |
| { |
| name = getTopLevelClassName(); |
| Boolean status = m.get(name); |
| if (status != null) { |
| return status.booleanValue(); |
| } |
| } |
| if (!loader.clearAssertionStatus) { |
| int systemStatus = VMExecutionEngine.getAssertionStatus(this, false, 0); |
| if (systemStatus != 0) { |
| return systemStatus > 0; |
| } |
| } |
| |
| // Next try (super)packages name(s) recursively |
| m = loader.packageAssertionStatus; |
| if (m != null && m.size() != 0) { |
| if (name == null) { |
| name = getName(); |
| } |
| name = getParentName(name); |
| // if this class is in the default package, |
| // it is checked in the 1st iteration |
| do { |
| Boolean status = m.get(name); |
| if (status != null) { |
| return status.booleanValue(); |
| } |
| } while ( (name = getParentName(name)).length() > 0); |
| } |
| if (!loader.clearAssertionStatus) { |
| int systemStatus = VMExecutionEngine.getAssertionStatus(this, true, |
| loader.defaultAssertionStatus); |
| if (systemStatus != 0) { |
| return systemStatus > 0; |
| } |
| } |
| |
| // Finally check the default status |
| return loader.defaultAssertionStatus > 0; |
| } |
| |
| /** |
| * Note: We don't check member access permission for each super class. |
| * Java 1.5 API specification doesn't require this check. |
| */ |
| public Class[] getClasses() { |
| checkMemberAccess(Member.PUBLIC); |
| Class<?> clss = this; |
| ArrayList<Class<?>> classes = null; |
| while (clss != null) { |
| Class<?>[] declared = VMClassRegistry.getDeclaredClasses(clss); |
| if (declared.length != 0) { |
| if (classes == null) { |
| classes = new ArrayList<Class<?>>(); |
| } |
| for (Class<?> c : declared) { |
| if (Modifier.isPublic(c.getModifiers())) { |
| classes.add(c); |
| } |
| } |
| } |
| clss = clss.getSuperclass(); |
| } |
| if (classes == null) { |
| return new Class[0]; |
| } else { |
| return classes.toArray(new Class[classes.size()]); |
| } |
| } |
| |
| public ClassLoader getClassLoader() { |
| ClassLoader loader = getClassLoaderImpl(); |
| SecurityManager sc = System.getSecurityManager(); |
| if (sc != null) { |
| ClassLoader callerLoader = VMClassRegistry.getClassLoader(VMStack |
| .getCallerClass(0)); |
| if (callerLoader != null && !callerLoader.isSameOrAncestor(loader)) { |
| sc.checkPermission(RuntimePermissionCollection.GET_CLASS_LOADER_PERMISSION); |
| } |
| } |
| return loader; |
| } |
| |
| public Class<?> getComponentType() { |
| if (!isArray()) { |
| return null; |
| } |
| return VMClassRegistry.getComponentType(this); |
| } |
| |
| public Constructor<T> getConstructor(Class... argumentTypes) |
| throws NoSuchMethodException { |
| checkMemberAccess(Member.PUBLIC); |
| Constructor<T> ctors[] = getReflectionData().getPublicConstructors(); |
| for (int i = 0; i < ctors.length; i++) { |
| Constructor<T> c = ctors[i]; |
| try { |
| if (isTypeMatches(argumentTypes, c.getParameterTypes())) { |
| return Reflection.copyConstructor(c); |
| } |
| } catch (LinkageError ignore) {} |
| } |
| throw new NoSuchMethodException(getName() |
| + printMethodSignature(argumentTypes)); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Constructor[] getConstructors() { |
| checkMemberAccess(Member.PUBLIC); |
| return Reflection.copyConstructors(getReflectionData().getPublicConstructors()); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Class[] getDeclaredClasses() { |
| checkMemberAccess(Member.DECLARED); |
| return VMClassRegistry.getDeclaredClasses(this); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Constructor<T> getDeclaredConstructor(Class... argumentTypes) |
| throws NoSuchMethodException { |
| checkMemberAccess(Member.DECLARED); |
| return Reflection |
| .copyConstructor(getDeclaredConstructorInternal(argumentTypes)); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Constructor[] getDeclaredConstructors() { |
| checkMemberAccess(Member.DECLARED); |
| return Reflection.copyConstructors(getReflectionData().getDeclaredConstructors()); |
| } |
| |
| public Field getDeclaredField(String fieldName) throws NoSuchFieldException { |
| checkMemberAccess(Member.DECLARED); |
| final Field[] declaredFields = getReflectionData().getDeclaredFields(); |
| for (int i = 0; i < declaredFields.length; i++) { |
| Field f = declaredFields[i]; |
| if (fieldName.equals(f.getName())) { |
| return Reflection.copyField(f); |
| } |
| } |
| throw new NoSuchFieldException(fieldName.toString()); |
| } |
| |
| public Field[] getDeclaredFields() { |
| checkMemberAccess(Member.DECLARED); |
| return Reflection.copyFields(getReflectionData().getDeclaredFields()); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Method getDeclaredMethod(String methodName, Class... argumentTypes) |
| throws NoSuchMethodException { |
| checkMemberAccess(Member.DECLARED); |
| return Reflection |
| .copyMethod(findMatchingMethod(getReflectionData().getDeclaredMethods(), |
| methodName, argumentTypes)); |
| } |
| |
| public Method[] getDeclaredMethods() { |
| checkMemberAccess(Member.DECLARED); |
| return Reflection.copyMethods(getReflectionData().getDeclaredMethods()); |
| } |
| |
| public Class<?> getDeclaringClass() { |
| return VMClassRegistry.getDeclaringClass(this); |
| } |
| |
| public Field getField(String fieldName) throws NoSuchFieldException { |
| checkMemberAccess(Member.PUBLIC); |
| final Field[] fields = getReflectionData().getPublicFields(); |
| for (Field f : fields) { |
| if (fieldName.equals(f.getName())) { |
| return Reflection.copyField(f); |
| } |
| } |
| throw new NoSuchFieldException(fieldName.toString()); |
| } |
| |
| public Field[] getFields() { |
| checkMemberAccess(Member.PUBLIC); |
| return Reflection.copyFields(getReflectionData().getPublicFields()); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Class[] getInterfaces() { |
| return VMClassRegistry.getInterfaces(this); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Method getMethod(String methodName, Class... argumentTypes) |
| throws NoSuchMethodException { |
| checkMemberAccess(Member.PUBLIC); |
| return Reflection |
| .copyMethod(findMatchingMethod(getReflectionData().getPublicMethods(), |
| methodName, argumentTypes)); |
| } |
| |
| public Method[] getMethods() { |
| checkMemberAccess(Member.PUBLIC); |
| return Reflection.copyMethods(getReflectionData().getPublicMethods()); |
| } |
| |
| public int getModifiers() { |
| return getReflectionData().getModifiers(); |
| } |
| |
| public String getName() { |
| return getReflectionData().name; |
| } |
| |
| public Package getPackage() { |
| ClassLoader classLoader = getClassLoaderImpl(); |
| return classLoader == null |
| ? ClassLoader.BootstrapLoader.getPackage(getPackageName()) |
| : classLoader.getPackage(getPackageName()); |
| } |
| |
| public ProtectionDomain getProtectionDomain() { |
| SecurityManager sc = System.getSecurityManager(); |
| if (sc != null) { |
| sc.checkPermission( |
| RuntimePermissionCollection.GET_PROTECTION_DOMAIN_PERMISSION); |
| } |
| if (domain == null) { |
| if (systemDomain == null) { |
| Permissions allPermissions = new Permissions(); |
| allPermissions.add(new AllPermission()); |
| systemDomain = new ProtectionDomain(null, allPermissions); |
| } |
| return systemDomain; |
| } |
| return domain; |
| } |
| |
| public URL getResource(String resource) { |
| resource = getAbsoluteResource(resource); |
| ClassLoader classLoader = getClassLoaderImpl(); |
| return classLoader == null |
| ? ClassLoader.getSystemResource(resource) |
| : classLoader.getResource(resource); |
| } |
| |
| public InputStream getResourceAsStream(String resource) { |
| resource = getAbsoluteResource(resource); |
| ClassLoader classLoader = getClassLoaderImpl(); |
| return classLoader == null |
| ? ClassLoader.getSystemResourceAsStream(resource) |
| : classLoader.getResourceAsStream(resource); |
| } |
| |
| public Object[] getSigners() { |
| try { |
| Object[] signers = (Object[])getClassLoaderImpl().classSigners.get(getName()); |
| return (Object[])signers.clone(); |
| } catch (NullPointerException e) { |
| } |
| try { |
| return (Object[])domain.getCodeSource().getCertificates().clone(); |
| } catch (NullPointerException e) { |
| } |
| return null; |
| } |
| |
| public Class<? super T> getSuperclass() { |
| return VMClassRegistry.getSuperclass(this); |
| } |
| |
| public boolean isArray() { |
| return getReflectionData().isArray; |
| } |
| |
| public boolean isAssignableFrom(Class<?> clazz) { |
| |
| if (SERIALIZABLE_CLASS.equals(this)) { |
| return clazz.getReflectionData().isSerializable(); |
| } |
| |
| if (EXTERNALIZABLE_CLASS.equals(this)) { |
| return clazz.getReflectionData().isExternalizable(); |
| } |
| |
| return VMClassRegistry.isAssignableFrom(this, clazz); |
| } |
| |
| public boolean isInstance(Object obj) { |
| return VMClassRegistry.isInstance(this, obj); |
| } |
| |
| public boolean isInterface() { |
| return (getModifiers() & ACC_INTERFACE) != 0; |
| } |
| |
| public boolean isPrimitive() { |
| return getReflectionData().isPrimitive; |
| } |
| |
| public T newInstance() throws InstantiationException, |
| IllegalAccessException { |
| T newInstance = null; |
| final ReflectionData localReflectionData = getReflectionData(); |
| SecurityManager sc = System.getSecurityManager(); |
| if (sc != null) { |
| sc.checkMemberAccess(this, Member.PUBLIC); |
| sc.checkPackageAccess(localReflectionData.packageName); |
| } |
| |
| /* |
| * HARMONY-1930: The synchronization issue is possible here. |
| * |
| * The issues is caused by fact that: |
| * - first thread starts defaultConstructor initialization, including |
| * setting "isAccessible" flag to "true" for Constrcutor object |
| * - another thread bypasses initialization and calls "newInstance" |
| * for defaultConstructor (while isAccessible is "false" yet) |
| * - so, for this "another" thread the Constructor.newInstance checks |
| * the access rights by mistake and IllegalAccessException happens |
| */ |
| while (!isDefaultConstructorInitialized) { |
| synchronized (localReflectionData) { |
| if (isDefaultConstructorInitialized) { |
| break; // non-first threads can be here - nothing to do |
| } |
| |
| // only first thread can reach this point & do initialization |
| final Constructor<T> c; |
| try { |
| c = localReflectionData.getDefaultConstructor(); |
| } catch (NoSuchMethodException e) { |
| throw new InstantiationException(e.getMessage() |
| + " method not found"); |
| } |
| try { |
| AccessController.doPrivileged(new PrivilegedAction<Object>() { |
| public Object run() { |
| c.setAccessible(true); |
| return null; |
| } |
| }); |
| } catch (SecurityException e) { |
| // can't change accessibility of the default constructor |
| IllegalAccessException ex = new IllegalAccessException(); |
| ex.initCause(e); |
| throw ex; |
| } |
| |
| // default constructor is initialized, access flag is set |
| isDefaultConstructorInitialized = true; |
| break; |
| } |
| } |
| |
| // initialization is done, threads may work from here in any order |
| final Constructor<T> defaultConstructor; |
| try { |
| defaultConstructor = localReflectionData.getDefaultConstructor(); |
| } catch (NoSuchMethodException e){ |
| throw new AssertionError(e); |
| } |
| Reflection.checkMemberAccess( |
| VMStack.getCallerClass(0), |
| defaultConstructor.getDeclaringClass(), |
| defaultConstructor.getDeclaringClass(), |
| defaultConstructor.getModifiers() |
| ); |
| |
| try { |
| newInstance = defaultConstructor.newInstance(); |
| } catch (InvocationTargetException e) { |
| System.rethrow(e.getCause()); |
| } |
| return newInstance; |
| } |
| |
| @Override |
| public String toString() { |
| return isPrimitive() ? getName() |
| : (isInterface() ? "interface " : "class ") + getName(); |
| } |
| |
| String getPackageName() { |
| return getReflectionData().packageName; |
| } |
| |
| void setProtectionDomain(ProtectionDomain protectionDomain) { |
| domain = protectionDomain; |
| } |
| |
| private void checkMemberAccess(int accessType) { |
| SecurityManager sc = System.getSecurityManager(); |
| if (sc != null) { |
| sc.checkMemberAccess(this, accessType); |
| sc.checkPackageAccess(getReflectionData().packageName); |
| } |
| } |
| |
| private String getAbsoluteResource(String resource) { |
| if (resource.startsWith("/")) { |
| return resource.substring(1); |
| } |
| String pkgName = getPackageName(); |
| if (pkgName.length() > 0) { |
| resource = pkgName.replace('.', '/') + '/' + resource; |
| } |
| return resource; |
| } |
| |
| private Constructor<T> getDeclaredConstructorInternal(Class<?>[] argumentTypes) |
| throws NoSuchMethodException { |
| final Constructor<T>[] declaredConstructors = getReflectionData().getDeclaredConstructors(); |
| for (int i = 0; i < declaredConstructors.length; i++) { |
| Constructor<T> c = declaredConstructors[i]; |
| if (isTypeMatches(argumentTypes, c.getParameterTypes())) { |
| return c; |
| } |
| } |
| throw new NoSuchMethodException(getName() |
| + printMethodSignature(argumentTypes)); |
| } |
| |
| private String getTopLevelClassName() { |
| Class<?> declaringClass = getDeclaringClass(); |
| return declaringClass == null |
| ? getName() : declaringClass.getTopLevelClassName(); |
| } |
| |
| /** |
| * VMI method |
| */ |
| final ClassLoader getClassLoaderImpl() { |
| assert(VMClassRegistry.getClassLoader0(this) == definingLoader); |
| return definingLoader; |
| } |
| |
| public Annotation[] getDeclaredAnnotations() { |
| Annotation[] declared = getCache().getDeclaredAnnotations(); |
| Annotation aa[] = new Annotation[declared.length]; |
| System.arraycopy(declared, 0, aa, 0, declared.length); |
| return aa; |
| } |
| |
| public Annotation[] getAnnotations() { |
| Annotation[] all = getCache().getAllAnnotations(); |
| Annotation aa[] = new Annotation[all.length]; |
| System.arraycopy(all, 0, aa, 0, all.length); |
| return aa; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public <A extends Annotation> A getAnnotation(Class<A> annotationClass) { |
| if(annotationClass == null) { |
| throw new NullPointerException(); |
| } |
| for (Annotation aa : getCache().getAllAnnotations()) { |
| if(annotationClass == aa.annotationType()) { |
| return (A)aa; |
| } |
| } |
| return null; |
| } |
| |
| public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) { |
| if(annotationClass == null) { |
| throw new NullPointerException(); |
| } |
| for (Annotation aa : getCache().getAllAnnotations()) { |
| if(annotationClass == aa.annotationType()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public T[] getEnumConstants() { |
| if (isEnum()) { |
| try { |
| final Method values = getMethod("values"); |
| AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| values.setAccessible(true); |
| return null; |
| } |
| }); |
| return (T[]) values.invoke(null); |
| } catch (Exception ignore) {} |
| } |
| return null; |
| } |
| |
| public boolean isEnum() { |
| // check for superclass is needed for compatibility |
| // otherwise there are false positives on anonymous element classes |
| return ((getModifiers() & ACC_ENUM) != 0 && getSuperclass() == ENUM_CLASS); |
| } |
| |
| public boolean isAnnotation() { |
| return (getModifiers() & ACC_ANNOTATION) != 0; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public <U> Class<? extends U> asSubclass(Class<U> clazz) throws ClassCastException { |
| if (!VMClassRegistry.isAssignableFrom(clazz, this)) { |
| throw new ClassCastException(toString()); |
| } |
| |
| return (Class<? extends U>)this; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public T cast(Object obj) throws ClassCastException { |
| if (obj != null && !VMClassRegistry.isInstance(this, obj)) { |
| throw new ClassCastException(obj.getClass().toString()); |
| } |
| return (T) obj; |
| } |
| |
| public TypeVariable<Class<T>>[] getTypeParameters() throws GenericSignatureFormatError { |
| return (TypeVariable<Class<T>>[])getCache().getTypeParameters().clone(); |
| } |
| |
| public Method getEnclosingMethod() { |
| Member m = VMClassRegistry.getEnclosingMember(this); // see VMClassRegistry.getEnclosingMember() spec |
| return m instanceof Method? (Method)m : null; |
| } |
| |
| public Constructor<?> getEnclosingConstructor() { |
| Member m = VMClassRegistry.getEnclosingMember(this); // see VMClassRegistry.getEnclosingMember() spec |
| return m instanceof Constructor ? (Constructor<?>)m : null; |
| } |
| |
| public Type[] getGenericInterfaces() throws GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException { |
| if (isArray()) { |
| return new Type[]{CLONEABLE_CLASS, SERIALIZABLE_CLASS}; |
| } |
| if (isPrimitive()) { |
| return new Type[0]; |
| } |
| |
| return (Type[])getCache().getGenericInterfaces().clone(); |
| } |
| |
| public Type getGenericSuperclass() throws GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException { |
| String tmp; |
| if (isInterface() || ((tmp = getCanonicalName()) != null && tmp.equals("java.lang.Object")) || isPrimitive()) { |
| return null; |
| } |
| if (isArray()) { |
| return (Type) OBJECT_CLASS; |
| } |
| |
| Class<?> clazz = getSuperclass(); |
| if (clazz.getTypeParameters().length == 0) { |
| return (Type) clazz; |
| } |
| |
| return getCache().getGenericSuperclass(); |
| } |
| |
| public Class<?> getEnclosingClass() { |
| return VMClassRegistry.getEnclosingClass(this); // see VMClassRegistry.getEnclosingClass() spec |
| } |
| |
| public boolean isMemberClass() { |
| return getDeclaringClass() != null; // see Class.getDeclaringClass() spec |
| } |
| |
| public boolean isLocalClass() { |
| return VMClassRegistry.getEnclosingMember(this) != null && !isAnonymousClass(); // see CFF spec, #4.8.6, first paragraph and VMClassRegistry.getEnclosingMember() spec |
| } |
| |
| |
| public boolean isAnonymousClass() { |
| return getSimpleName().length() == 0; |
| } |
| |
| public boolean isSynthetic() { |
| return (getModifiers() & ACC_SYNTHETIC) != 0; |
| } |
| |
| public String getCanonicalName() { |
| if (isLocalClass() || isAnonymousClass()) { |
| return null; |
| } |
| if (isArray()) { |
| String res = getComponentType().getCanonicalName(); |
| return res != null ? res + "[]" : null; |
| } |
| |
| StringBuffer sb = new StringBuffer(getPackageName()); |
| ArrayList<String> sympleNames = new ArrayList<String>(); |
| Class<?> clss = this; |
| while ((clss = clss.getDeclaringClass()) != null) { |
| if (clss.isLocalClass() || clss.isAnonymousClass()) { |
| return null; |
| } |
| sympleNames.add(clss.getSimpleName()); |
| } |
| if (sb.length() > 0) { |
| sb.append("."); |
| } |
| for (int i = sympleNames.size() - 1; i > -1 ; i--) { |
| sb.append(sympleNames.get(i)).append("."); |
| } |
| sb.append(getSimpleName()); |
| |
| return sb.toString(); |
| } |
| |
| public String getSimpleName() { |
| return VMClassRegistry.getSimpleName(this); |
| } |
| |
| private final class ReflectionData { |
| |
| final String packageName; |
| final String name; |
| final boolean isPrimitive; |
| final boolean isArray; |
| |
| /* |
| * Do no access the following fields directly from enclosing class; |
| * use the accessor methods |
| */ |
| private volatile int _modifiers; |
| private volatile Constructor<T>[] _declaredConstructors; |
| private volatile Field[] _declaredFields; |
| private volatile Method[] _declaredMethods; |
| private volatile Constructor<T> _defaultConstructor; |
| private volatile Constructor<T>[] _publicConstructors; |
| private volatile Field[] _publicFields; |
| private volatile Method[] _publicMethods; |
| |
| private volatile boolean _serialPropsResolved; |
| private boolean _isExternalizable; |
| private boolean _isSerializable; |
| |
| ReflectionData() { |
| name = VMClassRegistry.getName(Class.this); |
| isPrimitive = VMClassRegistry.isPrimitive(Class.this); |
| isArray = VMClassRegistry.isArray(Class.this); |
| packageName = Class.getParentName(name); |
| _modifiers = -1; |
| } |
| |
| boolean isSerializable(){ |
| resolveSerialProps(); |
| return _isSerializable; |
| } |
| |
| boolean isExternalizable() { |
| resolveSerialProps(); |
| return _isExternalizable; |
| } |
| |
| private void resolveSerialProps() { |
| if (!_serialPropsResolved){ |
| _isExternalizable = VMClassRegistry.isAssignableFrom(EXTERNALIZABLE_CLASS, Class.this); |
| _isSerializable = VMClassRegistry.isAssignableFrom(SERIALIZABLE_CLASS, Class.this); |
| _serialPropsResolved = true; |
| } |
| } |
| |
| int getModifiers() { |
| final int localCopy = _modifiers; |
| if (localCopy != -1){ |
| return localCopy; |
| } |
| return _modifiers = VMClassRegistry.getModifiers(Class.this); |
| } |
| |
| Constructor<T>[] getDeclaredConstructors() { |
| final Constructor<T>[] localCopy = _declaredConstructors; |
| if (localCopy != null) { |
| return localCopy; |
| } |
| return _declaredConstructors = VMClassRegistry.getDeclaredConstructors(Class.this); |
| } |
| |
| Field[] getDeclaredFields() { |
| final Field[] localCopy = _declaredFields; |
| if (localCopy == null) { |
| return _declaredFields = VMClassRegistry |
| .getDeclaredFields(Class.this); |
| } else { |
| return localCopy; |
| } |
| } |
| |
| Method[] getDeclaredMethods() { |
| final Method[] localCopy = _declaredMethods; |
| if (localCopy != null) { |
| return localCopy; |
| } |
| return _declaredMethods = VMClassRegistry.getDeclaredMethods(Class.this); |
| } |
| |
| Constructor<T> getDefaultConstructor() throws NoSuchMethodException { |
| final Constructor<T> localCopy = _defaultConstructor; |
| if (localCopy != null) { |
| return localCopy; |
| } |
| return _defaultConstructor = Class.this.getDeclaredConstructorInternal(null); |
| } |
| |
| Constructor<T>[] getPublicConstructors() { |
| final Constructor<T>[] localCopy = _publicConstructors; |
| if (localCopy != null) { |
| return localCopy; |
| } |
| |
| final Constructor<T>[] declaredConstructors = getDeclaredConstructors(); |
| ArrayList<Constructor<T>> constructors = new ArrayList<Constructor<T>>( |
| declaredConstructors.length); |
| for (int i = 0; i < declaredConstructors.length; i++) { |
| Constructor<T> c = declaredConstructors[i]; |
| if (Modifier.isPublic(c.getModifiers())) { |
| constructors.add(c); |
| } |
| } |
| final int size = constructors.size(); |
| @SuppressWarnings("unchecked") |
| final Constructor<T>[] tempArray = (Constructor<T>[]) new Constructor[size]; |
| return _publicConstructors = constructors.toArray(tempArray); |
| } |
| |
| /** |
| * Stores public fields in order they should be searched by |
| * getField(name) method. |
| */ |
| public synchronized Field[] getPublicFields() { |
| final Field[] localCopy = _publicFields; |
| if (localCopy != null) { |
| return localCopy; |
| } |
| |
| final Field[] declaredFields = getDeclaredFields(); |
| |
| // initialize public fields of the super class |
| int size = declaredFields.length; |
| Class<?> superClass = Class.this.getSuperclass(); |
| Field[] superFields = null; |
| if (superClass != null) { |
| final Class<?>.ReflectionData superClassRefData = superClass.getReflectionData(); |
| superFields = superClassRefData.getPublicFields(); |
| size += superFields.length; |
| } |
| |
| // add public fields of this class |
| Collection<Field> fields = new LinkedHashSet<Field>(size); |
| for (Field f : declaredFields) { |
| if (Modifier.isPublic(f.getModifiers())) { |
| fields.add(f); |
| } |
| } |
| |
| // initialize and add fields of the super interfaces |
| Class<?>[] interfaces = Class.this.getInterfaces(); |
| for (Class<?> ci : interfaces) { |
| final Class<?>.ReflectionData ciRefData = ci.getReflectionData(); |
| Field[] fi = ciRefData.getPublicFields(); |
| for (Field f : fi) { |
| fields.add(f); |
| } |
| } |
| |
| // add public fields of the super class |
| if (superFields != null) { |
| for (Field f : superFields) { |
| if (Modifier.isPublic(f.getModifiers())) { |
| fields.add(f); |
| } |
| } |
| } |
| |
| return _publicFields = fields.toArray(new Field[fields.size()]); |
| } |
| |
| public synchronized Method[] getPublicMethods() { |
| final Method[] localCopy = _publicMethods; |
| if (localCopy != null) { |
| return localCopy; |
| } |
| |
| final Method[] declaredMethods = getDeclaredMethods(); |
| |
| // initialize public methods of the super class |
| int size = declaredMethods.length; |
| Class<?> superClass = Class.this.getSuperclass(); |
| Method[] superPublic = null; |
| if (superClass != null) { |
| final Class<?>.ReflectionData superClassRefData = superClass.getReflectionData(); |
| superPublic = superClassRefData.getPublicMethods(); |
| size += superPublic.length; |
| } |
| |
| // add methods of the super interfaces |
| Class<?>[] interfaces = Class.this.getInterfaces(); |
| Method[][] intf = null; |
| if (interfaces.length != 0) { |
| intf = new Method[interfaces.length][]; |
| for (int i = 0; i < interfaces.length; i++) { |
| Class<?> ci = interfaces[i]; |
| final Class<?>.ReflectionData ciRefData = ci.getReflectionData(); |
| intf[i] = ciRefData.getPublicMethods(); |
| size += intf[i].length; |
| } |
| } |
| return _publicMethods = Reflection.mergePublicMethods(declaredMethods, superPublic, intf, size); |
| } |
| } |
| |
| private final class GACache { |
| |
| private Annotation[] allAnnotations; |
| private Annotation[] declaredAnnotations; |
| private Type[] genericInterfaces; |
| private Type genericSuperclass; |
| private TypeVariable<Class<T>>[] typeParameters; |
| |
| public synchronized Annotation[] getAllAnnotations() { |
| if (allAnnotations != null) { |
| return allAnnotations; |
| } |
| if (declaredAnnotations == null) { |
| declaredAnnotations = VMGenericsAndAnnotations |
| .getDeclaredAnnotations(Class.this); |
| } |
| |
| // look for inherited annotations |
| Class<?> superClass = Class.this.getSuperclass(); |
| if (superClass != null) { |
| Annotation[] sa = superClass.getCache().getAllAnnotations(); |
| if (sa.length != 0) { |
| final int size = declaredAnnotations.length; |
| Annotation[] all = new Annotation[size + sa.length]; |
| System.arraycopy(declaredAnnotations, 0, all, 0, size); |
| int pos = size; |
| next: for (Annotation s : sa) { |
| if (s.annotationType().isAnnotationPresent(INHERITED_CLASS)) { |
| for (int i = 0; i < size; i++) { |
| if (all[i].annotationType() == s.annotationType()) { |
| // overriden by declared annotation |
| continue next; |
| } |
| } |
| all[pos++] = s; |
| } |
| } |
| allAnnotations = new Annotation[pos]; |
| System.arraycopy(all, 0, allAnnotations, 0, pos); |
| return allAnnotations; |
| } |
| } |
| return allAnnotations = declaredAnnotations; |
| } |
| |
| public Annotation[] getDeclaredAnnotations() { |
| if (declaredAnnotations == null) { |
| declaredAnnotations = VMGenericsAndAnnotations |
| .getDeclaredAnnotations(Class.this); |
| } |
| return declaredAnnotations; |
| } |
| |
| public synchronized Type[] getGenericInterfaces() { |
| if (genericInterfaces == null) { |
| genericInterfaces = Parser.getGenericInterfaces(Class.this, VMGenericsAndAnnotations.getSignature(Class.this)); |
| } |
| return genericInterfaces; |
| } |
| |
| public Type getGenericSuperclass() { |
| //So, here it can be only ParameterizedType or ordinary reference class type |
| if (genericSuperclass == null) { |
| genericSuperclass = Parser.getGenericSuperClass(Class.this, VMGenericsAndAnnotations.getSignature(Class.this)); |
| } |
| return genericSuperclass; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public synchronized TypeVariable<Class<T>>[] getTypeParameters() { |
| if(typeParameters == null){ |
| typeParameters = Parser.getTypeParameters(Class.this, |
| VMGenericsAndAnnotations.getSignature(Class.this)); |
| } |
| return typeParameters; |
| } |
| } |
| } |
