diff options
| -rw-r--r-- | Readme.html | 4 | ||||
| -rw-r--r-- | build.xml | 4 | ||||
| -rw-r--r-- | sample/vector/Test.j | 76 | ||||
| -rw-r--r-- | sample/vector/VectorAssistant.java | 270 |
4 files changed, 177 insertions, 177 deletions
diff --git a/Readme.html b/Readme.html index 14dc8a10..e5dec48f 100644 --- a/Readme.html +++ b/Readme.html @@ -181,12 +181,11 @@ set CLASSPATH=.;javassist.jar <p>This example shows the use of Javassit for producing a class representing a vector of a given type at compile time. -This is a demonstration of the use of <tt>javassist.preproc</tt> package. <p> To run, type the commands: <ul><pre> % javac sample/vector/*.java -% java javassist.preproc.Compiler sample/vector/Test.j +% java sample.preproc.Compiler sample/vector/Test.j % javac sample/vector/Test.java % java sample.vector.Test </pre></ul> @@ -287,6 +286,7 @@ see javassist.Dump. <ul> <li>getEnclosingClass() in javassist.CtClass was renamed to getEnclosingMethod(). + <li>toMethod() in javassist.CtConstructor has been implemented. </ul> <p>- version 3.1 RC2 in September 7, 2005 @@ -179,8 +179,8 @@ Copyright (C) 1999-2005 Shigeru Chiba. All Rights Reserved.</i>]]></bottom> </target> <target name = "sample-vector" depends="sample" > - <echo>javassist.preproc.Compiler sample/vector/Test.j</echo> - <java fork="true" dir="${run.dir}" classname="javassist.preproc.Compiler"> + <echo>sample.preproc.Compiler sample/vector/Test.j</echo> + <java fork="true" dir="${run.dir}" classname="sample.preproc.Compiler"> <classpath refid="classpath"/> <arg line="sample/vector/Test.j"/> </java> diff --git a/sample/vector/Test.j b/sample/vector/Test.j index 6f524c93..4ae7f6b6 100644 --- a/sample/vector/Test.j +++ b/sample/vector/Test.j @@ -1,38 +1,38 @@ -/*
- A sample program using sample.vector.VectorAssistant
- and the javassist.preproc package.
-
- This automatically produces the classes representing vectors of integer
- and vectors of java.lang.String.
-
- To compile and run this program, do as follows:
-
- % java javassist.tool.Compiler sample/vector/Test.j
- % javac sample/vector/Test.java
- % java sample.vector.Test
-
- The first line produces one source file (sample/Test.java) and
- two class files (sample/vector/intVector.class and
- sample/vector/StringVector.class).
-*/
-
-package sample.vector;
-
-import java.util.Vector by sample.vector.VectorAssistant(java.lang.String);
-import java.util.Vector by sample.vector.VectorAssistant(int);
-
-public class Test {
- public static void main(String[] args) {
- intVector iv = new intVector();
- iv.add(3);
- iv.add(4);
- for (int i = 0; i < iv.size(); ++i)
- System.out.println(iv.at(i));
-
- StringVector sv = new StringVector();
- sv.add("foo");
- sv.add("bar");
- for (int i = 0; i < sv.size(); ++i)
- System.out.println(sv.at(i));
- }
-}
+/* + A sample program using sample.vector.VectorAssistant + and the sample.preproc package. + + This automatically produces the classes representing vectors of integer + and vectors of java.lang.String. + + To compile and run this program, do as follows: + + % java sample.preproc.Compiler sample/vector/Test.j + % javac sample/vector/Test.java + % java sample.vector.Test + + The first line produces one source file (sample/Test.java) and + two class files (sample/vector/intVector.class and + sample/vector/StringVector.class). +*/ + +package sample.vector; + +import java.util.Vector by sample.vector.VectorAssistant(java.lang.String); +import java.util.Vector by sample.vector.VectorAssistant(int); + +public class Test { + public static void main(String[] args) { + intVector iv = new intVector(); + iv.add(3); + iv.add(4); + for (int i = 0; i < iv.size(); ++i) + System.out.println(iv.at(i)); + + StringVector sv = new StringVector(); + sv.add("foo"); + sv.add("bar"); + for (int i = 0; i < sv.size(); ++i) + System.out.println(sv.at(i)); + } +} diff --git a/sample/vector/VectorAssistant.java b/sample/vector/VectorAssistant.java index 27d5f702..8b721dbf 100644 --- a/sample/vector/VectorAssistant.java +++ b/sample/vector/VectorAssistant.java @@ -1,135 +1,135 @@ -package sample.vector;
-
-import java.io.IOException;
-import javassist.*;
-import javassist.preproc.Assistant;
-
-/**
- * This is a Javassist program which produce a new class representing
- * vectors of a given type. For example,
- *
- * <ul>import java.util.Vector by sample.vector.VectorAssistant(int)</ul>
- *
- * <p>requests the Javassist preprocessor to substitute the following
- * lines for the original import declaration:
- *
- * <ul><pre>
- * import java.util.Vector;
- * import sample.vector.intVector;
- * </pre></ul>
- *
- * <p>The Javassist preprocessor calls <code>VectorAssistant.assist()</code>
- * and produces class <code>intVector</code> equivalent to:
- *
- * <ul><pre>
- * package sample.vector;
- *
- * public class intVector extends Vector {
- * pubilc void add(int value) {
- * addElement(new Integer(value));
- * }
- *
- * public int at(int index) {
- * return elementAt(index).intValue();
- * }
- * }
- * </pre></ul>
- *
- * <p><code>VectorAssistant.assist()</code> uses
- * <code>sample.vector.Sample</code> and <code>sample.vector.Sample2</code>
- * as a template to produce the methods <code>add()</code> and
- * <code>at()</code>.
- */
-public class VectorAssistant implements Assistant {
- public final String packageName = "sample.vector.";
-
- /**
- * Calls <code>makeSubclass()</code> and produces a new vector class.
- * This method is called by a <code>javassist.preproc.Compiler</code>.
- *
- * @see javassist.preproc.Compiler
- */
- public CtClass[] assist(ClassPool pool, String vec, String[] args)
- throws CannotCompileException
- {
- if (args.length != 1)
- throw new CannotCompileException(
- "VectorAssistant receives a single argument.");
-
- try {
- CtClass subclass;
- CtClass elementType = pool.get(args[0]);
- if (elementType.isPrimitive())
- subclass = makeSubclass2(pool, elementType);
- else
- subclass = makeSubclass(pool, elementType);
-
- CtClass[] results = { subclass, pool.get(vec) };
- return results;
- }
- catch (NotFoundException e) {
- throw new CannotCompileException(e);
- }
- catch (IOException e) {
- throw new CannotCompileException(e);
- }
- }
-
- /**
- * Produces a new vector class. This method does not work if
- * the element type is a primitive type.
- *
- * @param type the type of elements
- */
- public CtClass makeSubclass(ClassPool pool, CtClass type)
- throws CannotCompileException, NotFoundException, IOException
- {
- CtClass vec = pool.makeClass(makeClassName(type));
- vec.setSuperclass(pool.get("java.util.Vector"));
-
- CtClass c = pool.get("sample.vector.Sample");
- CtMethod addmethod = c.getDeclaredMethod("add");
- CtMethod atmethod = c.getDeclaredMethod("at");
-
- ClassMap map = new ClassMap();
- map.put("sample.vector.X", type.getName());
-
- vec.addMethod(CtNewMethod.copy(addmethod, "add", vec, map));
- vec.addMethod(CtNewMethod.copy(atmethod, "at", vec, map));
- vec.writeFile();
- return vec;
- }
-
- /**
- * Produces a new vector class. This uses wrapped methods so that
- * the element type can be a primitive type.
- *
- * @param type the type of elements
- */
- public CtClass makeSubclass2(ClassPool pool, CtClass type)
- throws CannotCompileException, NotFoundException, IOException
- {
- CtClass vec = pool.makeClass(makeClassName(type));
- vec.setSuperclass(pool.get("java.util.Vector"));
-
- CtClass c = pool.get("sample.vector.Sample2");
- CtMethod addmethod = c.getDeclaredMethod("add");
- CtMethod atmethod = c.getDeclaredMethod("at");
-
- CtClass[] args1 = { type };
- CtClass[] args2 = { CtClass.intType };
- CtMethod m
- = CtNewMethod.wrapped(CtClass.voidType, "add", args1,
- null, addmethod, null, vec);
- vec.addMethod(m);
- m = CtNewMethod.wrapped(type, "at", args2,
- null, atmethod, null, vec);
- vec.addMethod(m);
- vec.writeFile();
- return vec;
- }
-
- private String makeClassName(CtClass type) {
- return packageName + type.getSimpleName() + "Vector";
- }
-}
+package sample.vector; + +import java.io.IOException; +import javassist.*; +import sample.preproc.Assistant; + +/** + * This is a Javassist program which produce a new class representing + * vectors of a given type. For example, + * + * <ul>import java.util.Vector by sample.vector.VectorAssistant(int)</ul> + * + * <p>requests the Javassist preprocessor to substitute the following + * lines for the original import declaration: + * + * <ul><pre> + * import java.util.Vector; + * import sample.vector.intVector; + * </pre></ul> + * + * <p>The Javassist preprocessor calls <code>VectorAssistant.assist()</code> + * and produces class <code>intVector</code> equivalent to: + * + * <ul><pre> + * package sample.vector; + * + * public class intVector extends Vector { + * pubilc void add(int value) { + * addElement(new Integer(value)); + * } + * + * public int at(int index) { + * return elementAt(index).intValue(); + * } + * } + * </pre></ul> + * + * <p><code>VectorAssistant.assist()</code> uses + * <code>sample.vector.Sample</code> and <code>sample.vector.Sample2</code> + * as a template to produce the methods <code>add()</code> and + * <code>at()</code>. + */ +public class VectorAssistant implements Assistant { + public final String packageName = "sample.vector."; + + /** + * Calls <code>makeSubclass()</code> and produces a new vector class. + * This method is called by a <code>sample.preproc.Compiler</code>. + * + * @see sample.preproc.Compiler + */ + public CtClass[] assist(ClassPool pool, String vec, String[] args) + throws CannotCompileException + { + if (args.length != 1) + throw new CannotCompileException( + "VectorAssistant receives a single argument."); + + try { + CtClass subclass; + CtClass elementType = pool.get(args[0]); + if (elementType.isPrimitive()) + subclass = makeSubclass2(pool, elementType); + else + subclass = makeSubclass(pool, elementType); + + CtClass[] results = { subclass, pool.get(vec) }; + return results; + } + catch (NotFoundException e) { + throw new CannotCompileException(e); + } + catch (IOException e) { + throw new CannotCompileException(e); + } + } + + /** + * Produces a new vector class. This method does not work if + * the element type is a primitive type. + * + * @param type the type of elements + */ + public CtClass makeSubclass(ClassPool pool, CtClass type) + throws CannotCompileException, NotFoundException, IOException + { + CtClass vec = pool.makeClass(makeClassName(type)); + vec.setSuperclass(pool.get("java.util.Vector")); + + CtClass c = pool.get("sample.vector.Sample"); + CtMethod addmethod = c.getDeclaredMethod("add"); + CtMethod atmethod = c.getDeclaredMethod("at"); + + ClassMap map = new ClassMap(); + map.put("sample.vector.X", type.getName()); + + vec.addMethod(CtNewMethod.copy(addmethod, "add", vec, map)); + vec.addMethod(CtNewMethod.copy(atmethod, "at", vec, map)); + vec.writeFile(); + return vec; + } + + /** + * Produces a new vector class. This uses wrapped methods so that + * the element type can be a primitive type. + * + * @param type the type of elements + */ + public CtClass makeSubclass2(ClassPool pool, CtClass type) + throws CannotCompileException, NotFoundException, IOException + { + CtClass vec = pool.makeClass(makeClassName(type)); + vec.setSuperclass(pool.get("java.util.Vector")); + + CtClass c = pool.get("sample.vector.Sample2"); + CtMethod addmethod = c.getDeclaredMethod("add"); + CtMethod atmethod = c.getDeclaredMethod("at"); + + CtClass[] args1 = { type }; + CtClass[] args2 = { CtClass.intType }; + CtMethod m + = CtNewMethod.wrapped(CtClass.voidType, "add", args1, + null, addmethod, null, vec); + vec.addMethod(m); + m = CtNewMethod.wrapped(type, "at", args2, + null, atmethod, null, vec); + vec.addMethod(m); + vec.writeFile(); + return vec; + } + + private String makeClassName(CtClass type) { + return packageName + type.getSimpleName() + "Vector"; + } +} |