Java InterfaceType类代码示例

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
/**
 * Shared implementation of {@linkplain ClassType#allMethods()} and
 * {@linkplain InterfaceType#allMethods()}
 * @return A list of all methods (recursively)
 */
public final List<Method> allMethods() {
    ArrayList<Method> list = new ArrayList<>(methods());
    ClassType clazz = superclass();
    while (clazz != null) {
        list.addAll(clazz.methods());
        clazz = clazz.superclass();
    }
    /*
     * Avoid duplicate checking on each method by iterating through
     * duplicate-free allInterfaces() rather than recursing
     */
    for (InterfaceType interfaze : getAllInterfaces()) {
        list.addAll(interfaze.methods());
    }
    return list;
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
/**
 * JDI addition: Determines if this is a F3 class.
 *
 * @return <code>true</code> if this is a F3 class; false otherwise.
 */
@Override
public boolean isF3Type() {
    if (!isIsF3TypeSet) {
        isIsF3TypeSet = true;
        F3VirtualMachine f3vm = virtualMachine();
        InterfaceType f3ObjType = (InterfaceType) F3Wrapper.unwrap(f3vm.f3ObjectType());
        if (f3ObjType != null) {
            ClassType thisType = underlying();
            List<InterfaceType> allIfaces = thisType.allInterfaces();
            for (InterfaceType iface : allIfaces) {
                if (iface.equals(f3ObjType)) {
                    isF3Type = true;
                    break;
                }
            }
        }
    }
    return isF3Type;
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
@Override
boolean isAssignableTo(ReferenceType type) {
    ClassTypeImpl superclazz = (ClassTypeImpl) superclass();
    if (this.equals(type)) {
        return true;
    } else if ((superclazz != null) && superclazz.isAssignableTo(type)) {
        return true;
    } else {
        List<InterfaceType> interfaces = interfaces();
        Iterator<InterfaceType> iter = interfaces.iterator();
        while (iter.hasNext()) {
            InterfaceTypeImpl interfaze = (InterfaceTypeImpl) iter.next();
            if (interfaze.isAssignableTo(type)) {
                return true;
            }
        }
        return false;
    }
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
private void handleInterfaceLoad(final InterfaceType intfType, final ThreadReference thread)
{
  // do not proceed if this part of the hierarchy has been processed
  if (contourFactory().lookupStaticContour(intfType.name()) == null)
  {
    // update the meta-data for this type and all other types in its file
    resolveType(intfType);
    // recursively create the schemas, as necessary
    final List<?> superTypes = intfType.superinterfaces();
    for (final Object o : superTypes)
    {
      final InterfaceType superType = (InterfaceType) o;
      handleInterfaceLoad(superType, thread);
    }
    // all interfaces are either top-level or static;
    // we only create a contour if the interface declares fields
    if (intfType.fields().size() > 0)
    {
      // creates and dispatches a type load event for this type
      manager().jiveDispatcher().dispatchLoadEvent(intfType, thread);
    }
  }
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
@Override
final void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces) {
    /*
     * Add methods from
     * parent types first, so that the methods in this class will
     * overwrite them in the hash table
     */
    Iterator<InterfaceType> iter = interfaces().iterator();
    while (iter.hasNext()) {
        InterfaceTypeImpl interfaze = (InterfaceTypeImpl) iter.next();
        if (!seenInterfaces.contains(interfaze)) {
            interfaze.addVisibleMethods(methodMap, seenInterfaces);
            seenInterfaces.add(interfaze);
        }
    }
    ClassTypeImpl clazz = (ClassTypeImpl) superclass();
    if (clazz != null) {
        clazz.addVisibleMethods(methodMap, seenInterfaces);
    }
    addToMethodMap(methodMap, methods());
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
void writeLocation(Location location) {
    ReferenceTypeImpl refType = (ReferenceTypeImpl)location.declaringType();
    byte tag;
    if (refType instanceof ClassType) {
        tag = JDWP.TypeTag.CLASS;
    } else if (refType instanceof InterfaceType) {
        // It's possible to have executable code in an interface
        tag = JDWP.TypeTag.INTERFACE;
    } else {
        throw new InternalException("Invalid Location");
    }
    writeByte(tag);
    writeClassRef(refType.ref());
    writeMethodRef(((MethodImpl)location.method()).ref());
    writeLong(location.codeIndex());
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
public List<Method> visibleMethods() {
    /*
     * Build a collection of all visible methods. The hash
     * map allows us to do this efficiently by keying on the
     * concatenation of name and signature.
     */
    Map<String, Method> map = new HashMap<String, Method>();
    addVisibleMethods(map, new HashSet<InterfaceType>());

    /*
     * ... but the hash map destroys order. Methods should be
     * returned in a sensible order, as they are in allMethods().
     * So, start over with allMethods() and use the hash map
     * to filter that ordered collection.
     */
    List<Method> list = allMethods();
    list.retainAll(new HashSet<Method>(map.values()));
    return list;
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
boolean isAssignableTo(ReferenceType destType) {
    if (destType instanceof ArrayType) {
        try {
            Type destComponentType = ((ArrayType)destType).componentType();
            return isComponentAssignable(destComponentType, componentType());
        } catch (ClassNotLoadedException e) {
            // One or both component types has not yet been
            // loaded => can't assign
            return false;
        }
    } else if (destType instanceof InterfaceType) {
        // Only valid InterfaceType assignee is Cloneable
        return destType.name().equals("java.lang.Cloneable");
    } else {
        // Only valid ClassType assignee is Object
        return destType.name().equals("java.lang.Object");
    }
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
@Override
void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces) {
    /*
     * Add methods from
     * parent types first, so that the methods in this class will
     * overwrite them in the hash table
     */
    Iterator<InterfaceType> iter = superinterfaces().iterator();
    while (iter.hasNext()) {
        InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
        if (!seenInterfaces.contains(interfaze)) {
            interfaze.addVisibleMethods(methodMap, seenInterfaces);
            seenInterfaces.add(interfaze);
        }
    }

    addToMethodMap(methodMap, methods());
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
List getAllMethods() {
    ArrayList list = new ArrayList(methods());
    ClassType clazz = superclass();
    while (clazz != null) {
        list.addAll(clazz.methods());
        clazz = clazz.superclass();
    }
    /*
     * Avoid duplicate checking on each method by iterating through
     * duplicate-free allInterfaces() rather than recursing
     */
    Iterator iter = allInterfaces().iterator();
    while (iter.hasNext()) {
        InterfaceType interfaze = (InterfaceType)iter.next();
        list.addAll(interfaze.methods());
    }
    return list;
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
@Override
void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces) {
    /*
     * Add methods from
     * parent types first, so that the methods in this class will
     * overwrite them in the hash table
     */

    Iterator<InterfaceType> iter = interfaces().iterator();
    while (iter.hasNext()) {
        InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
        if (!seenInterfaces.contains(interfaze)) {
            interfaze.addVisibleMethods(methodMap, seenInterfaces);
            seenInterfaces.add(interfaze);
        }
    }

    ClassTypeImpl clazz = (ClassTypeImpl)superclass();
    if (clazz != null) {
        clazz.addVisibleMethods(methodMap, seenInterfaces);
    }

    addToMethodMap(methodMap, methods());
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
boolean isAssignableTo(ReferenceType destType) {
    if (destType instanceof ArrayType) {
        try {
            Type destComponentType = ((ArrayType)destType).componentType();
            return isComponentAssignable(destComponentType, componentType());
        } catch (ClassNotLoadedException e) {
            // One or both component types has not yet been
            // loaded => can't assign
            return false;
        }
    } else {
        Symbol typeName = ((ReferenceTypeImpl)destType).typeNameAsSymbol();
        if (destType instanceof InterfaceType) {
            // Every array type implements java.io.Serializable and
            // java.lang.Cloneable. fixme in JVMDI-JDI, includes only
            // Cloneable but not Serializable.
            return typeName.equals(vm.javaLangCloneable()) ||
                   typeName.equals(vm.javaIoSerializable());
        } else {
            // Only valid ClassType assignee is Object
            return typeName.equals(vm.javaLangObject());
        }
    }
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
@Nullable
public static PsiType getCastableRuntimeType(Project project, Value value) {
  Type type = value.type();
  PsiType psiType = findPsiType(project, type);
  if (psiType != null) {
    return psiType;
  }

  if (type instanceof ClassType) {
    ClassType superclass = ((ClassType)type).superclass();
    if (superclass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(superclass.name())) {
      psiType = findPsiType(project, superclass);
      if (psiType != null) {
        return psiType;
      }
    }

    for (InterfaceType interfaceType : ((ClassType)type).interfaces()) {
      psiType = findPsiType(project, interfaceType);
      if (psiType != null) {
        return psiType;
      }
    }
  }
  return null;
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
/**
 * JDI addition: Determines if this is a F3 type.
 *
 * @return <code>true</code> if this is a F3 type; false otherwise.
 */
public boolean isF3Type() {
    if (!isIsF3TypeSet) {
        isIsF3TypeSet = true;
        F3VirtualMachine f3vm = virtualMachine();
        InterfaceType f3ObjType = (InterfaceType) F3Wrapper.unwrap(f3vm.f3ObjectType());
        if (f3ObjType != null) {
            InterfaceType thisType = underlying();
            List<InterfaceType> allIfaces = thisType.superinterfaces();
            for (InterfaceType iface : allIfaces) {
                if (iface.equals(f3ObjType)) {
                    isF3Type = true;
                    break;
                }
            }
        }
    }
    return isF3Type;
}
 

import com.sun.jdi.InterfaceType; //导入依赖的package包/类
public static PsiClass getCastableRuntimeType(Project project, Value value) {
  Type type = value.type();
  PsiClass psiClass = findPsiClass(project, type);
  if (psiClass != null) {
    return psiClass;
  }

  if (type instanceof ClassType) {
    ClassType superclass = ((ClassType)type).superclass();
    if (superclass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(superclass.name())) {
      psiClass = findPsiClass(project, superclass);
      if (psiClass != null) {
        return psiClass;
      }
    }

    for (InterfaceType interfaceType : ((ClassType)type).interfaces()) {
      psiClass = findPsiClass(project, interfaceType);
      if (psiClass != null) {
        return psiClass;
      }
    }
  }
  return null;
}