示例#1
0
 /**
  * Insert the source code details, if available.
  *
  * @param ped The given program element.
  */
 public void addSourcePosition(ProgramElementDoc ped, int indent) {
   if (!addSrcInfo) return;
   if (JDiff.javaVersion.startsWith("1.1")
       || JDiff.javaVersion.startsWith("1.2")
       || JDiff.javaVersion.startsWith("1.3")) {
     return; // position() only appeared in J2SE1.4
   }
   try {
     // Could cache the method for improved performance
     Class c = ProgramElementDoc.class;
     Method m = c.getMethod("position", null);
     Object sp = m.invoke(ped, null);
     if (sp != null) {
       for (int i = 0; i < indent; i++) outputFile.print(" ");
       outputFile.println("src=\"" + sp + "\"");
     }
   } catch (NoSuchMethodException e2) {
     System.err.println("Error: method \"position\" not found");
     e2.printStackTrace();
   } catch (IllegalAccessException e4) {
     System.err.println("Error: class not permitted to be instantiated");
     e4.printStackTrace();
   } catch (InvocationTargetException e5) {
     System.err.println("Error: method \"position\" could not be invoked");
     e5.printStackTrace();
   } catch (Exception e6) {
     System.err.println("Error: ");
     e6.printStackTrace();
   }
 }
示例#2
0
  private void addClass(Class<?> c) {
    if (classes.add(c)) {
      if (c.getSuperclass() != null) {
        addClass(c.getSuperclass());
      }
      for (Class<?> sc : c.getInterfaces()) {
        addClass(sc);
      }
      for (Class<?> dc : c.getDeclaredClasses()) {
        addClass(dc);
      }
      for (Method m : c.getDeclaredMethods()) {
        addClass(m.getReturnType());
        for (Class<?> p : m.getParameterTypes()) {
          addClass(p);
        }
      }

      if (c != void.class && dimensions(c) < 2) {
        Class<?> arrayClass = Array.newInstance(c, 0).getClass();
        arrayClasses.put(c, arrayClass);
        addClass(arrayClass);
      }
    }
  }
示例#3
0
 private void commandMethods(StringTokenizer t) throws NoSessionException {
   if (!t.hasMoreTokens()) {
     env.error("No class specified.");
     return;
   }
   String idClass = t.nextToken();
   ReferenceType cls = findClass(idClass);
   if (cls != null) {
     List<Method> methods = cls.allMethods();
     OutputSink out = env.getOutputSink();
     for (int i = 0; i < methods.size(); i++) {
       Method method = methods.get(i);
       out.print(method.declaringType().name() + " " + method.name() + "(");
       Iterator<String> it = method.argumentTypeNames().iterator();
       if (it.hasNext()) {
         while (true) {
           out.print(it.next());
           if (!it.hasNext()) {
             break;
           }
           out.print(", ");
         }
       }
       out.println(")");
     }
     out.show();
   } else {
     // ### Should validate class name syntax.
     env.failure("\"" + idClass + "\" is not a valid id or class name.");
   }
 }
示例#4
0
  private boolean invokeMethod(String line, PrintWriter out, Method method, String[] fields)
      throws IllegalAccessException, InvocationTargetException {
    ArrayList<Object> methodArguments = new ArrayList<Object>();

    Class<?>[] parameterTypes = method.getParameterTypes();
    if (parameterTypes.length == 2
        && parameterTypes[0] == PrintWriter.class
        && parameterTypes[1] == String.class) {
      // FIXME: there must be a better way to say "I want to parse the line myself."
      methodArguments.add(out);
      methodArguments.add(line);
    } else {
      int nextField = 1;
      for (Class<?> parameterType : parameterTypes) {
        if (parameterType == PrintWriter.class) {
          methodArguments.add(out);
        } else if (parameterType == String.class) {
          methodArguments.add(fields[nextField++]);
        }
        // FIXME: support other common types. "int" seems a likely first candidate.
      }
    }

    method.invoke(handler, methodArguments.toArray());
    return true;
  }
示例#5
0
 void addIfTestMethod(Method m) {
   if (m.getAnnotation(Test.class) == null) return;
   if (!(m.getReturnType().equals(boolean.class) || m.getReturnType().equals(void.class)))
     throw new RuntimeException("@Test method" + " must return boolean or void");
   m.setAccessible(true); // In case it's private, etc.
   add(m);
 }
  static {
    try {
      Map<String, Method> orderedMethods = new TreeMap<String, Method>();
      for (Method m : MBeanServerConnection.class.getDeclaredMethods()) {
        orderedMethods.put(m.toGenericString(), m);
      }
      Method[] methods = orderedMethods.values().toArray(new Method[orderedMethods.size()]);
      Map<String, Method> asynchMethods = new TreeMap<String, Method>();
      for (Method asynchMethod : AsynchJMXResponseListener.class.getDeclaredMethods()) {
        asynchMethods.put(asynchMethod.getName(), asynchMethod);
      }

      Map<Method, Byte> m2k = new HashMap<Method, Byte>(methods.length);
      Map<Byte, Method> k2m = new HashMap<Byte, Method>(methods.length);
      Map<Byte, Method> k2am = new HashMap<Byte, Method>(methods.length);
      for (int i = 0; i < methods.length; i++) {
        m2k.put(methods[i], (byte) i);
        k2m.put((byte) i, methods[i]);
        Method asynchMethod = asynchMethods.get(methods[i].getName() + "Response");
        if (asynchMethod == null)
          throw new RuntimeException(
              "Failed to find asynch handler for [" + methods[i].toGenericString() + "]",
              new Throwable());
        k2am.put((byte) i, asynchMethod);
      }
      methodToKey = Collections.unmodifiableMap(m2k);
      keyToMethod = Collections.unmodifiableMap(k2m);
      keyToAsynchMethod = Collections.unmodifiableMap(k2am);
    } catch (Exception ex) {
      throw new RuntimeException(ex);
    }
  }
示例#7
0
 /**
  * Gets the ObjectLoader for the specified class.
  *
  * @param classtype the class
  * @return the ObjectLoader
  */
 public static XML.ObjectLoader getLoader(Class classtype) {
   // look for registered loader first
   ObjectLoader loader = (ObjectLoader) loaders.get(classtype);
   // if no registered loader, look for static getLoader() method in class
   if (loader == null) {
     try {
       Method method = classtype.getMethod("getLoader", (Class[]) null); // $NON-NLS-1$
       if (method != null && Modifier.isStatic(method.getModifiers())) {
         loader = (ObjectLoader) method.invoke(null, (Object[]) null);
         if (loader != null) {
           // register loader for future calls
           setLoader(classtype, loader);
         }
       }
     } catch (Exception ex) {
       /** empty block */
     }
   }
   // if still no loader found, use the default loader
   if (loader == null) {
     if (defaultLoader == null) {
       defaultLoader = new XMLLoader();
     }
     loader = defaultLoader;
   }
   return loader;
 }
示例#8
0
文件: Macro.java 项目: bramk/bnd
 private String doCommand(Object target, String method, String[] args) {
   if (target == null) ; // System.err.println("Huh? Target should never be null " +
   // domain);
   else {
     String cname = "_" + method.replaceAll("-", "_");
     try {
       Method m = target.getClass().getMethod(cname, new Class[] {String[].class});
       return (String) m.invoke(target, new Object[] {args});
     } catch (NoSuchMethodException e) {
       // Ignore
     } catch (InvocationTargetException e) {
       if (e.getCause() instanceof IllegalArgumentException) {
         domain.error(
             "%s, for cmd: %s, arguments; %s",
             e.getCause().getMessage(), method, Arrays.toString(args));
       } else {
         domain.warning("Exception in replace: %s", e.getCause());
         e.getCause().printStackTrace();
       }
     } catch (Exception e) {
       domain.warning("Exception in replace: " + e + " method=" + method);
       e.printStackTrace();
     }
   }
   return null;
 }
 Document parseDocument(String filename) throws Exception {
   FileReader reader = new FileReader(filename);
   String firstLine = new BufferedReader(reader).readLine();
   reader.close();
   Document document = null;
   if (firstLine.startsWith("<?xml")) {
     System.err.println("XML detected; using default XML parser.");
   } else {
     try {
       Class nekoParserClass = Class.forName("org.cyberneko.html.parsers.DOMParser");
       Object parser = nekoParserClass.newInstance();
       Method parse = nekoParserClass.getMethod("parse", new Class[] {String.class});
       Method getDocument = nekoParserClass.getMethod("getDocument", new Class[0]);
       parse.invoke(parser, filename);
       document = (Document) getDocument.invoke(parser);
     } catch (Exception e) {
       System.err.println("NekoHTML HTML parser not found; HTML4 support disabled.");
     }
   }
   if (document == null) {
     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     try { // http://www.w3.org/blog/systeam/2008/02/08/w3c_s_excessive_dtd_traffic
       factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
     } catch (ParserConfigurationException e) {
       System.err.println("Warning: Could not disable external DTD loading");
     }
     DocumentBuilder builder = factory.newDocumentBuilder();
     document = builder.parse(filename);
   }
   return document;
 }
示例#10
0
  /** Creates the URL connection. */
  protected URLConnection openConnection(URL url) throws IOException {
    URLConnection conn = url.openConnection();

    conn.setDoOutput(true);

    if (_readTimeout > 0) {
      try {
        // only available for JDK 1.5
        Method method = conn.getClass().getMethod("setReadTimeout", new Class[] {int.class});

        if (method != null) method.invoke(conn, new Object[] {new Integer((int) _readTimeout)});
      } catch (Throwable e) {
      }
    }

    conn.setRequestProperty("Content-Type", "x-application/hessian");

    if (_basicAuth != null) conn.setRequestProperty("Authorization", _basicAuth);
    else if (_user != null && _password != null) {
      _basicAuth = "Basic " + base64(_user + ":" + _password);
      conn.setRequestProperty("Authorization", _basicAuth);
    }

    return conn;
  }
示例#11
0
 /* gets target VM version from the given VMVersionMismatchException.
  * Note that we need to reflectively call the method because of we may
  * have got this from different classloader's namespace */
 private static String getVMVersion(Throwable throwable)
     throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
   // assert isVMVersionMismatch(throwable), "not a VMVersionMismatch"
   Class expClass = throwable.getClass();
   Method targetVersionMethod = expClass.getMethod("getTargetVersion", new Class[0]);
   return (String) targetVersionMethod.invoke(throwable);
 }
示例#12
0
 // we set an observer to detect VirtualMachineImpl.dispose call
 // and on dispose we add corresponding VirtualMachineImpl.class to
 // free VirtualMachimeImpl Class list.
 protected static void setVMDisposeObserver(final Object vm) {
   try {
     Method setDisposeObserverMethod =
         vm.getClass()
             .getDeclaredMethod("setDisposeObserver", new Class[] {java.util.Observer.class});
     setDisposeObserverMethod.setAccessible(true);
     setDisposeObserverMethod.invoke(
         vm,
         new Object[] {
           new Observer() {
             public void update(Observable o, Object data) {
               if (DEBUG) {
                 System.out.println("got VM.dispose notification");
               }
               addFreeVMImplClass(vm.getClass());
             }
           }
         });
   } catch (Exception exp) {
     if (DEBUG) {
       System.out.println("setVMDisposeObserver() got an exception:");
       exp.printStackTrace();
     }
   }
 }
示例#13
0
  void enableLionFS() {
    try {
      String version = System.getProperty("os.version");
      String[] tokens = version.split("\\.");
      int major = Integer.parseInt(tokens[0]), minor = 0;
      if (tokens.length > 1) minor = Integer.parseInt(tokens[1]);
      if (major < 10 || (major == 10 && minor < 7))
        throw new Exception("Operating system version is " + version);

      Class fsuClass = Class.forName("com.apple.eawt.FullScreenUtilities");
      Class argClasses[] = new Class[] {Window.class, Boolean.TYPE};
      Method setWindowCanFullScreen = fsuClass.getMethod("setWindowCanFullScreen", argClasses);
      setWindowCanFullScreen.invoke(fsuClass, this, true);

      Class fsListenerClass = Class.forName("com.apple.eawt.FullScreenListener");
      InvocationHandler fsHandler = new MyInvocationHandler(cc);
      Object proxy =
          Proxy.newProxyInstance(
              fsListenerClass.getClassLoader(), new Class[] {fsListenerClass}, fsHandler);
      argClasses = new Class[] {Window.class, fsListenerClass};
      Method addFullScreenListenerTo = fsuClass.getMethod("addFullScreenListenerTo", argClasses);
      addFullScreenListenerTo.invoke(fsuClass, this, proxy);

      canDoLionFS = true;
    } catch (Exception e) {
      vlog.debug("Could not enable OS X 10.7+ full-screen mode:");
      vlog.debug("  " + e.toString());
    }
  }
 private static double toDouble(Object value) {
   if (value instanceof Number) {
     return ((Number) value).doubleValue();
   } else if (value instanceof String) {
     return ScriptRuntime.toNumber((String) value);
   } else if (value instanceof Scriptable) {
     if (value instanceof Wrapper) {
       // XXX: optimize tail-recursion?
       return toDouble(((Wrapper) value).unwrap());
     } else {
       return ScriptRuntime.toNumber(value);
     }
   } else {
     Method meth;
     try {
       meth = value.getClass().getMethod("doubleValue", (Class[]) null);
     } catch (NoSuchMethodException e) {
       meth = null;
     } catch (SecurityException e) {
       meth = null;
     }
     if (meth != null) {
       try {
         return ((Number) meth.invoke(value, (Object[]) null)).doubleValue();
       } catch (IllegalAccessException e) {
         // XXX: ignore, or error message?
         reportConversionError(value, Double.TYPE);
       } catch (InvocationTargetException e) {
         // XXX: ignore, or error message?
         reportConversionError(value, Double.TYPE);
       }
     }
     return ScriptRuntime.toNumber(value.toString());
   }
 }
示例#15
0
    protected void generateDelegateCode(
        Class intfcl, String genclass, Method method, IndentedWriter iw) throws IOException {

      String mname = method.getName();
      if (jdbc4WrapperMethod(mname)) {
        generateWrapperDelegateCode(intfcl, genclass, method, iw);
        return;
      }

      Class retType = method.getReturnType();

      iw.println("if (proxyConn != null) proxyConn.maybeDirtyTransaction();");
      iw.println();

      if (mname.equals("close")) {
        iw.println("if (! this.isDetached())");
        iw.println("{");
        iw.upIndent();

        iw.println("if (creator instanceof Statement)");
        iw.upIndent();
        iw.println(
            "parentPooledConnection.markInactiveResultSetForStatement( (Statement) creator, inner );");
        iw.downIndent();
        iw.println("else if (creator instanceof DatabaseMetaData)");
        iw.upIndent();
        iw.println("parentPooledConnection.markInactiveMetaDataResultSet( inner );");
        iw.downIndent();
        iw.println("else if (creator instanceof Connection)");
        iw.upIndent();
        iw.println("parentPooledConnection.markInactiveRawConnectionResultSet( inner );");
        iw.downIndent();
        iw.println(
            "else throw new InternalError(\042Must be Statement or DatabaseMetaData -- Bad Creator: \042 + creator);");

        iw.println(
            "if (creatorProxy instanceof ProxyResultSetDetachable) ((ProxyResultSetDetachable) creatorProxy).detachProxyResultSet( this );");

        iw.println("this.detach();");
        iw.println("inner.close();");
        iw.println("this.inner = null;");

        iw.downIndent();
        iw.println("}");
      } else if (mname.equals("getStatement")) {
        iw.println("if (creator instanceof Statement)");
        iw.upIndent();
        iw.println("return (Statement) creatorProxy;");
        iw.downIndent();
        iw.println("else if (creator instanceof DatabaseMetaData)");
        iw.upIndent();
        iw.println("return null;");
        iw.downIndent();
        iw.println(
            "else throw new InternalError(\042Must be Statement or DatabaseMetaData -- Bad Creator: \042 + creator);");
      } else if (mname.equals("isClosed")) {
        iw.println("return this.isDetached();");
      } else super.generateDelegateCode(intfcl, genclass, method, iw);
    }
示例#16
0
 static Method lookup(String method) {
   for (Method m : Method.values()) {
     if (m.toString().equalsIgnoreCase(method)) {
       return m;
     }
   }
   return null;
 }
 /**
  * Given the name and parameters, invoke the method in the builder. This method is required to
  * invoke the appropriate build method as instructed by the builder XML file.
  *
  * @param methodName the name of the method that we would like to invoke.
  * @param paramClasses the types for each parameter.
  * @param params the parameters of the method.
  */
 protected void invokeMethod(String methodName, Class<?>[] paramClasses, Object[] params)
     throws Exception {
   if (DEBUG) {
     configuration.root.printError("DEBUG: " + this.getClass().getName() + "." + methodName);
   }
   Method method = this.getClass().getMethod(methodName, paramClasses);
   method.invoke(this, params);
 }
示例#18
0
  static <T> T set(Class<T> interf, Object value) {
    Properties p = new Properties();
    Method ms[] = interf.getMethods();

    for (Method m : ms) {
      p.put(m.getName(), value);
    }
    return Configurable.createConfigurable(interf, (Map<Object, Object>) p);
  }
 private static int linearSearch(ObjArray methods, Symbol name, Symbol signature) {
   int len = (int) methods.getLength();
   for (int index = 0; index < len; index++) {
     Method m = (Method) methods.getObjAt(index);
     if (m.getSignature().equals(signature) && m.getName().equals(name)) {
       return index;
     }
   }
   return -1;
 }
示例#20
0
 private static Method checkForCreatorMethod(Method m) {
   if (m.getAnnotation(TestObjectCreate.class) == null) return null;
   if (!m.getReturnType().equals(testClass))
     throw new RuntimeException(
         "@TestObjectCreate " + "must return instance of Class to be tested");
   if ((m.getModifiers() & java.lang.reflect.Modifier.STATIC) < 1)
     throw new RuntimeException("@TestObjectCreate " + "must be static.");
   m.setAccessible(true);
   return m;
 }
示例#21
0
 public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
   Object obj = null;
   if (CLOSE_METHOD_NAME.equals(m.getName())) {
     SimpleConnectionPool.pushConnectionBackToPool(this);
   } else {
     obj = m.invoke(m_originConnection, args);
   }
   lastAccessTime = System.currentTimeMillis();
   return obj;
 }
  //
  // Examine a single method to see if it raises SQLFeatureNotSupportedException.
  //
  private void vetMethod(
      Object candidate,
      Class iface,
      Method method,
      HashSet<String> unsupportedList,
      HashSet<String> notUnderstoodList)
      throws Exception {
    try {
      method.invoke(candidate, getNullArguments(method.getParameterTypes()));

      // it's ok for the method to succeed
    } catch (Throwable e) {
      if (!(e instanceof InvocationTargetException)) {
        recordUnexpectedError(candidate, iface, method, notUnderstoodList, e);
      } else {
        Throwable cause = e.getCause();

        if (cause instanceof SQLFeatureNotSupportedException) {
          boolean isExcludable = isExcludable(method);

          if (!isExcludable) {
            StackTraceElement[] stack = cause.getStackTrace();
            int i = 0;
            while (i < stack.length && !stack[i].getMethodName().equals("notImplemented")) {
              ++i;
            }
            while (i < stack.length && stack[i].getMethodName().equals("notImplemented")) {
              ++i;
            }
            if (i == stack.length) {
              // cause.printStackTrace();
            }

            unsupportedList.add(
                candidate.getClass().getName()
                    + ": "
                    + method
                    + "@"
                    + (i == stack.length ? "no source" : cause.getStackTrace()[i]));
          } else {

          }
        } else if (cause instanceof SQLException) {
          // swallow other SQLExceptions, caused by bogus args
        } else if (cause instanceof NullPointerException) {
          // swallow other NPEs, caused by bogus args
        } else if (cause instanceof ArrayIndexOutOfBoundsException) {
          // swallow these, caused by bogus args
        } else {
          recordUnexpectedError(candidate, iface, method, notUnderstoodList, cause);
        }
      }
    }
  }
示例#23
0
 private void dumpStack(ThreadReference thread, boolean showPC) {
   // ### Check for these.
   // env.failure("Thread no longer exists.");
   // env.failure("Target VM must be in interrupted state.");
   // env.failure("Current thread isn't suspended.");
   // ### Should handle extremely long stack traces sensibly for user.
   List<StackFrame> stack = null;
   try {
     stack = thread.frames();
   } catch (IncompatibleThreadStateException e) {
     env.failure("Thread is not suspended.");
   }
   // ### Fix this!
   // ### Previously mishandled cases where thread was not current.
   // ### Now, prints all of the stack regardless of current frame.
   int frameIndex = 0;
   // int frameIndex = context.getCurrentFrameIndex();
   if (stack == null) {
     env.failure("Thread is not running (no stack).");
   } else {
     OutputSink out = env.getOutputSink();
     int nFrames = stack.size();
     for (int i = frameIndex; i < nFrames; i++) {
       StackFrame frame = stack.get(i);
       Location loc = frame.location();
       Method meth = loc.method();
       out.print("  [" + (i + 1) + "] ");
       out.print(meth.declaringType().name());
       out.print('.');
       out.print(meth.name());
       out.print(" (");
       if (meth.isNative()) {
         out.print("native method");
       } else if (loc.lineNumber() != -1) {
         try {
           out.print(loc.sourceName());
         } catch (AbsentInformationException e) {
           out.print("<unknown>");
         }
         out.print(':');
         out.print(loc.lineNumber());
       }
       out.print(')');
       if (showPC) {
         long pc = loc.codeIndex();
         if (pc != -1) {
           out.print(", pc = " + pc);
         }
       }
       out.println();
     }
     out.show();
   }
 }
  private Method findPublicVoidMethod(Class<?> aClass, String methodName) {
    for (Method method : aClass.getDeclaredMethods()) {
      if (isPublic(method.getModifiers())
          && method.getReturnType() == void.class
          && methodName.equals(method.getName())) {
        return method;
      }
    }

    return null;
  }
  /**
   * Computes the set of emit methods in the Assembler for a given IA32 opcode.
   *
   * @param emitters the set of all emit methods
   * @param opcode the opcode being examined
   */
  private static EmitterSet buildSetForOpcode(Method[] emitters, String opcode) {
    EmitterSet s = new EmitterSet();
    for (int i = 0; i < emitters.length; i++) {
      Method m = emitters[i];
      if (m.getName().startsWith("emit" + opcode + "_") || m.getName().equals("emit" + opcode)) {
        s.add(new EmitterDescriptor(m.getName(), m.getParameterTypes()));
      }
    }

    return s;
  }
示例#26
0
 public void toggleLionFS() {
   try {
     Class appClass = Class.forName("com.apple.eawt.Application");
     Method getApplication = appClass.getMethod("getApplication", (Class[]) null);
     Object app = getApplication.invoke(appClass);
     Method requestToggleFullScreen = appClass.getMethod("requestToggleFullScreen", Window.class);
     requestToggleFullScreen.invoke(app, this);
   } catch (Exception e) {
     vlog.debug("Could not toggle OS X 10.7+ full-screen mode:");
     vlog.debug("  " + e.toString());
   }
 }
示例#27
0
 @SuppressWarnings("unchecked")
 private void addMethods(List list, boolean isStatic) {
   int count = klass.getMethodCount(isStatic);
   for (int i = 0; i != count; ++i) {
     Method method = klass.getMethod(i, isStatic);
     if (!method.isHosted()) {
       MethodID mid = new MethodID(method.getOffset(), isStatic);
       ProxyMethod proxyMethod = new ProxyMethod(mid, method);
       list.add(proxyMethod);
     }
   }
 }
 /**
  * This function instantiates an invariant class by using the <type>(PptSlice) constructor.
  *
  * @param theClass the invariant class to be instantiated
  * @param sl the PptSlice representing the variables about which an invariant is determined
  * @return an instance of the class in theClass if one can be constructed, else throw a
  *     RuntimeException
  */
 private static Invariant instantiateClass(Class<? extends Invariant> theClass, PptSlice sl) {
   try {
     Method get_proto = theClass.getMethod("get_proto", new Class<?>[] {});
     Invariant proto = (/*@Prototype*/ Invariant) get_proto.invoke(null, new Object[] {});
     Invariant inv = proto.instantiate(sl);
     return (inv);
   } catch (Exception e) {
     e.printStackTrace(System.out);
     throw new RuntimeException(
         "Error while instantiating invariant " + theClass.getName() + ": " + e.toString());
   }
 }
示例#29
0
 /**
  * `使用反射机制调用方法`
  *
  * @param methodName Method name
  * @param obj Object holder of the method
  * @param paraType Array of parameter types
  * @param paraValue Array of parameters
  * @return Returned object of the method
  */
 public static Object call(String methodName, Object obj, Class[] paraType, Object[] paraValue) {
   try {
     Class cls = obj.getClass();
     Method method = cls.getDeclaredMethod(methodName, paraType);
     // invoke() returns the object returned by the
     // 		underlying method.
     // It returns null, if the underlying method returns void.
     return method.invoke(obj, paraValue);
   } catch (Exception e) {
     e.printStackTrace();
     throw new RuntimeException(e);
   }
 }
    /**
     * This function returns the check_modified method from the class type provided.
     *
     * @param theClass the class in which to find the check_modified method
     * @return the check_modified method if it exists
     * @throws RuntimeException if check_modified does not exist.
     */
    private static Method getCheckModified(Class<? extends Invariant> theClass) {
      Method[] methods = theClass.getMethods();

      Method currentMethod;
      for (int i = 0; i < methods.length; i++) {
        currentMethod = methods[i];
        if (currentMethod.getName().lastIndexOf("check_modified")
            != -1) { // Method should be called check_modified
          return currentMethod;
        }
      }
      throw new RuntimeException("Cannot find check_modified method");
    }