Java ReflectionUtil.isAssignable方法代码示例

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
@NotNull
protected <T extends NodeDescriptor> List<T> getSelectedNodes(final Class<T> nodeClass){
  TreePath[] paths = getSelectionPaths();
  if (paths == null) return Collections.emptyList();
  final ArrayList<T> result = new ArrayList<T>();
  for (TreePath path : paths) {
    Object lastPathComponent = path.getLastPathComponent();
    if (lastPathComponent instanceof DefaultMutableTreeNode) {
      DefaultMutableTreeNode node = (DefaultMutableTreeNode)lastPathComponent;
      Object userObject = node.getUserObject();
      if (userObject != null && ReflectionUtil.isAssignable(nodeClass, userObject.getClass())) {
        result.add((T)userObject);
      }
    }
  }
  return result;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
@Nullable
private static Object getPrimaryKey(Object implementation, final boolean singleValuedInvocation) {
  final Method method = getPrimaryKeyMethod(implementation.getClass());
  if (method != null) {
    final Object o = DomReflectionUtil.invokeMethod(method, implementation);
    return ReflectionUtil.isAssignable(GenericValue.class, method.getReturnType()) ? ((GenericValue)o).getValue() : o;
  }
  else {
    if (implementation instanceof GenericValue) {
      return singleValuedInvocation? Boolean.TRUE : ((GenericValue)implementation).getValue();
    }
    else {
      return null;
    }
  }
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
@NotNull
@Override
public Collection<StructureViewExtension> getAllExtensions(@NotNull Class<? extends PsiElement> type) {
  Collection<StructureViewExtension> result = myImplExtensions.get(type);
  if (result == null) {
    MultiValuesMap<Class<? extends PsiElement>, StructureViewExtension> map = myExtensions.getValue();
    for (Class<? extends PsiElement> registeredType : map.keySet()) {
      if (ReflectionUtil.isAssignable(registeredType, type)) {
        final Collection<StructureViewExtension> extensions = map.get(registeredType);
        for (StructureViewExtension extension : extensions) {
          myImplExtensions.put(type, extension);
        }
      }
    }
    result = myImplExtensions.get(type);
    if (result == null) return Collections.emptyList();
  }
  return result;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
@NotNull
@Override
public final <T> List<T> getComponentInstancesOfType(@NotNull Class<T> baseClass) {
  List<T> result = null;
  // we must use instances only from our adapter (could be service or extension point or something else)
  for (ComponentAdapter componentAdapter : ((DefaultPicoContainer)getPicoContainer()).getComponentAdapters()) {
    if (componentAdapter instanceof ComponentConfigComponentAdapter && ReflectionUtil.isAssignable(baseClass, componentAdapter.getComponentImplementation())) {
      //noinspection unchecked
      T instance = (T)((ComponentConfigComponentAdapter)componentAdapter).myInitializedComponentInstance;
      if (instance != null) {
        if (result == null) {
          result = new ArrayList<T>();
        }
        result.add(instance);
      }
    }
  }
  return ContainerUtil.notNullize(result);
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
public VisitorDescription(final Class<? extends DomElementVisitor> visitorClass) {
  myVisitorClass = visitorClass;
  for (final Method method : ReflectionUtil.getClassPublicMethods(visitorClass)) {
    final Class<?>[] parameterTypes = method.getParameterTypes();
    if (parameterTypes.length != 1) {
      continue;
    }
    final Class<?> domClass = parameterTypes[0];
    if (!ReflectionUtil.isAssignable(DomElement.class, domClass)) {
      continue;
    }
    final String methodName = method.getName();
    if (VISIT.equals(methodName) || methodName.startsWith(VISIT) /*&& domClass.getSimpleName().equals(methodName.substring(VISIT.length()))*/) {
      method.setAccessible(true);
      myMethods.put(domClass, method);
    }
  }
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
public static boolean isTagValueGetter(final JavaMethod method) {
  if (!isGetter(method)) {
    return false;
  }
  if (hasTagValueAnnotation(method)) {
    return true;
  }
  if ("getValue".equals(method.getName())) {
    if (method.getAnnotation(SubTag.class) != null) return false;
    if (method.getAnnotation(SubTagList.class) != null) return false;
    if (method.getAnnotation(Convert.class) != null || method.getAnnotation(Resolve.class) != null) {
      return !ReflectionUtil.isAssignable(GenericDomValue.class, method.getReturnType());
    }
    if (ReflectionUtil.isAssignable(DomElement.class, method.getReturnType())) return false;
    return true;
  }
  return false;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
private static boolean isElementOfClass(PsiElement element, Class[] classesFilter) {
  if (classesFilter == null) return true;
  for (Class aClassesFilter : classesFilter) {
    if (ReflectionUtil.isAssignable(aClassesFilter, element.getClass())) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
private static boolean isPsiClassType(GenericDomValue element) {
  final Class genericValueParameter = DomUtil.getGenericValueParameter(element.getDomElementType());
  if (genericValueParameter != null && (ReflectionUtil.isAssignable(genericValueParameter, PsiClass.class) ||
                                        ReflectionUtil.isAssignable(genericValueParameter, PsiType.class))) {
    return true;
  }
  return false;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
private boolean shouldBeIgnored(Object object) {
  if (object instanceof CellRendererPane) return true;
  if (object == null) {
    return true;
  }
  for (Class aClass : myControlsToIgnore) {
    if (ReflectionUtil.isAssignable(aClass, object.getClass())) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
public static <T extends PsiReference> void registerReferenceFixes(@NotNull T ref, @NotNull QuickFixActionRegistrar registrar) {
  final boolean dumb = DumbService.getInstance(ref.getElement().getProject()).isDumb();
  UnresolvedReferenceQuickFixProvider[] fixProviders = Extensions.getExtensions(EXTENSION_NAME);
  Class<? extends PsiReference> referenceClass = ref.getClass();
  for (UnresolvedReferenceQuickFixProvider each : fixProviders) {
    if (dumb && !DumbService.isDumbAware(each)) {
      continue;
    }
    if (ReflectionUtil.isAssignable(each.getReferenceClass(), referenceClass)) {
      each.registerFixes(ref, registrar);
    }
  }
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
protected final Object mergeImplementations(final Class returnType, final List<Object> implementations) {
  for (int i = myMergingStrategies.size() - 1; i >= 0; i--) {
    if (ReflectionUtil.isAssignable(myMergingStrategyClasses.get(i), returnType)) {
      final Object o = myMergingStrategies.get(i).mergeChildren(returnType, implementations);
      if (o != null) {
        return o;
      }
    }
  }
  if (implementations.size() == 1) {
    return implementations.get(0);
  }
  return mergeModels(returnType, implementations);
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
protected boolean isSuitable(final PsiElement element) {
  if (element == null) return false;
  final Class[] suitableClasses = getSuitableClasses();
  for (Class suitableClass : suitableClasses) {
    if (ReflectionUtil.isAssignable(suitableClass, element.getClass())) return true;
  }
  return false;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
@Override
public List<Object> getComponentInstancesOfType(@Nullable Class componentType) {
  if (componentType == null) {
    return Collections.emptyList();
  }

  List<Object> result = new ArrayList<Object>();
  for (ComponentAdapter componentAdapter : getComponentAdapters()) {
    if (ReflectionUtil.isAssignable(componentType, componentAdapter.getComponentImplementation())) {
      // may be null in the case of the "implicit" adapter representing "this".
      ContainerUtil.addIfNotNull(result, getInstance(componentAdapter));
    }
  }
  return result;
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
@Nullable
public static <T, V> V getImplementation(final T element, final Class<V> clazz) {
  if (element == null) return null;
  CommonProcessors.FindFirstProcessor<T> processor = new CommonProcessors.FindFirstProcessor<T>() {
    @Override
    public boolean process(final T t) {
      return !ReflectionUtil.isAssignable(clazz, t.getClass()) || super.process(t);
    }
  };
  new ImplementationProcessor<T>(processor, true).process(element);
  return (V)processor.getFoundValue();
}
 

import com.intellij.util.ReflectionUtil; //导入方法依赖的package包/类
@Override
public boolean isClassAcceptable(Class hintClass){
  return ReflectionUtil.isAssignable(PsiClass.class, hintClass);
}