cleaned up import declarations

git-svn-id: http://anonsvn.jboss.org/repos/javassist/trunk@168 30ef5769-5b8d-40dd-aea6-55b5d6557bb3

sample/evolve/DemoLoader.java

@@ -1,8 +1,6 @@
 package sample.evolve;
 
 import javassist.*;
-import java.io.*;
-import java.util.Hashtable;
 
 /**
  * DemoLoader is a class loader for running a program including

sample/evolve/DemoServer.java

@@ -1,6 +1,5 @@
 package sample.evolve;
 
-import javassist.*;
 import javassist.web.*;
 import java.io.*;
 

sample/evolve/Evolution.java

@@ -1,202 +1,189 @@
 package sample.evolve;
 
 import javassist.*;
-import java.io.IOException;
 
 /**
  * Evolution provides a set of methods for instrumenting bytecodes.
- *
- * For class evolution, updatable class A is renamed to B.  Then an
- * abstract class named A is produced as the super class of B.  If the
- * original class A has a public method m(), then the abstract class A
- * has an abstract method m().
- *
- *                    abstract class A
- *                      abstract m()
- *                      _makeInstance()
- *                           |
- *     class A  --------> class B
- *       m()                m()
- *
- * Also, all the other classes are translated so that "new A(i)"
- * in the methods is replaced with "_makeInstance(i)".  This makes
- * it possible to change the behavior of the instantiation of
- * the class A.
+ * 
+ * For class evolution, updatable class A is renamed to B. Then an abstract
+ * class named A is produced as the super class of B. If the original class A
+ * has a public method m(), then the abstract class A has an abstract method
+ * m().
+ * 
+ * abstract class A abstract m() _makeInstance() | class A --------> class B m()
+ * m()
+ * 
+ * Also, all the other classes are translated so that "new A(i)" in the methods
+ * is replaced with "_makeInstance(i)". This makes it possible to change the
+ * behavior of the instantiation of the class A.
  */
 public class Evolution implements Translator {
     public final static String handlerMethod = "_makeInstance";
-    public final static String latestVersionField
-				= VersionManager.latestVersionField;
+
+    public final static String latestVersionField = VersionManager.latestVersionField;
+
     public final static String versionManagerMethod = "initialVersion";
 
     private static CtMethod trapMethod;
+
     private static final int initialVersion = 0;
+
     private ClassPool pool;
+
     private String updatableClassName = null;
+
     private CtClass updatableClass = null;
 
     public void start(ClassPool _pool) throws NotFoundException {
-	pool = _pool;
+        pool = _pool;
 
-	// Get the definition of Sample.make() and store it into trapMethod
-	// for later use.
-	trapMethod = _pool.getMethod("sample.evolve.Sample", "make");
+        // Get the definition of Sample.make() and store it into trapMethod
+        // for later use.
+        trapMethod = _pool.getMethod("sample.evolve.Sample", "make");
     }
 
     public void onLoad(ClassPool _pool, String classname)
-	throws NotFoundException, CannotCompileException
-    {
-	onLoadUpdatable(classname);
-
-	/*
-	 * Replaces all the occurrences of the new operator with a call
-	 * to _makeInstance().
-	 */
-	CtClass clazz = _pool.get(classname);
-	CtClass absClass = updatableClass;
-	CodeConverter converter = new CodeConverter();
-	converter.replaceNew(absClass, absClass, handlerMethod);
-	clazz.instrument(converter);
+            throws NotFoundException, CannotCompileException {
+        onLoadUpdatable(classname);
+
+        /*
+         * Replaces all the occurrences of the new operator with a call to
+         * _makeInstance().
+         */
+        CtClass clazz = _pool.get(classname);
+        CtClass absClass = updatableClass;
+        CodeConverter converter = new CodeConverter();
+        converter.replaceNew(absClass, absClass, handlerMethod);
+        clazz.instrument(converter);
     }
 
-    private void onLoadUpdatable(String classname)
-	throws NotFoundException, CannotCompileException
-    {
-	// if the class is a concrete class,
-	// classname is <updatableClassName>$<version>.
-
-	int i = classname.lastIndexOf('$');
-	if (i <= 0)
-	    return;
-
-	String orgname = classname.substring(0, i);
-	if (!orgname.equals(updatableClassName))
-	    return;
-
-	int version;
-	try {
-	    version = Integer.parseInt(classname.substring(i + 1));
-	}
-	catch (NumberFormatException e) {
-	    throw new NotFoundException(classname, e);
-	}
-
-	CtClass clazz = pool.getAndRename(orgname, classname);
-	makeConcreteClass(clazz, updatableClass, version);
+    private void onLoadUpdatable(String classname) throws NotFoundException,
+            CannotCompileException {
+        // if the class is a concrete class,
+        // classname is <updatableClassName>$<version>.
+
+        int i = classname.lastIndexOf('$');
+        if (i <= 0)
+            return;
+
+        String orgname = classname.substring(0, i);
+        if (!orgname.equals(updatableClassName))
+            return;
+
+        int version;
+        try {
+            version = Integer.parseInt(classname.substring(i + 1));
+        }
+        catch (NumberFormatException e) {
+            throw new NotFoundException(classname, e);
+        }
+
+        CtClass clazz = pool.getAndRename(orgname, classname);
+        makeConcreteClass(clazz, updatableClass, version);
     }
 
-    /* Register an updatable class.
+    /*
+     * Register an updatable class.
      */
-    public void makeUpdatable(String classname)
-	throws NotFoundException, CannotCompileException
-    {
-	if (pool == null)
-	    throw new RuntimeException(
-		       "Evolution has not been linked to ClassPool.");
-
-	CtClass c = pool.get(classname);
-	updatableClassName = classname;
-	updatableClass = makeAbstractClass(c);
+    public void makeUpdatable(String classname) throws NotFoundException,
+            CannotCompileException {
+        if (pool == null)
+            throw new RuntimeException(
+                    "Evolution has not been linked to ClassPool.");
+
+        CtClass c = pool.get(classname);
+        updatableClassName = classname;
+        updatableClass = makeAbstractClass(c);
     }
 
     /**
      * Produces an abstract class.
      */
     protected CtClass makeAbstractClass(CtClass clazz)
-	throws CannotCompileException, NotFoundException
-    {
-	int i;
-
-	CtClass absClass = pool.makeClass(clazz.getName());
-	absClass.setModifiers(Modifier.PUBLIC | Modifier.ABSTRACT);
-	absClass.setSuperclass(clazz.getSuperclass());
-	absClass.setInterfaces(clazz.getInterfaces());
-
-	// absClass.inheritAllConstructors();
-
-	CtField fld = new CtField(pool.get("java.lang.Class"),
-				  latestVersionField, absClass);
-	fld.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
-
-	CtField.Initializer finit
-	    = CtField.Initializer.byCall(
-		pool.get("sample.evolve.VersionManager"),
-		versionManagerMethod,
-		new String[] { clazz.getName() });
-	absClass.addField(fld, finit);
-
-	CtField[] fs = clazz.getDeclaredFields();
-	for (i = 0; i < fs.length; ++i) {
-	    CtField f = fs[i];
-	    if (Modifier.isPublic(f.getModifiers()))
-		absClass.addField(new CtField(f.getType(), f.getName(),
-					      absClass));
-	}
-
-	CtConstructor[] cs = clazz.getDeclaredConstructors();
-	for (i = 0; i < cs.length; ++i) {
-	    CtConstructor c = cs[i];
-	    int mod = c.getModifiers();
-	    if (Modifier.isPublic(mod)) {
-		CtMethod wm
-		    = CtNewMethod.wrapped(absClass, handlerMethod,
-					  c.getParameterTypes(),
-					  c.getExceptionTypes(),
-					  trapMethod, null, absClass);
-		wm.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
-		absClass.addMethod(wm);
-	    }
-	}
-
-	CtMethod[] ms = clazz.getDeclaredMethods();
-	for (i = 0; i < ms.length; ++i) {
-	    CtMethod m = ms[i];
-	    int mod = m.getModifiers();
-	    if (Modifier.isPublic(mod))
-		if (Modifier.isStatic(mod))
-		    throw new CannotCompileException(
-				"static methods are not supported.");
-		else {
-		    CtMethod m2
-			= CtNewMethod.abstractMethod(m.getReturnType(),
-						     m.getName(),
-						     m.getParameterTypes(),
-						     m.getExceptionTypes(),
-						     absClass);
-		    absClass.addMethod(m2);
-		}
-	}
-
-	return absClass;
+            throws CannotCompileException, NotFoundException {
+        int i;
+
+        CtClass absClass = pool.makeClass(clazz.getName());
+        absClass.setModifiers(Modifier.PUBLIC | Modifier.ABSTRACT);
+        absClass.setSuperclass(clazz.getSuperclass());
+        absClass.setInterfaces(clazz.getInterfaces());
+
+        // absClass.inheritAllConstructors();
+
+        CtField fld = new CtField(pool.get("java.lang.Class"),
+                latestVersionField, absClass);
+        fld.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
+
+        CtField.Initializer finit = CtField.Initializer.byCall(pool
+                .get("sample.evolve.VersionManager"), versionManagerMethod,
+                new String[] { clazz.getName() });
+        absClass.addField(fld, finit);
+
+        CtField[] fs = clazz.getDeclaredFields();
+        for (i = 0; i < fs.length; ++i) {
+            CtField f = fs[i];
+            if (Modifier.isPublic(f.getModifiers()))
+                absClass.addField(new CtField(f.getType(), f.getName(),
+                        absClass));
+        }
+
+        CtConstructor[] cs = clazz.getDeclaredConstructors();
+        for (i = 0; i < cs.length; ++i) {
+            CtConstructor c = cs[i];
+            int mod = c.getModifiers();
+            if (Modifier.isPublic(mod)) {
+                CtMethod wm = CtNewMethod.wrapped(absClass, handlerMethod, c
+                        .getParameterTypes(), c.getExceptionTypes(),
+                        trapMethod, null, absClass);
+                wm.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
+                absClass.addMethod(wm);
+            }
+        }
+
+        CtMethod[] ms = clazz.getDeclaredMethods();
+        for (i = 0; i < ms.length; ++i) {
+            CtMethod m = ms[i];
+            int mod = m.getModifiers();
+            if (Modifier.isPublic(mod))
+                if (Modifier.isStatic(mod))
+                    throw new CannotCompileException(
+                            "static methods are not supported.");
+                else {
+                    CtMethod m2 = CtNewMethod.abstractMethod(m.getReturnType(),
+                            m.getName(), m.getParameterTypes(), m
+                                    .getExceptionTypes(), absClass);
+                    absClass.addMethod(m2);
+                }
+        }
+
+        return absClass;
     }
 
     /**
-     * Modifies the given class file so that it is a subclass of the
-     * abstract class produced by makeAbstractClass().
-     *
+     * Modifies the given class file so that it is a subclass of the abstract
+     * class produced by makeAbstractClass().
+     * 
      * Note: the naming convention must be consistent with
      * VersionManager.update().
      */
-    protected void makeConcreteClass(CtClass clazz,
-				     CtClass abstractClass, int version)
-	throws CannotCompileException, NotFoundException
-    {
-	int i;
-	clazz.setSuperclass(abstractClass);
-	CodeConverter converter = new CodeConverter();
-	CtField[] fs = clazz.getDeclaredFields();
-	for (i = 0; i < fs.length; ++i) {
-	    CtField f = fs[i];
-	    if (Modifier.isPublic(f.getModifiers()))
-		converter.redirectFieldAccess(f, abstractClass, f.getName());
-	}
-
-	CtConstructor[] cs = clazz.getDeclaredConstructors();
-	for (i = 0; i < cs.length; ++i)
-	    cs[i].instrument(converter);
-
-	CtMethod[] ms = clazz.getDeclaredMethods();
-	for (i = 0; i < ms.length; ++i)
-	    ms[i].instrument(converter);
+    protected void makeConcreteClass(CtClass clazz, CtClass abstractClass,
+            int version) throws CannotCompileException, NotFoundException {
+        int i;
+        clazz.setSuperclass(abstractClass);
+        CodeConverter converter = new CodeConverter();
+        CtField[] fs = clazz.getDeclaredFields();
+        for (i = 0; i < fs.length; ++i) {
+            CtField f = fs[i];
+            if (Modifier.isPublic(f.getModifiers()))
+                converter.redirectFieldAccess(f, abstractClass, f.getName());
+        }
+
+        CtConstructor[] cs = clazz.getDeclaredConstructors();
+        for (i = 0; i < cs.length; ++i)
+            cs[i].instrument(converter);
+
+        CtMethod[] ms = clazz.getDeclaredMethods();
+        for (i = 0; i < ms.length; ++i)
+            ms[i].instrument(converter);
     }
 }

sample/evolve/VersionManager.java

@@ -2,89 +2,89 @@ package sample.evolve;
 
 import java.util.Hashtable;
 import java.lang.reflect.*;
-import javassist.CtClass;
 
 /**
  * Runtime system for class evolution
  */
 public class VersionManager {
     private static Hashtable versionNo = new Hashtable();
+
     public final static String latestVersionField = "_version";
 
     /**
      * For updating the definition of class my.X, say:
-     *
+     * 
      * VersionManager.update("my.X");
      */
     public static void update(String qualifiedClassname)
-	throws CannotUpdateException
-    {
-	try {
-	    Class c = getUpdatedClass(qualifiedClassname);
-	    Field f = c.getField(latestVersionField);
-	    f.set(null, c);
-	}
-	catch (ClassNotFoundException e) {
-	    throw new CannotUpdateException("cannot update class: "
-					    + qualifiedClassname);
-	}
-	catch (Exception e) {
-	    throw new CannotUpdateException(e);
-	}
+            throws CannotUpdateException {
+        try {
+            Class c = getUpdatedClass(qualifiedClassname);
+            Field f = c.getField(latestVersionField);
+            f.set(null, c);
+        }
+        catch (ClassNotFoundException e) {
+            throw new CannotUpdateException("cannot update class: "
+                    + qualifiedClassname);
+        }
+        catch (Exception e) {
+            throw new CannotUpdateException(e);
+        }
     }
 
     private static Class getUpdatedClass(String qualifiedClassname)
-	throws ClassNotFoundException
-    {
-	int version;
-	Object found = versionNo.get(qualifiedClassname);
-	if (found == null)
-	    version = 0;
-	else
-	    version = ((Integer)found).intValue() + 1;
+            throws ClassNotFoundException {
+        int version;
+        Object found = versionNo.get(qualifiedClassname);
+        if (found == null)
+            version = 0;
+        else
+            version = ((Integer)found).intValue() + 1;
 
-	Class c = Class.forName(qualifiedClassname + '$' + version);
-	versionNo.put(qualifiedClassname, new Integer(version));
-	return c;
+        Class c = Class.forName(qualifiedClassname + '$' + version);
+        versionNo.put(qualifiedClassname, new Integer(version));
+        return c;
     }
 
-    /* initiaVersion() is used to initialize the _version field of
-     * the updatable classes.
+    /*
+     * initiaVersion() is used to initialize the _version field of the updatable
+     * classes.
      */
     public static Class initialVersion(String[] params) {
-	try {
-	    return getUpdatedClass(params[0]);
-	}
-	catch (ClassNotFoundException e) {
-	    throw new RuntimeException("cannot initialize " + params[0]);
-	}
+        try {
+            return getUpdatedClass(params[0]);
+        }
+        catch (ClassNotFoundException e) {
+            throw new RuntimeException("cannot initialize " + params[0]);
+        }
     }
 
-    /** make() performs the object creation of the updatable classes.
-     * The expression "new <updatable class>" is replaced with a call
-     * to this method.
+    /**
+     * make() performs the object creation of the updatable classes. The
+     * expression "new <updatable class>" is replaced with a call to this
+     * method.
      */
     public static Object make(Class clazz, Object[] args) {
-	Constructor[] constructors = clazz.getConstructors();
-	int n = constructors.length;
-	for (int i = 0; i < n; ++i) {
-	    try {
-		return constructors[i].newInstance(args);
-	    }
-	    catch (IllegalArgumentException e) {
-		// try again
-	    }
-	    catch (InstantiationException e) {
-		throw new CannotCreateException(e);
-	    }
-	    catch (IllegalAccessException e) {
-		throw new CannotCreateException(e);
-	    }
-	    catch (InvocationTargetException e) {
-		throw new CannotCreateException(e);
-	    }
-	}
+        Constructor[] constructors = clazz.getConstructors();
+        int n = constructors.length;
+        for (int i = 0; i < n; ++i) {
+            try {
+                return constructors[i].newInstance(args);
+            }
+            catch (IllegalArgumentException e) {
+                // try again
+            }
+            catch (InstantiationException e) {
+                throw new CannotCreateException(e);
+            }
+            catch (IllegalAccessException e) {
+                throw new CannotCreateException(e);
+            }
+            catch (InvocationTargetException e) {
+                throw new CannotCreateException(e);
+            }
+        }
 
-	throw new CannotCreateException("no constructor matches");
+        throw new CannotCreateException("no constructor matches");
     }
 }

sample/reflect/Main.java

@@ -1,6 +1,5 @@
 package sample.reflect;
 
-import javassist.reflect.ClassMetaobject;
 import javassist.reflect.Loader;
 
 /*
@@ -23,11 +22,11 @@ import javassist.reflect.Loader;
 */
 public class Main {
     public static void main(String[] args) throws Throwable {
-	Loader cl = (Loader)Main.class.getClassLoader();
-	cl.makeReflective("sample.reflect.Person",
-			  "sample.reflect.VerboseMetaobj",
-			  "javassist.reflect.ClassMetaobject");
+        Loader cl = (Loader)Main.class.getClassLoader();
+        cl.makeReflective("sample.reflect.Person",
+                          "sample.reflect.VerboseMetaobj",
+                          "javassist.reflect.ClassMetaobject");
 
-	cl.run("sample.reflect.Person", args);
+        cl.run("sample.reflect.Person", args);
     }
 }

sample/reflect/Person.java

@@ -1,6 +1,6 @@
 /*
-  A base-level class controlled by VerboseMetaobj.
-*/
+ * A base-level class controlled by VerboseMetaobj.
+ */
 
 package sample.reflect;
 
@@ -9,43 +9,45 @@ import javassist.reflect.Metaobject;
 
 public class Person {
     public String name;
+
     public static int birth = 3;
+
     public static final String defaultName = "John";
 
     public Person(String name, int birthYear) {
-	if (name == null)
-	    this.name = defaultName;
-	else
-	    this.name = name;
+        if (name == null)
+            this.name = defaultName;
+        else
+            this.name = name;
 
-	this.birth = birthYear;
+        birth = birthYear;
     }
 
     public String getName() {
-	return name;
+        return name;
     }
 
     public int getAge(int year) {
-	return year - birth;
+        return year - birth;
     }
 
     public static void main(String[] args) {
-	String name;
-	if (args.length > 0)
-	    name = args[0];
-	else
-	    name = "Bill";
-
-	Person p = new Person(name, 1960);
-	System.out.println("name: " + p.getName());
-	System.out.println("object: " + p.toString());
-
-	// change the metaobject of p.
-	if (p instanceof Metalevel) {
-	    ((Metalevel)p)._setMetaobject(new Metaobject(p, null));
-	    System.out.println("<< the metaobject was changed.>>");
-	}
-
-	System.out.println("age: " + p.getAge(1999));
+        String name;
+        if (args.length > 0)
+            name = args[0];
+        else
+            name = "Bill";
+
+        Person p = new Person(name, 1960);
+        System.out.println("name: " + p.getName());
+        System.out.println("object: " + p.toString());
+
+        // change the metaobject of p.
+        if (p instanceof Metalevel) {
+            ((Metalevel)p)._setMetaobject(new Metaobject(p, null));
+            System.out.println("<< the metaobject was changed.>>");
+        }
+
+        System.out.println("age: " + p.getAge(1999));
     }
 }

sample/reflect/VerboseMetaobj.java

@@ -1,29 +1,27 @@
 package sample.reflect;
 
-import javassist.*;
 import javassist.reflect.*;
 
 public class VerboseMetaobj extends Metaobject {
     public VerboseMetaobj(Object self, Object[] args) {
-	super(self, args);
-	System.out.println("** constructed: " + self.getClass().getName());
+        super(self, args);
+        System.out.println("** constructed: " + self.getClass().getName());
     }
 
     public Object trapFieldRead(String name) {
-	System.out.println("** field read: " + name);
-	return super.trapFieldRead(name);
+        System.out.println("** field read: " + name);
+        return super.trapFieldRead(name);
     }
 
     public void trapFieldWrite(String name, Object value) {
-	System.out.println("** field write: " + name);
-	super.trapFieldWrite(name, value);
+        System.out.println("** field write: " + name);
+        super.trapFieldWrite(name, value);
     }
 
     public Object trapMethodcall(int identifier, Object[] args)
-	throws Throwable
-    {
-	System.out.println("** trap: " + getMethodName(identifier)
-			   + "() in " + getClassMetaobject().getName());
-	return super.trapMethodcall(identifier, args);
+            throws Throwable {
+        System.out.println("** trap: " + getMethodName(identifier) + "() in "
+                + getClassMetaobject().getName());
+        return super.trapMethodcall(identifier, args);
     }
 }