com.sun.jdi.Type Java Examples

private static Type boxType(Type t) {
    if (t instanceof ClassType) {
        String name = ((ClassType) t).name();
        if (name.equals("java.lang.Boolean")) {
            t = t.virtualMachine().mirrorOf(true).type();
        } else if (name.equals("java.lang.Byte")) {
            t = t.virtualMachine().mirrorOf((byte) 10).type();
        } else if (name.equals("java.lang.Character")) {
            t = t.virtualMachine().mirrorOf('a').type();
        } else if (name.equals("java.lang.Integer")) {
            t = t.virtualMachine().mirrorOf(10).type();
        } else if (name.equals("java.lang.Long")) {
            t = t.virtualMachine().mirrorOf(10l).type();
        } else if (name.equals("java.lang.Short")) {
            t = t.virtualMachine().mirrorOf((short)10).type();
        } else if (name.equals("java.lang.Float")) {
            t = t.virtualMachine().mirrorOf(10f).type();
        } else if (name.equals("java.lang.Double")) {
            t = t.virtualMachine().mirrorOf(10.0).type();
        }
    }
    return t;
}
 

public boolean hasAllTypes() {
    if (getInnerValue () == null) {
        return true;
    }
    Type t;
    synchronized (valueTypeLoaded) {
        if (!valueTypeLoaded[0]) {
            return false;
        }
        t = valueType;
    }
    if (t instanceof ClassType) {
        ClassType ct = (ClassType) t;
        if (!getDebugger().hasAllInterfaces(ct)) {
            return false;
        }
        synchronized (superClassLoaded) {
            if (!superClassLoaded[0]) {
                return false;
            }
        }
    }
    return true;
}
 

public List<JPDAClassType> getAllInterfaces() {
    if (getInnerValue () == null) {
        return null;
    }
    try {
        Type t = getCachedType();
        if (!(t instanceof ClassType)) {
            return null;
        }
        ClassType ct = (ClassType) t;
        return getDebugger().getAllInterfaces(ct);
    } catch (ObjectCollectedExceptionWrapper ocex) {
        return null;
    } catch (InternalExceptionWrapper ex) {
        return null;
    } catch (VMDisconnectedExceptionWrapper e) {
        return null;
    }
}
 

/**
 * Returns whether to support the logical structure view for the given object instance.
 */
public boolean providesLogicalStructure(ObjectReference obj) {
    Type variableType = obj.type();
    if (!(variableType instanceof ClassType)) {
        return false;
    }

    ClassType classType = (ClassType) variableType;
    while (classType != null) {
        if (Objects.equals(type, classType.name())) {
            return true;
        }

        classType = classType.superclass();
    }

    List<InterfaceType> interfaceTypes = ((ClassType) variableType).allInterfaces();
    for (InterfaceType interfaceType : interfaceTypes) {
        if (Objects.equals(type, interfaceType.name())) {
            return true;
        }
    }

    return false;
}
 

private Value handleSetValueForObject(String name, String belongToClass, String valueString,
        ObjectReference container, Map<String, Object> options) throws InvalidTypeException, ClassNotLoadedException {
    Value newValue;
    if (container instanceof ArrayReference) {
        ArrayReference array = (ArrayReference) container;
        Type eleType = ((ArrayType) array.referenceType()).componentType();
        newValue = setArrayValue(array, eleType, Integer.parseInt(name), valueString, options);
    } else {
        if (StringUtils.isBlank(belongToClass)) {
            Field field = container.referenceType().fieldByName(name);
            if (field != null) {
                if (field.isStatic()) {
                    newValue = this.setStaticFieldValue(container.referenceType(), field, name, valueString, options);
                } else {
                    newValue = this.setObjectFieldValue(container, field, name, valueString, options);
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("SetVariableRequest: Variable %s cannot be found.", name));
            }
        } else {
            newValue = setFieldValueWithConflict(container, container.referenceType().allFields(), name, belongToClass, valueString, options);
        }
    }
    return newValue;
}
 

/**
 * Test whether the value has referenced objects.
 *
 * @param value
 *            the value.
 * @param includeStatic
 *            whether or not the static fields are visible.
 * @return true if this value is reference objects.
 */
public static boolean hasChildren(Value value, boolean includeStatic) {
    if (value == null || !(value instanceof ObjectReference)) {
        return false;
    }
    Type type = value.type();
    if (type instanceof ArrayType) {
        return ((ArrayReference) value).length() > 0;
    }
    return value.type() instanceof ReferenceType && ((ReferenceType) type).allFields().stream()
            .filter(t -> includeStatic || !t.isStatic()).toArray().length > 0;
}
 

/**
 * Format a JDI type, using the <code>SimpleTypeFormatter.QUALIFIED_FORMAT_OPTION</code> to control whether or not
 * to use the fully qualified name. Set QUALIFIED_FORMAT_OPTION to true(<code>java.lang.Boolean</code>) to enable
 * fully qualified name, the default option for QUALIFIED_FORMAT_OPTION is false.
 *
 * @param type the Jdi type
 * @param options the format options
 * @return the type name
 */
@Override
public String toString(Object type, Map<String, Object> options) {
    if (type == null) {
        return NullObjectFormatter.NULL_STRING;
    }

    String typeName = ((Type) type).name();
    return showQualifiedClassName(options) ? typeName : trimTypeName(typeName);
}
 

@Override
public Value valueOf(String value, Type type, Map<String, Object> options) {
    VirtualMachine vm = type.virtualMachine();
    char signature0 = type.signature().charAt(0);
    if (signature0 == LONG
            || signature0 == INT
            || signature0 == SHORT
            || signature0 == BYTE) {
        long number = parseNumber(value);
        if (signature0 == LONG) {
            return vm.mirrorOf(number);
        } else if (signature0 == INT) {
            return vm.mirrorOf((int) number);
        } else if (signature0 == SHORT) {
            return vm.mirrorOf((short) number);
        } else if (signature0 == BYTE) {
            return vm.mirrorOf((byte) number);
        }
    } else if (hasFraction(signature0)) {
        double doubleNumber = parseFloatDouble(value);
        if (signature0 == DOUBLE) {
            return vm.mirrorOf(doubleNumber);
        } else {
            return vm.mirrorOf((float) doubleNumber);
        }
    }

    throw new UnsupportedOperationException(String.format("%s is not a numeric type.", type.name()));
}
 

/**
 * The conditional function for this formatter.
 *
 * @param type the JDI type
 * @return whether or not this formatter is expected to work on this value.
 */
@Override
public boolean acceptType(Type type, Map<String, Object> options) {
    if (type == null) {
        return false;
    }
    char signature0 = type.signature().charAt(0);
    return signature0 == LONG
            || signature0 == INT
            || signature0 == SHORT
            || signature0 == BYTE
            || signature0 == FLOAT
            || signature0 == DOUBLE;
}
 

@Override
public boolean acceptType(Type type, Map<String, Object> options) {
    if (type == null) {
        return false;
    }
    char signature0 = type.signature().charAt(0);
    return signature0 == CHAR;
}
 

@Override
public Value valueOf(String value, Type type, Map<String, Object> options) {
    VirtualMachine vm = type.virtualMachine();
    if (value == null) {
        return null;
    }
    if (value.length() == 3
            && value.startsWith("'")
            && value.endsWith("'")) {
        return type.virtualMachine().mirrorOf(value.charAt(1));
    }
    return vm.mirrorOf(value.charAt(0));
}
 

@Override
public Value valueOf(String value, Type type, Map<String, Object> options) {
    if (value == null || NULL_STRING.equals(value)) {
        return null;
    }
    throw new UnsupportedOperationException("Set value is not supported by NullObjectFormatter.");
}
 

@Override
public boolean acceptType(Type type, Map<String, Object> options) {
    if (type == null) {
        return false;
    }
    char signature0 = type.signature().charAt(0);
    return signature0 == BOOLEAN;
}
 

private Value setStaticFieldValue(Type declaringType, Field field, String name, String value, Map<String, Object> options)
        throws ClassNotLoadedException, InvalidTypeException {
    if (field.isFinal()) {
        throw new UnsupportedOperationException(
                String.format("SetVariableRequest: Final field %s cannot be changed.", name));
    }
    if (!(declaringType instanceof ClassType)) {
        throw new UnsupportedOperationException(
                String.format("SetVariableRequest: Field %s in interface cannot be changed.", name));
    }
    return setValueProxy(field.type(), value, newValue -> ((ClassType) declaringType).setValue(field, newValue), options);
}
 

/**
 * Get the declaring type of this variable if it is a field declared by some class.
 *
 * @return the declaring type of this variable.
 */
public Type getDeclaringType() {
    if (this.field != null) {
        return this.field.declaringType();
    }
    return null;
}
 

@Override
public Object getValue() throws IllegalAccessException, InvocationTargetException {
    synchronized (valueLock) {
        if (value == null) {
            value = valueCalculating;
            debugger.getRequestProcessor().post(new Runnable() {
                @Override
                public void run() {
                    try {
                        RemoteServices.runOnStoppedThread(t, new Runnable() {
                            @Override
                            public void run() {
                                boolean[] isEditablePtr = new boolean[] { false };
                                Type[] typePtr = new Type[] { null };
                                String v = getValueLazy(isEditablePtr, typePtr);
                                synchronized (valueLock) {
                                    value = v;
                                    valueIsEditable = isEditablePtr[0];
                                    valueType = typePtr[0];
                                }
                                ci.firePropertyChange(propertyName, null, v);
                            }
                        }, sType);
                    } catch (PropertyVetoException ex) {
                        value = ex.getLocalizedMessage();
                    }
                }
            });
        }
        return value;
    }
}
 

/**
 * Get the variables of the object.
 *
 * @param obj
 *            the object
 * @return the variable list
 * @throws AbsentInformationException
 *             when there is any error in retrieving information
 */
public static List<Variable> listFieldVariables(ObjectReference obj, boolean includeStatic) throws AbsentInformationException {
    List<Variable> res = new ArrayList<>();
    Type type = obj.type();
    if (type instanceof ArrayType) {
        int arrayIndex = 0;
        for (Value elementValue : ((ArrayReference) obj).getValues()) {
            Variable ele = new Variable(String.valueOf(arrayIndex++), elementValue);
            res.add(ele);
        }
        return res;
    }
    List<Field> fields = obj.referenceType().allFields().stream().filter(t -> includeStatic || !t.isStatic())
            .sorted((a, b) -> {
                try {
                    boolean v1isStatic = a.isStatic();
                    boolean v2isStatic = b.isStatic();
                    if (v1isStatic && !v2isStatic) {
                        return -1;
                    }
                    if (!v1isStatic && v2isStatic) {
                        return 1;
                    }
                    return a.name().compareToIgnoreCase(b.name());
                } catch (Exception e) {
                    logger.log(Level.SEVERE, String.format("Cannot sort fields: %s", e), e);
                    return -1;
                }
            }).collect(Collectors.toList());
    fields.forEach(f -> {
        Variable var = new Variable(f.name(), obj.getValue(f));
        var.field = f;
        res.add(var);
    });
    return res;
}
 

/**
 * Get the variables of the object with pagination.
 *
 * @param obj
 *            the object
 * @param start
 *            the start of the pagination
 * @param count
 *            the number of variables needed
 * @return the variable list
 * @throws AbsentInformationException
 *             when there is any error in retrieving information
 */
public static List<Variable> listFieldVariables(ObjectReference obj, int start, int count)
        throws AbsentInformationException {
    List<Variable> res = new ArrayList<>();
    Type type = obj.type();
    if (type instanceof ArrayType) {
        int arrayIndex = start;
        for (Value elementValue : ((ArrayReference) obj).getValues(start, count)) {
            res.add(new Variable(String.valueOf(arrayIndex++), elementValue));
        }
        return res;
    }
    throw new UnsupportedOperationException("Only Array type is supported.");
}
 

private static IFormatter getFormatter(Map<? extends IFormatter, Integer> formatterMap, Type type,
                                       Map<String, Object> options) {
    List<? extends IFormatter> formatterList =
            formatterMap.keySet().stream().filter(t -> t.acceptType(type, options))
                    .sorted((a, b) ->
                            -Integer.compare(formatterMap.get(a), formatterMap.get(b))).collect(Collectors.toList());
    if (formatterList.isEmpty()) {
        throw new UnsupportedOperationException(String.format("There is no related formatter for type %s.",
                type == null ? "null" : type.name()));
    }
    return formatterList.get(0);
}
 

private static String findInheritedType(Value value, Set<String> typeNames) {
    if (!(value instanceof ObjectReference)) {
        return null;
    }

    Type variableType = ((ObjectReference) value).type();
    if (!(variableType instanceof ClassType)) {
        return null;
    }

    ClassType classType = (ClassType) variableType;
    while (classType != null) {
        if (typeNames.contains(classType.name())) {
            return classType.name();
        }

        classType = classType.superclass();
    }

    List<InterfaceType> interfaceTypes = ((ClassType) variableType).allInterfaces();
    for (InterfaceType interfaceType : interfaceTypes) {
        if (typeNames.contains(interfaceType.name())) {
            return interfaceType.name();
        }
    }

    return null;
}
 

private static String getGenericName(ReferenceType type) throws DebugException {
    if (type instanceof ArrayType) {
        try {
            Type componentType;
            componentType = ((ArrayType) type).componentType();
            if (componentType instanceof ReferenceType) {
                return getGenericName((ReferenceType) componentType) + "[]"; //$NON-NLS-1$
            }
            return type.name();
        } catch (ClassNotLoadedException e) {
            // we cannot create the generic name using the component type,
            // just try to create one with the information
        }
    }
    String signature = type.signature();
    StringBuffer res = new StringBuffer(getTypeName(signature));
    String genericSignature = type.genericSignature();
    if (genericSignature != null) {
        String[] typeParameters = Signature.getTypeParameters(genericSignature);
        if (typeParameters.length > 0) {
            res.append('<').append(Signature.getTypeVariable(typeParameters[0]));
            for (int i = 1; i < typeParameters.length; i++) {
                res.append(',').append(Signature.getTypeVariable(typeParameters[i]));
            }
            res.append('>');
        }
    }
    return res.toString();
}
 

public Candidates filter(Type type) {
    Candidates exps = new Candidates();
    for (int i = 0; i < this.size(); i++) {
        Expression expression = this.get(i);
        if (expression instanceof Method) {
            continue;
        }
        if (expression.getValue().isAssignableTo(type)) {
            exps.add(expression);
        }
    }
    return exps;
}
 

@Override
public Value valueOf(String value, Type type, Map<String, Object> options) {
    if (value == null || NullObjectFormatter.NULL_STRING.equals(value)) {
        return null;
    }
    if (value.length() >= 2
            && value.startsWith(QUOTE_STRING)
            && value.endsWith(QUOTE_STRING)) {
        return type.virtualMachine().mirrorOf(StringUtils.substring(value, 1, -1));
    }
    return type.virtualMachine().mirrorOf(value);
}
 

public AbstractObjectVariable (
    JPDADebuggerImpl debugger,
    Value value,
    String id
) {
    this(debugger, value, (com.sun.jdi.Type) null, id);
}
 

@Override
public Value valueOf(String value, Type type, Map<String, Object> options) {
    if (value == null || NullObjectFormatter.NULL_STRING.equals(value)) {
        return null;
    }
    throw new UnsupportedOperationException(String.format("Set value is not supported yet for type %s.", type.name()));
}
 

@Override
public boolean acceptType(Type type, Map<String, Object> options) {
    if (type == null) {
        return false;
    }
    char tag = type.signature().charAt(0);
    return (tag == OBJECT) || (tag == ARRAY) || (tag == STRING)
            || (tag == THREAD) || (tag == THREAD_GROUP)
            || (tag == CLASS_LOADER)
            || (tag == CLASS_OBJECT);
}
 

public ScriptVariable createScriptLocalVariable(String name, Type type) {
    Map<String, ScriptVariable> map = stack.peek();
    ScriptVariable var = new ScriptVariable(name, type);
    map.put(name, var);
    scriptLocalVariables.put(name, var);
    return var;
}
 

@Override
public Type getType() throws ClassNotLoadedException {
    return var.type();
}
 

public static List<ReferenceType> getAttachableListeners(JavaComponentInfo ci) {
    ObjectReference component = ci.getComponent();
    List<ReferenceType> listenerClasses = new ArrayList<ReferenceType>();
    try {
        ReferenceType clazz = ObjectReferenceWrapper.referenceType(component);
        List<Method> visibleMethods = ReferenceTypeWrapper.visibleMethods(clazz);
        for (Method m : visibleMethods) {
            String name = TypeComponentWrapper.name(m);
            if (!name.startsWith("add") || !name.endsWith("Listener")) {
                continue;
            }
            List<Type> argTypes;
            try {
                argTypes = MethodWrapper.argumentTypes(m);
            } catch (ClassNotLoadedException ex) {
                continue;
            }
            if (argTypes.size() != 1) {
                continue;
            }
            Type t = argTypes.get(0);
            if (!(t instanceof ReferenceType)) {
                continue;
            }
            ReferenceType rt = (ReferenceType) t;
            String lname = ReferenceTypeWrapper.name(rt);
            int i = lname.lastIndexOf('.');
            if (i < 0) {
                i = 0;
            } else {
                i++;
            }
            int ii = lname.lastIndexOf('$', i);
            if (ii > i) {
                i = ii + 1;
            }
            //System.err.println("  getAttachableListeners() '"+name.substring(3)+"' should equal to '"+lname.substring(i)+"', lname = "+lname+", i = "+i);
            if (!name.substring(3).equals(lname.substring(i))) {
                // addXXXListener() method name does not match XXXListener simple class name.
                // TODO: Perhaps check removeXXXListener method instead of this.
                continue;
            }
            listenerClasses.add(rt);
        }
    } catch (ClassNotPreparedExceptionWrapper cnpex) {
    } catch (ObjectCollectedExceptionWrapper ocex) {
    } catch (InternalExceptionWrapper iex) {
    } catch (VMDisconnectedExceptionWrapper vdex) {
    }
    return listenerClasses;
}
 

@Override
public boolean isAssignableTo(Type refAss) {
    throw new NotImplementedException();
}