示例#1
0
  /**
   * Generates a new error message based on the excpetion message.
   *
   * @param message the rror message
   */
  public void generateErrorMessage(String message, MethodDescription mDesc) {

    ObjectDescription oDesc = getObjectDescription(getObject(mDesc.getObjectID()));
    String methodName = oDesc.getName() + "." + mDesc.getMethodName() + "()";

    System.err.println("Method \"" + methodName + "\" can't be invoked:" + message);
  }
示例#2
0
  /**
   * Adds an object to this inspector.
   *
   * @param o the object that is to be added
   * @param objID object id of the object that shall be replaced
   */
  public synchronized void replaceObject(Object newObj, int objID)
      throws InterfaceChangedException {

    if (newObj == null) {
      throw new IllegalArgumentException("Argument \"null\" not supported!");
    }

    // objects.getById(objID).setObject(newObj);
    Collection<Object> instances = getObjectsByClassName(newObj.getClass().getName());

    if (instances.size() <= objID) {
      addObject(newObj);
    } else {

      Object oldObj = getObject(objID);

      ObjectDescription oDescOld = getObjectDescription(oldObj);
      ObjectDescription oDescNew = generateObjectDescription(newObj, objID, false);

      if (oDescOld.getSignature().equals(oDescNew.getSignature())) {

        removeObject(objID);
        addObject(newObj, objID);
        objectDescriptions.add(oDescNew);
      } else {
        throw new InterfaceChangedException(
            "Cannot replace object because the interface of the new"
                + " class and the old class are not equal!");
      }
    }
  }
示例#3
0
  /**
   * Returns the object description of an object.
   *
   * @param o the object of the description that is to be returned
   * @return description of the object or <code>null</code> if the requested description cannot be
   *     found
   */
  public ObjectDescription getObjectDescription(Object o) {
    Integer ID = getObjectID(o);

    if (ID == null) {
      return null;
    }

    for (ObjectDescription oD : this.getObjectDescriptions()) {
      if (oD.getID() == ID) {
        return oD;
      }
    }

    return null;
  }
示例#4
0
  /**
   * For each instance of the given class a new instance for replacement will be created if the
   * interface of the specified class has not changed. The purpose of this method is to create
   * instances from updated class, i.e., if the specified class has been recompiled.
   *
   * @param cls the class
   * @param creator instance creator
   * @return a pair containing the old instances (first) and the new instances (second)
   * @throws InterfaceChangedException if the interface of the specified class has changed
   */
  public synchronized Pair<ArrayList<Object>, ArrayList<Object>> replaceAllObjects(
      Class<?> cls, InstanceCreator creator) throws InterfaceChangedException {

    if (cls == null) {
      throw new IllegalArgumentException("Argument \"null\" not supported!");
    }

    ArrayList<Object> newInstances = new ArrayList<Object>();
    ArrayList<Object> oldInstances = new ArrayList<Object>();

    Collection<Object> instances = getObjectsByClassName(cls.getName());

    //        if (instances.isEmpty()) {
    //            throw new IllegalStateException(
    //                    "Cannot replace. No instances found!");
    //        }
    for (Object oldObj : instances) {
      Object newObj;

      newObj = creator.newInstance(cls);

      if (newObj == null) {
        break;
      }

      int objID = getObjectID(oldObj);

      ObjectDescription oDescOld = getObjectDescription(oldObj);
      ObjectDescription oDescNew = generateObjectDescription(newObj, objID, false);

      if (oDescOld.getSignature().equals(oDescNew.getSignature())) {
        oldInstances.add(getObject(objID));

        replaceObject(newObj, objID);
        newInstances.add(newObj);
      } else {
        throw new InterfaceChangedException(
            "Cannot replace object because the interface of the new"
                + " class and the old class are not equal!");
      }
    }

    return new Pair<ArrayList<Object>, ArrayList<Object>>(oldInstances, newInstances);
  }
示例#5
0
  /**
   * Returns the description of a method.
   *
   * @param o object of the method
   * @param methodName name of the method
   * @param params method parameters
   * @return description of the method or <code>null</code> if the requested method could not be
   *     found
   */
  public MethodDescription getMethodDescription(Object o, String methodName, Class... params) {
    ObjectDescription oDesc = getObjectDescription(o);
    MethodDescription result = null;

    ArrayList<Class> paramTypes = new ArrayList<Class>();

    for (Class<?> p : params) {
      //            Class c = p.getClass();
      paramTypes.add(p);
    }

    for (MethodDescription mDesc : oDesc.getMethods()) {
      if (mDesc.getMethodName().equals(methodName)) {
        //                System.out.println("M: " + mDesc.getMethodName());
        boolean isEqual = true;
        for (int i = 0; i < mDesc.getParameterTypes().length; i++) {
          //                    System.out.println(">> P: " +
          //                            mDesc.getParameterTypes()[i].getName());
          //                    System.out.println(">> PE: " + paramTypes.get(i).getName());
          if (!paramTypes.get(i).equals(mDesc.getParameterTypes()[i])) {
            isEqual = false;
            break;
          }
        }
        if (isEqual) {
          result = mDesc;
          result.setParameters(params);

          break;
        }
      }
    }

    //        if (result == null) {
    //            System.err.println(">> MethodDescription not found!"
    //                    + " Wrong name or wrong parameters?");
    //        }

    return result;
  }
示例#6
0
  /**
   * Removes object with specific ID from the inspector.
   *
   * @param ID the ID of the object that is to be removed
   */
  public void removeObject(int ID) {

    // remove object entry
    ObjectEntry removedElement1 = null;
    for (ObjectEntry oEntry : objects) {
      if (oEntry.getID() == ID) {
        removedElement1 = oEntry;
        break;
      }
    }
    objects.remove(removedElement1);

    // remove object description
    ObjectDescription removedElement2 = null;
    for (ObjectDescription oDesc : objectDescriptions) {
      if (oDesc.getID() == ID) {
        removedElement2 = oDesc;
        break;
      }
    }
    objectDescriptions.remove(removedElement2);
  }
示例#7
0
  /**
   * Returns the description of a method.
   *
   * @param o object of the method
   * @param methodName name of the method
   * @param params method parameters
   * @return description of the method
   */
  public MethodDescription getMethodDescriptionFromGUI(
      Object o, String methodName, Object... params) {
    ObjectDescription oDesc = getObjectDescription(o);
    MethodDescription result = null;

    //        ArrayList<Class> paramTypes = new ArrayList<Class>();
    //
    //        for (Object p : params) {
    //            Class c = p.getClass();
    //            paramTypes.add(c);
    //        }
    for (MethodDescription mDesc : oDesc.getMethods()) {
      if (mDesc.getMethodName().equals(methodName)) {
        boolean isEqual = true;
        for (int i = 0; i < mDesc.getParameterTypes().length; i++) {

          if (!params[i].equals(mDesc.getParameterTypes()[i])) {
            isEqual = false;
            break;
          }
        }
        if (isEqual) {
          result = mDesc;
          result.setParameters(params);

          break;
        }
      }
    }

    if (result == null) {
      System.out.println(">> MethodDescription not found!" + " Wrong name or wrong parameters?");
    }

    return result;
  }
示例#8
0
  public ObjectDescription generateObjectDescription(Object o, Integer objID, boolean addObject) {

    ObjectDescription result = null;

    // Object annotations
    ObjectInfo objectInfo = null;

    Annotation[] objectAnnotations = o.getClass().getAnnotations();

    for (Annotation a : objectAnnotations) {
      if (a.annotationType().equals(ObjectInfo.class)) {
        objectInfo = (ObjectInfo) a;
        break;
      }
    }

    if (addObject) {
      ObjectEntry oEntry = new ObjectEntry(o);
      if (objID != null) {
        objects.addWithID(oEntry, objID);
      } else {
        objects.add(oEntry);
        objID = oEntry.getID();
      }
    }

    boolean hasCustomReferenceMethod = false;

    // we need special treatment for proxy objects
    if (o instanceof ProxyObject) {
      ProxyObject proxy = (ProxyObject) o;

      result = proxy.getObjectDescription();

      result.setName(o.getClass().getName());

      result.setID(objID);

      // update objID of methods
      for (MethodDescription mDesc : result.getMethods()) {
        mDesc.setObjectID(objID);
      }

    } else {
      result = new ObjectDescription();
      result.setInfo(objectInfo);

      result.setName(o.getClass().getName());

      result.setID(objID);

      Class<?> c = o.getClass();

      Method[] theMethods = null;

      if (objectInfo != null && objectInfo.showInheritedMethods()) {
        theMethods = c.getMethods();
      } else {
        ArrayList<Method> methods = new ArrayList<Method>();

        // methods declared by class c
        for (Method m : c.getDeclaredMethods()) {
          methods.add(m);
        }

        // methods declared in superclasses of c
        for (Method m : c.getMethods()) {
          MethodInfo info = m.getAnnotation(MethodInfo.class);
          // if m is marked as inheritGUI this method will
          // be visualized even if it is a method declared
          // in a superclass of c
          if (info != null && info.inheritGUI()) {
            if (!methods.contains(m)) {
              methods.add(m);
            }
          }
        }

        Method[] tmpArray = new Method[methods.size()];

        theMethods = methods.toArray(tmpArray);
      }

      for (int i = 0; i < theMethods.length; i++) {

        // filter groovy object specific methods
        String method = theMethods[i].getName();
        boolean isGroovyObject = o instanceof GroovyObject;
        boolean isGroovyMethod =
            method.equals("setProperty")
                || method.equals("getProperty")
                || method.equals("invokeMethod")
                || method.equals("getMetaClass")
                || method.equals("setMetaClass"); // ||
        //                            // the following methods are only present
        //                            // for Groovy >= 1.6
        //                            method.equals("super$1$wait") ||
        //                            method.equals("super$1$toString") ||
        //                            method.equals("super$1$notify") ||
        //                            method.equals("super$1$notifyAll") ||
        //                            method.equals("super$1$getClass") ||
        //                            method.equals("super$1$equals") ||
        //                            method.equals("super$1$clone") ||
        //                            method.equals("super$1$hashCode") ||
        //                            method.equals("super$1$finalize");

        // For Groovy >= 1.6 private methods have $ sign in their
        // name, e.g.,
        //   private doSomething()
        // will be changed to
        //   this$2$doSomething()
        // which is unfortunately accessible and thus will be
        // visualized by vrl.
        // To prevent groovys strange behavior
        // methods with $ sign are ignored and treated as private.
        boolean isPrivateGroovyMethod = method.contains("$");

        // TODO improve that code!
        if ((isGroovyObject && isGroovyMethod) || isPrivateGroovyMethod) {
          continue;
        }

        Class[] parameterTypes = theMethods[i].getParameterTypes();

        Annotation[][] allParameterAnnotations = theMethods[i].getParameterAnnotations();

        ArrayList<String> paramNames = new ArrayList<String>();

        ArrayList<ParamInfo> paramAnnotations = new ArrayList<ParamInfo>();
        ArrayList<ParamGroupInfo> paramGroupAnnotations = new ArrayList<ParamGroupInfo>();

        // retrieving annotation information for each parameter
        for (int j = 0; j < allParameterAnnotations.length; j++) {

          Annotation[] annotations = allParameterAnnotations[j];

          // add name element and set it to null
          // because we don't know if parameter j is annotated
          paramNames.add(null);
          paramAnnotations.add(null);
          paramGroupAnnotations.add(null);

          // check all annotations of parameter j
          // if we have a ParamInfo annotation retrieve data
          // and store it as element of paramName
          for (Annotation a : annotations) {
            if (a.annotationType().equals(ParamInfo.class)) {
              ParamInfo n = (ParamInfo) a;
              if (!n.name().equals("")) {
                paramNames.set(j, n.name());
              }
              paramAnnotations.set(j, n);
            } else {
              if (a.annotationType().equals(ParamGroupInfo.class)) {
                ParamGroupInfo n = (ParamGroupInfo) a;
                paramGroupAnnotations.set(j, n);
              }
            }
          } // end for a
        } // end for j

        // convert list to array
        String[] parameterNames = paramNames.toArray(new String[paramNames.size()]);

        ParamInfo[] parameterAnnotations =
            paramAnnotations.toArray(new ParamInfo[paramAnnotations.size()]);

        ParamGroupInfo[] parameterGroupAnnotations =
            paramGroupAnnotations.toArray(new ParamGroupInfo[paramGroupAnnotations.size()]);

        Class returnType = theMethods[i].getReturnType();

        String methodString = theMethods[i].getName();
        String methodTitle = "";
        String returnValueName = null;

        int modifiers = theMethods[i].getModifiers();

        String modifierString = Modifier.toString(modifiers);

        // Method Annotations
        Annotation[] annotations = theMethods[i].getAnnotations();
        MethodInfo methodInfo = null;

        OutputInfo outputInfo = null;

        boolean interactive = true;
        boolean hide = false;

        for (Annotation a : annotations) {
          if (a.annotationType().equals(MethodInfo.class)) {
            MethodInfo n = (MethodInfo) a;

            methodTitle = n.name();
            interactive = n.interactive();
            hide = n.hide();
            returnValueName = n.valueName();

            methodInfo = n;
          }

          if (a.annotationType().equals(OutputInfo.class)) {
            outputInfo = (OutputInfo) a;
          }
        }

        if (theMethods[i].getAnnotation(ReferenceMethodInfo.class) != null) {
          hasCustomReferenceMethod = true;
          MethodDescription customReferenceMethod =
              new MethodDescription(
                  objID,
                  0,
                  methodString,
                  methodTitle,
                  null,
                  parameterTypes,
                  parameterNames,
                  parameterAnnotations,
                  parameterGroupAnnotations,
                  returnType,
                  returnValueName,
                  interactive,
                  methodInfo,
                  outputInfo);

          if (customReferenceMethod.getParameterTypes() == null
              || customReferenceMethod.getParameterTypes().length != 1) {
            throw new IllegalArgumentException(
                " Cannot to use "
                    + "\""
                    + methodString
                    + "\" as reference method"
                    + " because the number of parameters does not"
                    + " match. Exactly one parameter must be"
                    + " provided.");
          }

          if (customReferenceMethod.getReturnType() == void.class
              || customReferenceMethod.getReturnType().isPrimitive()) {
            throw new IllegalArgumentException(
                " Cannot to use "
                    + "\""
                    + methodString
                    + "\" as reference method"
                    + " because it does not return an object."
                    + " Returning primitives or void is not"
                    + " allowed.");
          }

          customReferenceMethod.setMethodType(MethodType.CUSTOM_REFERENCE);

          result.addMethod(customReferenceMethod);
        } //
        // TODO: at the moment method id is always 0 and will only be
        //      set from corresponding method representations
        //
        //      is it necessary to change that?
        else if (modifierString.contains("public")
            && (methodInfo == null || !methodInfo.ignore())) {
          result.addMethod(
              new MethodDescription(
                  objID,
                  0,
                  methodString,
                  methodTitle,
                  null,
                  parameterTypes,
                  parameterNames,
                  parameterAnnotations,
                  parameterGroupAnnotations,
                  returnType,
                  returnValueName,
                  interactive,
                  methodInfo,
                  outputInfo));
        }
      } // end for i

      // Object name
      if (objectInfo != null && !objectInfo.name().equals("")) {
        result.setName(objectInfo.name());
      }
    } // end else if (o instanceof ProxyObject)

    if (!hasCustomReferenceMethod) {
      result.addMethod(MethodDescription.createReferenceMethod(objID, o.getClass()));
    }

    return result;
  }