implemented getMethodIndex() in javassist.reflect.ClassMetaobject

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

diff --git a/src/main/javassist/CannotCompileException.java b/src/main/javassist/CannotCompileException.java
index 0a575577530ef454d7ee7d34cde88b84a7915960..6bb5c038b5ef587ca32cbd6533ae267499084304 100644 (file)
--- a/src/main/javassist/CannotCompileException.java
+++ b/src/main/javassist/CannotCompileException.java
@@ -22,6 +22,7 @@ import javassist.compiler.CompileError;
  */
 public class CannotCompileException extends Exception {
     private String message;
+    private Throwable cause;
 
     public String getReason() {
         if (message != null)
@@ -36,6 +37,7 @@ public class CannotCompileException extends Exception {
     public CannotCompileException(String msg) {
         super(msg);
         message = msg;
+        cause = null;
     }
 
     /**
@@ -44,6 +46,12 @@ public class CannotCompileException extends Exception {
     public CannotCompileException(Throwable e) {
         super("by " + e.toString());
         message = null;
+        cause = e;
+    }
+
+    public CannotCompileException(String msg, Throwable e) {
+        this(msg);
+        cause = e;
     }
 
     /**
@@ -51,14 +59,14 @@ public class CannotCompileException extends Exception {
      * <code>NotFoundException</code>.
      */
     public CannotCompileException(NotFoundException e) {
-        this("cannot find " + e.getMessage());
+        this("cannot find " + e.getMessage(), e);
     }
 
     /**
      * Constructs a CannotCompileException with an <code>CompileError</code>.
      */
     public CannotCompileException(CompileError e) {
-        super("[source error] " + e.getMessage());
+        super("[source error] " + e.getMessage(), e);
         message = null;
     }
 
@@ -67,13 +75,22 @@ public class CannotCompileException extends Exception {
      * with a <code>ClassNotFoundException</code>.
      */
     public CannotCompileException(ClassNotFoundException e, String name) {
-        this("cannot find " + name);
+        this("cannot find " + name, e);
     }
 
     /**
      * Constructs a CannotCompileException with a ClassFormatError.
      */
     public CannotCompileException(ClassFormatError e, String name) {
-        this("invalid class format: " + name);
+        this("invalid class format: " + name, e);
+    }
+
+    /**
+     * Prints this exception and its backtrace.
+     */
+    public void printStackTrace(java.io.PrintWriter w) {
+        super.printStackTrace(w);
+        w.println("Caused by:");
+        cause.printStackTrace(w);
     }
 }

diff --git a/src/main/javassist/reflect/ClassMetaobject.java b/src/main/javassist/reflect/ClassMetaobject.java
index ef21bafc90411e3cc854c60ab4b5a57ceefe44b9..7a149e7d34da5d56b587d324748fd8dc7948a018 100644 (file)
--- a/src/main/javassist/reflect/ClassMetaobject.java
+++ b/src/main/javassist/reflect/ClassMetaobject.java
@@ -16,6 +16,7 @@
 package javassist.reflect;
 
 import java.lang.reflect.*;
+import java.util.Arrays;
 import java.io.Serializable;
 import java.io.IOException;
 import java.io.ObjectInputStream;
@@ -28,7 +29,14 @@ import java.io.ObjectOutputStream;
  * class of reflective objects.  It can be used to hold values
  * shared among the reflective objects of the same class.
  *
+ * <p>To obtain a class metaobject, calls <code>_getClass()</code>
+ * on a reflective object.  For example,
+ *
+ * <ul><pre>ClassMetaobject cm = ((Metalevel)reflectiveObject)._getClass();
+ * </pre></ul>
+ *
  * @see javassist.reflect.Metaobject
+ * @see javassist.reflect.Metalevel
  */
 public class ClassMetaobject implements Serializable {
     /**
@@ -266,6 +274,22 @@ public class ClassMetaobject implements Serializable {
         return methods;
     }
 
+    /**
+     * Returns the <code>java.lang.reflect.Method</code> object representing
+     * the method specified by <code>identifier</code>.
+     *
+     * <p>Note that the actual method returned will be have an altered,
+     * reflective name i.e. <code>_m_2_..</code>.
+     *
+     * @param identifier        the identifier index
+     *                          given to <code>trapMethodcall()</code> etc.
+     * @see Metaobject#trapMethodcall(int,Object[])
+     * @see #trapMethodcall(int,Object[])
+     */
+    public final Method getMethod(int identifier) {
+        return getReflectiveMethods()[identifier];
+    }
+
     /**
      * Returns the name of the method specified
      * by <code>identifier</code>.
@@ -298,4 +322,40 @@ public class ClassMetaobject implements Serializable {
     public final Class getReturnType(int identifier) {
         return getReflectiveMethods()[identifier].getReturnType();
     }
+
+    /**
+     * Returns the identifier index of the method, as identified by its
+     * original name.
+     *
+     * <p>This method is useful, in conjuction with
+     * <link>ClassMetaobject#getMethod()</link>, to obtain a quick reference
+     * to the original method in the reflected class (i.e. not the proxy
+     * method), using the original name of the method.
+     *
+     * @param originalName      The original name of the reflected method
+     * @param argTypes          array of Class specifying the method signature
+     * @return      the identifier index of the original method
+     * @throws NoSuchMethodException    if the method does not exist
+     * 
+     * @see ClassMetaobject#getMethod(int)
+     * @author Brett Randall
+     * @author Shigeru Chiba
+     */
+    public final int getMethodIndex(String originalName, Class[] argTypes)
+        throws NoSuchMethodException
+    {
+        Method[] mthds = getReflectiveMethods();
+        for (int i = 0; i < mthds.length; i++) {
+            if (mthds[i] == null)
+                continue;
+
+            // check name and parameter types match
+            if (getMethodName(i).equals(originalName)
+                && Arrays.equals(argTypes, mthds[i].getParameterTypes()))
+                return i;
+        }
+
+        throw new NoSuchMethodException("Method " + originalName
+                                        + " not found");
+    }
 }

diff --git a/src/main/javassist/reflect/Metaobject.java b/src/main/javassist/reflect/Metaobject.java
index 250293daf72a5e564660a2e01eef83a6251eea93..20d23433de489875fc2c2926aa8dd39634d371ee 100644 (file)
--- a/src/main/javassist/reflect/Metaobject.java
+++ b/src/main/javassist/reflect/Metaobject.java
@@ -33,7 +33,14 @@ import java.io.ObjectOutputStream;
  * of the method calls, a subclass of <code>Metaobject</code>
  * should be defined.
  *
+ * <p>To obtain a metaobject, calls <code>_getMetaobject()</code>
+ * on a reflective object.  For example,
+ *
+ * <ul><pre>Metaobject m = ((Metalevel)reflectiveObject)._getMetaobject();
+ * </pre></ul>
+ *
  * @see javassist.reflect.ClassMetaobject
+ * @see javassist.reflect.Metalevel
  */
 public class Metaobject implements Serializable {
     protected ClassMetaobject classmetaobject;