| /* |
| * 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 org.apache.brooklyn.util.javalang; |
| |
| import static com.google.common.base.Preconditions.checkNotNull; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.lang.reflect.Array; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.net.URL; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashSet; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.Stack; |
| |
| import javax.annotation.Nullable; |
| |
| import org.apache.brooklyn.util.collections.MutableList; |
| import org.apache.brooklyn.util.collections.MutableMap; |
| import org.apache.brooklyn.util.exceptions.Exceptions; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import com.google.common.base.Optional; |
| import com.google.common.base.Preconditions; |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Sets; |
| |
| /** |
| * Reflection utilities ("borrowed" from cloudsoft monterey). |
| * |
| * @author aled |
| */ |
| public class Reflections { |
| |
| private static final Logger LOG = LoggerFactory.getLogger(Reflections.class); |
| |
| public static class ReflectionNotFoundException extends RuntimeException { |
| private static final long serialVersionUID = 9032835250796708037L; |
| public ReflectionNotFoundException(String message, Throwable cause) { |
| super(message, cause); |
| } |
| public ReflectionNotFoundException(String message) { |
| super(message); |
| } |
| } |
| |
| public static class ReflectionAccessException extends RuntimeException { |
| private static final long serialVersionUID = 6569605861192432009L; |
| |
| public ReflectionAccessException(String message, Throwable cause) { |
| super(message, cause); |
| } |
| } |
| |
| private final ClassLoader classLoader; |
| private final Map<String, String> classRenameMap = MutableMap.of(); |
| |
| public Reflections(ClassLoader classLoader) { |
| this.classLoader = checkNotNull(classLoader); |
| } |
| |
| /** supply a map of known renames, of the form "old-class -> new-class" */ |
| public Reflections applyClassRenames(Map<String,String> newClassRenames) { |
| this.classRenameMap.putAll(newClassRenames); |
| return this; |
| } |
| |
| public Object loadInstance(String classname, Object...argValues) throws ReflectionNotFoundException, ReflectionAccessException { |
| Class<?> clazz = loadClass(classname); |
| Optional<?> v = null; |
| try { |
| v = invokeConstructorWithArgs(clazz, argValues); |
| if (v.isPresent()) return v.get(); |
| } catch (Exception e) { |
| throw new IllegalStateException("Error invoking constructor for "+clazz+Arrays.toString(argValues) + ": " + Exceptions.collapseText(e)); |
| } |
| throw new IllegalStateException("No suitable constructor for "+clazz+Arrays.toString(argValues)); |
| } |
| public Object loadInstance(String classname, Class<?>[] argTypes, Object[] argValues) throws ReflectionNotFoundException, ReflectionAccessException { |
| Class<?> clazz = loadClass(classname); |
| Constructor<?> constructor = loadConstructor(clazz, argTypes); |
| return loadInstance(constructor, argValues); |
| } |
| |
| public Object loadInstance(String classname) throws ReflectionNotFoundException, ReflectionAccessException { |
| Class<?> clazz = loadClass(classname); |
| try { |
| return clazz.newInstance(); |
| } catch (InstantiationException e) { |
| throw new ReflectionAccessException("Failed to create instance of class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e); |
| } catch (IllegalAccessException e) { |
| throw new ReflectionAccessException("Failed to create instance of class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| /** instantiates the given class from its binary name */ |
| public Class<?> loadClass(String classname) throws ReflectionNotFoundException { |
| try { |
| classname = findMappedNameAndLog(classRenameMap, classname); |
| return classLoader.loadClass(classname); |
| } catch (ClassNotFoundException e) { |
| throw new ReflectionNotFoundException("Failed to load class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e); |
| } catch (NoClassDefFoundError e) { |
| throw new ReflectionNotFoundException("Failed to load class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e); |
| } catch (UnsupportedClassVersionError e) { |
| throw new ReflectionNotFoundException("Failed to load class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| public <T> Class<? extends T> loadClass(String classname, Class<T> superType) throws ReflectionNotFoundException { |
| return (Class<? extends T>) loadClass(classname); |
| } |
| |
| /** given a nested part, e.g. Inner$VeryInner, this will recurse through clazz.Inner, looking for VeryInner, |
| * then looking in each supertype (interface) of clazz for Inner.VeryInner; |
| * <p> |
| * so it will find Clazz.Inner.VeryInner wherever in the hierarchy it is defined |
| * <p> |
| * (as opposed to ClassLoader which requires Inner.VeryInner to be _declared_ in clazz, not in any supertype |
| * <p> |
| * returns null if not found |
| */ |
| public static Class<?> loadInnerClassPossiblyInheritted(Class<?> clazz, String nestedPart) throws ReflectionNotFoundException { |
| Set<String> visited = new HashSet<String>(); |
| Class<?> result = loadInnerClassPossiblyInheritted(visited, clazz, nestedPart); |
| if (result!=null) return result; |
| throw new ReflectionNotFoundException("Inner class " + nestedPart + " could not be found in " + clazz + " or any of its super-types"); |
| } |
| |
| /** as 2-arg, but maintains set of visited elements, and returns null if not found */ |
| private static Class<?> loadInnerClassPossiblyInheritted(Set<String> visited, Class<?> clazz, String nestedPart) throws ReflectionNotFoundException { |
| if (clazz==null) return null; |
| if (nestedPart==null || nestedPart.length()==0) return clazz; |
| |
| int i1 = nestedPart.indexOf('$'); |
| int i2 = nestedPart.indexOf('.'); |
| int idx = (i2 > -1 && (i2 < i1 || i1==-1) ? i2 : i1); |
| String thisClassToFind = nestedPart; |
| String nextClassesToFind = ""; |
| if (idx>=0) { |
| thisClassToFind = nestedPart.substring(0, idx); |
| nextClassesToFind = nestedPart.substring(idx+1); |
| } |
| |
| if (!visited.add(clazz.getCanonicalName()+"!"+nestedPart)) { |
| //already visited |
| return null; |
| } |
| |
| Class<?>[] members = clazz.getClasses(); |
| for (int i = 0; i < members.length; i++) { |
| if (members[i].getSimpleName().equals(thisClassToFind)) { |
| Class<?> clazzI = loadInnerClassPossiblyInheritted(visited, members[i], nextClassesToFind); |
| if (clazzI!=null) return clazzI; |
| } |
| } |
| |
| //look in supertype first (not sure if necessary) |
| Class<?> result = loadInnerClassPossiblyInheritted(visited, clazz.getSuperclass(), nestedPart); |
| if (result!=null) return result; |
| |
| for (Class<?> iface : clazz.getInterfaces()) { |
| result = loadInnerClassPossiblyInheritted(visited, iface, nestedPart); |
| if (result!=null) return result; |
| } |
| return null; |
| } |
| |
| /** does not look through ancestors of outer class */ |
| public Class<?> loadInnerClassNotInheritted(String outerClassname, String innerClassname) throws ReflectionNotFoundException { |
| return loadClass(outerClassname + "$" + innerClassname); |
| } |
| |
| /** does not look through ancestors of outer class |
| * <p> |
| * uses the classloader set in this class, not in the clazz supplied */ |
| public Class<?> loadInnerClassNotInheritted(Class<?> outerClazz, String innerClassname) throws ReflectionNotFoundException { |
| return loadClass(outerClazz.getName() + "$" + innerClassname); |
| } |
| |
| public Constructor<?> loadConstructor(Class<?> clazz, Class<?>[] argTypes) throws ReflectionAccessException { |
| try { |
| return clazz.getConstructor(argTypes); |
| } catch (SecurityException e) { |
| throw new ReflectionAccessException("Failed to load constructor of class '" + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e); |
| } catch (NoSuchMethodException e) { |
| throw new ReflectionAccessException("Failed to load constructor of class '" + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| /** Invokes a suitable constructor, supporting varargs and primitives */ |
| public static <T> Optional<T> invokeConstructorWithArgs(ClassLoader classLoader, String className, Object...argsArray) { |
| Reflections reflections = new Reflections(classLoader); |
| @SuppressWarnings("unchecked") |
| Class<T> clazz = (Class<T>) reflections.loadClass(className); |
| return invokeConstructorWithArgs(reflections, clazz, argsArray, false); |
| } |
| |
| /** Invokes a suitable constructor, supporting varargs and primitives */ |
| public static <T> Optional<T> invokeConstructorWithArgs(ClassLoader classLoader, Class<T> clazz, Object[] argsArray, boolean setAccessible) { |
| Reflections reflections = new Reflections(classLoader); |
| return invokeConstructorWithArgs(reflections, clazz, argsArray, setAccessible); |
| } |
| |
| /** Invokes a suitable constructor, supporting varargs and primitives */ |
| public static <T> Optional<T> invokeConstructorWithArgs(Class<T> clazz, Object...argsArray) { |
| return invokeConstructorWithArgs(clazz, argsArray, false); |
| } |
| |
| /** Invokes a suitable constructor, supporting varargs and primitives */ |
| public static <T> Optional<T> invokeConstructorWithArgs(Class<T> clazz, Object[] argsArray, boolean setAccessible) { |
| Reflections reflections = new Reflections(clazz.getClassLoader()); |
| return invokeConstructorWithArgs(reflections, clazz, argsArray, setAccessible); |
| } |
| |
| /** Invokes a suitable constructor, supporting varargs and primitives, additionally supporting setAccessible */ |
| @SuppressWarnings("unchecked") |
| public static <T> Optional<T> invokeConstructorWithArgs(Reflections reflections, Class<T> clazz, Object[] argsArray, boolean setAccessible) { |
| for (Constructor<?> constructor : clazz.getConstructors()) { |
| Class<?>[] parameterTypes = constructor.getParameterTypes(); |
| if (constructor.isVarArgs()) { |
| if (typesMatchUpTo(argsArray, parameterTypes, parameterTypes.length-1)) { |
| Class<?> varargType = parameterTypes[parameterTypes.length-1].getComponentType(); |
| boolean varargsMatch = true; |
| for (int i=parameterTypes.length-1; i<argsArray.length; i++) { |
| if (!Boxing.boxedType(varargType).isInstance(argsArray[i]) || |
| (varargType.isPrimitive() && argsArray[i]==null)) { |
| varargsMatch = false; |
| break; |
| } |
| } |
| if (varargsMatch) { |
| Object varargs = Array.newInstance(varargType, argsArray.length+1 - parameterTypes.length); |
| for (int i=parameterTypes.length-1; i<argsArray.length; i++) { |
| Boxing.setInArray(varargs, i+1-parameterTypes.length, argsArray[i], varargType); |
| } |
| Object[] newArgsArray = new Object[parameterTypes.length]; |
| System.arraycopy(argsArray, 0, newArgsArray, 0, parameterTypes.length-1); |
| newArgsArray[parameterTypes.length-1] = varargs; |
| if (setAccessible) constructor.setAccessible(true); |
| return (Optional<T>) Optional.of(reflections.loadInstance(constructor, newArgsArray)); |
| } |
| } |
| } |
| if (typesMatch(argsArray, parameterTypes)) { |
| if (setAccessible) constructor.setAccessible(true); |
| return (Optional<T>) Optional.of(reflections.loadInstance(constructor, argsArray)); |
| } |
| } |
| return Optional.absent(); |
| } |
| |
| |
| /** returns a single constructor in a given class, or throws an exception */ |
| public Constructor<?> loadSingleConstructor(Class<?> clazz) { |
| Constructor<?>[] constructors = clazz.getConstructors(); |
| if (constructors.length == 1) { |
| return constructors[0]; |
| } |
| throw new IllegalArgumentException("Class " + clazz + " has more than one constructor"); |
| } |
| |
| public <T> T loadInstance(Constructor<T> constructor, Object...argValues) throws IllegalArgumentException, ReflectionAccessException { |
| try { |
| try { |
| return constructor.newInstance(argValues); |
| } catch (IllegalArgumentException e) { |
| try { |
| LOG.warn("Failure passing provided arguments ("+getIllegalArgumentsErrorMessage(constructor, argValues)+"; "+e+"); attempting to reconstitute"); |
| argValues = (Object[]) updateFromNewClassLoader(argValues); |
| return constructor.newInstance(argValues); |
| } catch (Throwable e2) { |
| LOG.warn("Reconstitution attempt failed (will rethrow original excaption): "+e2, e2); |
| throw e; |
| } |
| } |
| } catch (IllegalArgumentException e) { |
| throw new IllegalArgumentException(getIllegalArgumentsErrorMessage(constructor, argValues)+": " + Exceptions.collapseText(e), e); |
| } catch (InstantiationException e) { |
| throw new ReflectionAccessException("Failed to create instance of " + constructor.getDeclaringClass() + ": " + Exceptions.collapseText(e), e); |
| } catch (IllegalAccessException e) { |
| throw new ReflectionAccessException("Failed to create instance of " + constructor.getDeclaringClass() + ": " + Exceptions.collapseText(e), e); |
| } catch (InvocationTargetException e) { |
| throw new ReflectionAccessException("Failed to create instance of " + constructor.getDeclaringClass() + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| public Method loadMethod(Class<?> clazz, String methodName, Class<?>[] argTypes) throws ReflectionNotFoundException, ReflectionAccessException { |
| try { |
| return clazz.getMethod(methodName, argTypes); |
| } catch (NoClassDefFoundError e) { |
| throw new ReflectionNotFoundException("Failed to invoke method " + methodName + " on class " + clazz + " with argument types " + Arrays.asList(argTypes) + ", using class loader " + clazz.getClassLoader() + ": " + Exceptions.collapseText(e), e); |
| } catch (NoSuchMethodException e) { |
| throw new ReflectionNotFoundException("Failed to invoke method " + methodName + " on class " + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e); |
| } catch (SecurityException e) { |
| throw new ReflectionAccessException("Failed to invoke method " + methodName + " on class " + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| /** returns the first method matching the given name */ |
| public Method loadMethod(Class<?> clazz, String methodName) throws ReflectionNotFoundException, ReflectionAccessException { |
| try { |
| Method[] allmethods = clazz.getMethods(); |
| for (int i = 0; i < allmethods.length; i++) { |
| if (allmethods[i].getName().equals(methodName)) { |
| return allmethods[i]; |
| } |
| } |
| throw new ReflectionNotFoundException("Cannot find method " + methodName + " on class " + clazz); |
| |
| } catch (SecurityException e) { |
| throw new ReflectionAccessException("Failed to invoke method '" + methodName + " on class " + clazz + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| /** |
| * |
| * @throws ReflectionAccessException If invocation failed due to illegal access or the invoked method failed |
| * @throws IllegalArgumentException If the arguments were invalid |
| */ |
| public Object invokeMethod(Method method, Object obj, Object... argValues) throws ReflectionAccessException { |
| try { |
| return method.invoke(obj, argValues); |
| } catch (IllegalArgumentException e) { |
| throw new IllegalArgumentException(getIllegalArgumentsErrorMessage(method, argValues), e); |
| } catch (IllegalAccessException e) { |
| throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e); |
| } catch (InvocationTargetException e) { |
| throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| public Object invokeStaticMethod(Method method, Object... argValues) throws IllegalArgumentException, ReflectionAccessException { |
| try { |
| return method.invoke(null, argValues); |
| } catch (IllegalArgumentException e) { |
| throw new IllegalArgumentException(getIllegalArgumentsErrorMessage(method, argValues), e); |
| } catch (IllegalAccessException e) { |
| throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e); |
| } catch (InvocationTargetException e) { |
| throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| |
| public Object loadStaticField(Class<?> clazz, String fieldname) throws ReflectionAccessException { |
| return loadStaticFields(clazz, new String[] {fieldname}, null)[0]; |
| } |
| |
| public Object[] loadStaticFields(Class<?> clazz, String[] fieldnamesArray, Object[] defaults) throws ReflectionAccessException { |
| Object[] result = new Object[fieldnamesArray.length]; |
| if (defaults!=null) { |
| for (int i = 0; i < defaults.length; i++) { |
| result[i] = defaults[i]; |
| } |
| } |
| |
| List<String> fieldnames = Arrays.asList(fieldnamesArray); |
| Field[] classFields = clazz.getDeclaredFields(); |
| |
| for (int i = 0; i < classFields.length; i++) { |
| Field field = classFields[i]; |
| int index = fieldnames.indexOf(field.getName()); |
| if (index >= 0) { |
| try { |
| result[index] = field.get(null); |
| } catch (IllegalArgumentException e) { |
| throw new ReflectionAccessException("Failed to load field '" + field.getName() + " from class " + clazz + ": " + Exceptions.collapseText(e), e); |
| } catch (IllegalAccessException e) { |
| throw new ReflectionAccessException("Failed to load field '" + field.getName() + " from class " + clazz + ": " + Exceptions.collapseText(e), e); |
| } |
| } |
| } |
| return result; |
| } |
| |
| private static String getIllegalArgumentsErrorMessage(Method method, Object[] argValues) { |
| return method.toGenericString() + " not applicable for the parameters of type " + argumentTypesToString(argValues); |
| } |
| |
| private static String getIllegalArgumentsErrorMessage(Constructor<?> constructor, Object[] argValues) { |
| return constructor.toGenericString() + " not applicable for the parameters of type " + argumentTypesToString(argValues); |
| } |
| |
| private static String argumentTypesToString(Object[] argValues) { |
| StringBuffer msg = new StringBuffer("("); |
| for (int i = 0; i < argValues.length; i++) { |
| if (i != 0) msg.append(", "); |
| msg.append(argValues[i] != null ? argValues[i].getClass().getName() : "null"); |
| } |
| msg.append(")"); |
| return msg.toString(); |
| } |
| |
| /** copies all fields from the source to target; very little compile-time safety checking, so use with care |
| * @throws IllegalAccessException |
| * @throws IllegalArgumentException */ |
| public static <T> void copyFields(T source, T target) throws IllegalArgumentException, IllegalAccessException { |
| Class<? extends Object> clazz = source.getClass(); |
| while (clazz!=null) { |
| Field[] fields = clazz.getDeclaredFields(); |
| for (Field f : fields) { |
| f.setAccessible(true); |
| Object vs = f.get(source); |
| Object vt = f.get(target); |
| if ((vs==null && vt!=null) || (vs!=null && !vs.equals(vt))) { |
| f.set(target, vs); |
| } |
| } |
| clazz = clazz.getSuperclass(); |
| } |
| } |
| |
| /** |
| * Loads class given its canonical name format (e.g. com.acme.Foo.Inner), |
| * using iterative strategy (trying com.acme.Foo$Inner, then com.acme$Foo$Inner, etc). |
| * @throws ReflectionNotFoundException |
| */ |
| public Class<?> loadClassFromCanonicalName(String canonicalName) throws ClassNotFoundException, ReflectionNotFoundException { |
| ClassNotFoundException err = null; |
| String name = canonicalName; |
| do { |
| try { |
| return classLoader.loadClass(name); |
| } catch (ClassNotFoundException e) { |
| if (err == null) err = e; |
| int lastIndexOf = name.lastIndexOf("."); |
| if (lastIndexOf >= 0) { |
| name = name.substring(0, lastIndexOf) + "$" + name.substring(lastIndexOf+1); |
| } |
| } |
| } while (name.contains(".")); |
| throw err; |
| } |
| |
| /** finds the resource in the classloader, if it exists; inserts or replaces leading slash as necessary |
| * (i believe it should _not_ have one, but there is some inconsistency) |
| * |
| * Will return null if no resource is found. |
| */ |
| @Nullable |
| public URL getResource(String r) { |
| URL u = null; |
| u = classLoader.getResource(r); |
| if (u!=null) return u; |
| |
| if (r.startsWith("/")) r = r.substring(1); |
| else r = "/"+r; |
| return classLoader.getResource(r); |
| } |
| |
| /** |
| * Serialize the given object, then reload using the current class loader; |
| * this removes linkages to instances with classes loaded by an older class loader. |
| * <p> |
| * (like a poor man's clone) |
| * <p> |
| * aka "reconstitute(Object)" |
| */ |
| public final Object updateFromNewClassLoader(Object data) throws IOException, ClassNotFoundException { |
| ByteArrayOutputStream bytes = new ByteArrayOutputStream(); |
| new ObjectOutputStream(bytes).writeObject(data); |
| Object reconstituted = new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray())).readObject(); |
| if (LOG.isDebugEnabled()) LOG.debug("Reconstituted data: " + reconstituted + ", class loader: " + classLoader); |
| return reconstituted; |
| } |
| |
| public ClassLoader getClassLoader() { |
| return classLoader; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public static <T> Class<? super T> findSuperType(T impl, String typeName) { |
| Set<Class<?>> toinspect = new LinkedHashSet<Class<?>>(); |
| Set<Class<?>> inspected = new HashSet<Class<?>>(); |
| toinspect.add(impl.getClass()); |
| |
| while (toinspect.size() > 0) { |
| Class<?> clazz = toinspect.iterator().next(); // get and remove the first element |
| if (clazz.getName().equals(typeName)) { |
| return (Class<? super T>) clazz; |
| } |
| inspected.add(clazz); |
| List<Class<?>> toAdd = Arrays.asList(clazz.getInterfaces()); |
| toinspect.addAll( toAdd ); |
| if (clazz.getSuperclass() != null) toinspect.add(clazz.getSuperclass()); |
| toinspect.removeAll(inspected); |
| } |
| |
| return null; |
| } |
| |
| /** whereas Class.getInterfaces() only returns interfaces directly implemented by a class, |
| * this walks the inheritance hierarchy to include interfaces implemented by superclass/ancestors; |
| * (note it does not include superinterfaces) |
| */ |
| public static Set<Class<?>> getInterfacesIncludingClassAncestors(Class<?> clazz) { |
| Set<Class<?>> result = new LinkedHashSet<Class<?>>(); |
| while (clazz!=null) { |
| for (Class<?> iface: clazz.getInterfaces()) |
| result.add(iface); |
| clazz = clazz.getSuperclass(); |
| } |
| return result; |
| } |
| |
| public static Method findMethod(Class<?> clazz, String name, Class<?>... parameterTypes) throws NoSuchMethodException { |
| if (clazz == null || name == null) { |
| throw new NullPointerException("Must not be null: clazz="+clazz+"; name="+name); |
| } |
| Class<?> clazzToInspect = clazz; |
| NoSuchMethodException toThrowIfFails = null; |
| |
| while (clazzToInspect != null) { |
| try { |
| return clazzToInspect.getDeclaredMethod(name, parameterTypes); |
| } catch (NoSuchMethodException e) { |
| if (toThrowIfFails == null) toThrowIfFails = e; |
| clazzToInspect = clazzToInspect.getSuperclass(); |
| } |
| } |
| throw toThrowIfFails; |
| } |
| |
| public static Field findField(Class<?> clazz, String name) throws NoSuchFieldException { |
| if (clazz == null || name == null) { |
| throw new NullPointerException("Must not be null: clazz="+clazz+"; name="+name); |
| } |
| Class<?> clazzToInspect = clazz; |
| NoSuchFieldException toThrowIfFails = null; |
| |
| while (clazzToInspect != null) { |
| try { |
| return clazzToInspect.getDeclaredField(name); |
| } catch (NoSuchFieldException e) { |
| if (toThrowIfFails == null) toThrowIfFails = e; |
| clazzToInspect = clazzToInspect.getSuperclass(); |
| } |
| } |
| throw toThrowIfFails; |
| } |
| |
| public static List<Field> findPublicFieldsOrderedBySuper(Class<?> clazz) { |
| checkNotNull(clazz, "clazz"); |
| MutableList.Builder<Field> result = MutableList.<Field>builder(); |
| Stack<Class<?>> tovisit = new Stack<Class<?>>(); |
| Set<Class<?>> visited = Sets.newLinkedHashSet(); |
| tovisit.push(clazz); |
| |
| while (!tovisit.isEmpty()) { |
| Class<?> nextclazz = tovisit.pop(); |
| if (!visited.add(nextclazz)) { |
| continue; // already visited |
| } |
| if (nextclazz.getSuperclass() != null) tovisit.add(nextclazz.getSuperclass()); |
| tovisit.addAll(Arrays.asList(nextclazz.getInterfaces())); |
| |
| result.addAll(Iterables.filter(Arrays.asList(nextclazz.getDeclaredFields()), new Predicate<Field>() { |
| @Override public boolean apply(Field input) { |
| return Modifier.isPublic(input.getModifiers()); |
| }})); |
| |
| } |
| |
| List<Field> resultList = result.build(); |
| Collections.sort(resultList, new Comparator<Field>() { |
| @Override public int compare(Field f1, Field f2) { |
| Field fsubbest = inferSubbestField(f1, f2); |
| return (fsubbest == null) ? 0 : (fsubbest == f1 ? 1 : -1); |
| }}); |
| |
| return resultList; |
| } |
| |
| // TODO I've seen strange behaviour where class.getMethods() does not include methods from interfaces. |
| // Also the ordering guarantees here are useful... |
| public static List<Method> findPublicMethodsOrderedBySuper(Class<?> clazz) { |
| checkNotNull(clazz, "clazz"); |
| MutableList.Builder<Method> result = MutableList.<Method>builder(); |
| Stack<Class<?>> tovisit = new Stack<Class<?>>(); |
| Set<Class<?>> visited = Sets.newLinkedHashSet(); |
| tovisit.push(clazz); |
| |
| while (!tovisit.isEmpty()) { |
| Class<?> nextclazz = tovisit.pop(); |
| if (!visited.add(nextclazz)) { |
| continue; // already visited |
| } |
| if (nextclazz.getSuperclass() != null) tovisit.add(nextclazz.getSuperclass()); |
| tovisit.addAll(Arrays.asList(nextclazz.getInterfaces())); |
| |
| result.addAll(Iterables.filter(Arrays.asList(nextclazz.getDeclaredMethods()), new Predicate<Method>() { |
| @Override public boolean apply(Method input) { |
| return Modifier.isPublic(input.getModifiers()); |
| }})); |
| |
| } |
| |
| List<Method> resultList = result.build(); |
| Collections.sort(resultList, new Comparator<Method>() { |
| @Override public int compare(Method m1, Method m2) { |
| Method msubbest = inferSubbestMethod(m1, m2); |
| return (msubbest == null) ? 0 : (msubbest == m1 ? 1 : -1); |
| }}); |
| |
| return resultList; |
| } |
| |
| /** |
| * Gets the field that is in the sub-class; or null if one field does not come from a sub-class of the other field's class |
| */ |
| public static Field inferSubbestField(Field f1, Field f2) { |
| Class<?> c1 = f1.getDeclaringClass(); |
| Class<?> c2 = f2.getDeclaringClass(); |
| boolean isSuper1 = c1.isAssignableFrom(c2); |
| boolean isSuper2 = c2.isAssignableFrom(c1); |
| return (isSuper1) ? (isSuper2 ? null : f2) : (isSuper2 ? f1 : null); |
| } |
| |
| /** |
| * Gets the method that is in the sub-class; or null if one method does not come from a sub-class of the other method's class |
| */ |
| public static Method inferSubbestMethod(Method m1, Method m2) { |
| Class<?> c1 = m1.getDeclaringClass(); |
| Class<?> c2 = m2.getDeclaringClass(); |
| boolean isSuper1 = c1.isAssignableFrom(c2); |
| boolean isSuper2 = c2.isAssignableFrom(c1); |
| return (isSuper1) ? (isSuper2 ? null : m2) : (isSuper2 ? m1 : null); |
| } |
| |
| /** |
| * Gets the class that is in the sub-class; or null if neither is a sub-class of the other. |
| */ |
| public static Class<?> inferSubbest(Class<?> c1, Class<?> c2) { |
| boolean isSuper1 = c1.isAssignableFrom(c2); |
| boolean isSuper2 = c2.isAssignableFrom(c1); |
| return (isSuper1) ? (isSuper2 ? null : c2) : (isSuper2 ? c1 : null); |
| } |
| |
| /** convenience for casting the given candidate to the given type (without any coercion, and allowing candidate to be null) */ |
| @SuppressWarnings("unchecked") |
| public static <T> T cast(Object candidate, Class<? extends T> type) { |
| if (candidate==null) return null; |
| if (!type.isAssignableFrom(candidate.getClass())) |
| throw new IllegalArgumentException("Requires a "+type+", but had a "+candidate.getClass()+" ("+candidate+")"); |
| return (T)candidate; |
| } |
| |
| /** invokes the given method on the given clazz or instance, doing reasonably good matching on args etc |
| * @throws InvocationTargetException |
| * @throws IllegalAccessException |
| * @throws IllegalArgumentException */ |
| public static Optional<Object> invokeMethodWithArgs(Object clazzOrInstance, String method, List<Object> args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException { |
| return invokeMethodWithArgs(clazzOrInstance, method, args, false); |
| } |
| public static Optional<Object> invokeMethodWithArgs(Object clazzOrInstance, String method, List<Object> args, boolean setAccessible) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException { |
| Preconditions.checkNotNull(clazzOrInstance, "clazz or instance"); |
| Preconditions.checkNotNull(method, "method"); |
| Preconditions.checkNotNull(args, "args to "+method); |
| |
| Class<?> clazz; |
| Object instance; |
| if (clazzOrInstance instanceof Class) { |
| clazz = (Class<?>)clazzOrInstance; |
| instance = null; |
| } else { |
| clazz = clazzOrInstance.getClass(); |
| instance = clazzOrInstance; |
| } |
| |
| Object[] argsArray = args.toArray(); |
| |
| for (Method m: clazz.getMethods()) { |
| if (method.equals(m.getName())) { |
| Class<?>[] parameterTypes = m.getParameterTypes(); |
| if (m.isVarArgs()) { |
| if (typesMatchUpTo(argsArray, parameterTypes, parameterTypes.length-1)) { |
| Class<?> varargType = parameterTypes[parameterTypes.length-1].getComponentType(); |
| boolean varargsMatch = true; |
| for (int i=parameterTypes.length-1; i<argsArray.length; i++) { |
| if (!Boxing.boxedType(varargType).isInstance(argsArray[i]) || |
| (varargType.isPrimitive() && argsArray[i]==null)) { |
| varargsMatch = false; |
| break; |
| } |
| } |
| if (varargsMatch) { |
| Object varargs = Array.newInstance(varargType, argsArray.length+1 - parameterTypes.length); |
| for (int i=parameterTypes.length-1; i<argsArray.length; i++) { |
| Boxing.setInArray(varargs, i+1-parameterTypes.length, argsArray[i], varargType); |
| } |
| Object[] newArgsArray = new Object[parameterTypes.length]; |
| System.arraycopy(argsArray, 0, newArgsArray, 0, parameterTypes.length-1); |
| newArgsArray[parameterTypes.length-1] = varargs; |
| if (setAccessible) m.setAccessible(true); |
| return Optional.of(m.invoke(instance, newArgsArray)); |
| } |
| } |
| } |
| if (typesMatch(argsArray, parameterTypes)) { |
| if (setAccessible) m.setAccessible(true); |
| return Optional.of(m.invoke(instance, argsArray)); |
| } |
| } |
| } |
| |
| return Optional.absent(); |
| } |
| |
| /** true iff all args match the corresponding types */ |
| public static boolean typesMatch(Object[] argsArray, Class<?>[] parameterTypes) { |
| if (argsArray.length != parameterTypes.length) |
| return false; |
| return typesMatchUpTo(argsArray, parameterTypes, argsArray.length); |
| } |
| |
| /** true iff the initial N args match the corresponding types */ |
| public static boolean typesMatchUpTo(Object[] argsArray, Class<?>[] parameterTypes, int lengthRequired) { |
| if (argsArray.length < lengthRequired || parameterTypes.length < lengthRequired) |
| return false; |
| for (int i=0; i<lengthRequired; i++) { |
| if (argsArray[i]==null) continue; |
| if (Boxing.boxedType(parameterTypes[i]).isInstance(argsArray[i])) continue; |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Gets all the interfaces implemented by the given type, including its parent classes. |
| * |
| * @param type the class to look up |
| * @return an immutable list of the interface classes |
| */ |
| public static List<Class<?>> getAllInterfaces(@Nullable Class<?> type) { |
| Set<Class<?>> found = Sets.newLinkedHashSet(); |
| findAllInterfaces(type, found); |
| return ImmutableList.copyOf(found); |
| } |
| |
| /** Recurse through the class hierarchies of the type and its interfaces. */ |
| private static void findAllInterfaces(@Nullable Class<?> type, Set<Class<?>> found) { |
| if (type == null) return; |
| for (Class<?> i : type.getInterfaces()) { |
| if (found.add(i)) { // not seen before |
| findAllInterfaces(i, found); |
| } |
| } |
| findAllInterfaces(type.getSuperclass(), found); |
| } |
| |
| public static boolean hasNoArgConstructor(Class<?> clazz) { |
| try { |
| clazz.getConstructor(new Class[0]); |
| return true; |
| } catch (NoSuchMethodException e) { |
| return false; |
| } |
| } |
| |
| public static boolean hasNoNonObjectFields(Class<? extends Object> clazz) { |
| if (Object.class.equals(clazz)) return true; |
| if (clazz.getDeclaredFields().length>0) return false; |
| return hasNoNonObjectFields(clazz.getSuperclass()); |
| } |
| |
| /** Takes a map of old-class-names to renames classes, and returns the mapped name if matched, or absent */ |
| public static Optional<String> tryFindMappedName(Map<String, String> renames, String name) { |
| if (renames==null) return Optional.absent(); |
| |
| String mappedName = renames.get(name); |
| if (mappedName != null) { |
| return Optional.of(mappedName); |
| } |
| |
| // look for inner classes by mapping outer class |
| if (name.contains("$")) { |
| String outerClassName = name.substring(0, name.indexOf('$')); |
| mappedName = renames.get(outerClassName); |
| if (mappedName != null) { |
| return Optional.of(mappedName + name.substring(name.indexOf('$'))); |
| } |
| } |
| |
| return Optional.absent(); |
| } |
| |
| public static String findMappedNameAndLog(Map<String, String> renames, String name) { |
| Optional<String> rename = Reflections.tryFindMappedName(renames, name); |
| if (rename.isPresent()) { |
| LOG.debug("Mapping class '"+name+"' to '"+rename.get()+"'"); |
| return rename.get(); |
| } |
| return name; |
| } |
| |
| } |
