Package org.plumelib.reflection

Class ReflectionPlume

java.lang.Object
org.plumelib.reflection.ReflectionPlume
public final class ReflectionPlume extends Object
Utility functions related to reflection, Class, Method, ClassLoader, and classpath.

  • Method Details

    • isSubtype

      @Pure public static boolean isSubtype(Class<?> sub, Class<?> sup)
      Return true iff sub is a subtype of sup. If sub == sup, then sub is considered a subtype of sub and this method returns true.
      Parameters:
      sub - class to test for being a subtype
      sup - class to test for being a supertype
      Returns:
      true iff sub is a subtype of sup

    • classForName

      public static Class<?> classForName(@ClassGetName String className) throws ClassNotFoundException
      Like Class.forName(String): given a string representing a non-array class, returns the Class. Unlike Class.forName(String), the argument may be a primitive type or a fully-qualified name (in addition to a binary name).

      If the given name can't be found, this method changes the last '.' to a dollar sign ($) and tries again. This accounts for inner classes that are incorrectly passed in in fully-qualified format instead of binary format. (It should try multiple dollar signs, not just at the last position.)

      Recall the rather odd specification for Class.forName(String): the argument is a binary name for non-arrays, but a field descriptor for arrays. This method uses the same rules, but additionally handles primitive types and, for non-arrays, fully-qualified names.

      Parameters:
      className - name of the class
      Returns:
      the Class corresponding to className
      Throws:
      ClassNotFoundException - if the class is not found

    • fullyQualifiedNameToSimpleName

      public static @ClassGetSimpleName String fullyQualifiedNameToSimpleName(@FullyQualifiedName String qualifiedName)
      Returns the simple unqualified class name that corresponds to the specified fully qualified name. For example, if qualifiedName is java.lang.String, String will be returned.
      Parameters:
      qualifiedName - the fully-qualified name of a class
      Returns:
      the simple unqualified name of the class

    • nameWithoutPackage

      public static String nameWithoutPackage(Class<?> c)
      Returns the class name, including outer classes but without the package. Uses "." as the separator between outer an inner classes, as in Java source code.
      Parameters:
      c - a class
      Returns:
      the class name, including outer classes but without the package

    • defineClassFromFile

      public static Class<?> defineClassFromFile(@BinaryName String className, String pathname) throws FileNotFoundException, IOException
      Converts the bytes in a file into an instance of class Class, and resolves (links) the class. Like ClassLoader.defineClass(String,byte[],int,int), but takes a file name rather than an array of bytes as an argument, and also resolves (links) the class.
      Parameters:
      className - the name of the class to define, or null if not known
      pathname - the pathname of a .class file
      Returns:
      a Java Object corresponding to the Class defined in the .class file
      Throws:
      FileNotFoundException - if the file cannot be found
      IOException - if there is trouble reading the file
      See Also:

    • addToClasspath

      public static void addToClasspath(String dir)
      Add the directory to the system classpath.
      Parameters:
      dir - directory to add to the system classpath

    • classpathToString

      public static String classpathToString()
      Returns the classpath as a multi-line string.
      Returns:
      the classpath as a multi-line string

    • methodForName

      public static Method methodForName(String method) throws ClassNotFoundException, NoSuchMethodException, SecurityException
      Given a method signature, return the method.

      Example calls are: 

       UtilPlume.methodForName(
   "org.plumelib.reflection.ReflectionPlume.methodForName"
   +"(java.lang.String, java.lang.String, java.lang.Class[])")
 UtilPlume.methodForName("org.plumelib.reflection.ReflectionPlume.methodForName"
                         +"(java.lang.String,java.lang.String,java.lang.Class[])")
 UtilPlume.methodForName("java.lang.Math.min(int,int)")
      Parameters:
      method - a method signature
      Returns:
      the method corresponding to the given signature
      Throws:
      ClassNotFoundException - if the class is not found
      NoSuchMethodException - if the method is not found
      SecurityException

    • methodForName

      public static Method methodForName(@BinaryName String classname, String methodname, Class<?>[] params) throws ClassNotFoundException, NoSuchMethodException, SecurityException
      Given a class name and a method name in that class, return the method.
      Parameters:
      classname - class in which to find the method
      methodname - the method name
      params - the parameters of the method
      Returns:
      the method named classname.methodname with parameters params
      Throws:
      ClassNotFoundException - if the class is not found
      NoSuchMethodException - if the method is not found
      SecurityException

    • setFinalField

      public static void setFinalField(Object o, String fieldName, @Interned Object value) throws NoSuchFieldException
      Sets the given field, which may be final and/or private. Leaves the field accessible.
      Parameters:
      o - object in which to set the field; null iff the field is static
      fieldName - name of field to set
      value - new value of field; may be null iff the field is nullable
      Throws:
      NoSuchFieldException - if the field does not exist in the object

    • getPrivateField

      public static @Nullable Object getPrivateField(Object o, String fieldName) throws NoSuchFieldException
      Reads the given field, which may be private. Leaves the field accessible. Use with care!
      Parameters:
      o - object in which to set the field
      fieldName - name of field to set
      Returns:
      new value of field
      Throws:
      NoSuchFieldException - if the field does not exist in the object

    • leastUpperBound

      public static <T> @Nullable Class<T> leastUpperBound(@Nullable Class<T> a, @Nullable Class<T> b)
      Returns the least upper bound of the given classes.
      Type Parameters:
      T - the (inferred) least upper bound of the two arguments
      Parameters:
      a - a class
      b - a class
      Returns:
      the least upper bound of the two classes, or null if both are null

    • leastUpperBound

      public static <T> @Nullable Class<T> leastUpperBound(@Nullable Class<T>[] classes)
      Returns the least upper bound of all the given classes.
      Type Parameters:
      T - the (inferred) least upper bound of the arguments
      Parameters:
      classes - a non-empty list of classes
      Returns:
      the least upper bound of all the given classes

    • leastUpperBound

      public static <T> @Nullable Class<T> leastUpperBound(@PolyMustCall @PolyNull Object[] objects)
      Returns the least upper bound of the classes of the given objects.
      Type Parameters:
      T - the (inferred) least upper bound of the arguments
      Parameters:
      objects - a list of objects
      Returns:
      the least upper bound of the classes of the given objects, or null if all arguments are null

    • leastUpperBound

      public static <T> @Nullable Class<T> leastUpperBound(List<? extends @Nullable Object> objects)
      Returns the least upper bound of the classes of the given objects.
      Type Parameters:
      T - the (inferred) least upper bound of the arguments
      Parameters:
      objects - a non-empty list of objects
      Returns:
      the least upper bound of the classes of the given objects, or null if all arguments are null