Java Code Examples for com.intellij.util.ReflectionUtil#isAssignable()

@Override
@Nullable
public PsiElement findElementAt(int offset, @Nonnull Class<? extends Language> lang) {
  final PsiFile mainRoot = getPsi(getBaseLanguage());
  PsiElement ret = null;
  for (final Language language : getLanguages()) {
    if (!ReflectionUtil.isAssignable(lang, language.getClass())) continue;
    if (lang.equals(Language.class) && !getLanguages().contains(language)) continue;

    final PsiFile psiRoot = getPsi(language);
    final PsiElement psiElement = findElementAt(psiRoot, offset);
    if (psiElement == null || psiElement instanceof OuterLanguageElement) continue;
    if (ret == null || psiRoot != mainRoot) {
      ret = psiElement;
    }
  }
  return ret;
}
 

protected static <T extends PsiNamedElement> int getChildIndex(T element, PsiElement parent, String name, Class<T> hisClass) {
  PsiElement[] children = parent.getChildren();
  int index = 0;

  for (PsiElement child : children) {
    if (ReflectionUtil.isAssignable(hisClass, child.getClass())) {
      T namedChild = hisClass.cast(child);
      final String childName = namedChild.getName();

      if (Comparing.equal(name, childName)) {
        if (namedChild.equals(element)) {
          return index;
        }
        index++;
      }
    }
  }

  return index;
}
 

@Nullable
protected static <T extends PsiNamedElement> T restoreElementInternal(@Nonnull PsiElement parent,
                                                                      String name,
                                                                      int index,
                                                                      @Nonnull Class<T> hisClass)
{
  PsiElement[] children = parent.getChildren();

  for (PsiElement child : children) {
    if (ReflectionUtil.isAssignable(hisClass, child.getClass())) {
      T namedChild = hisClass.cast(child);
      final String childName = namedChild.getName();

      if (Comparing.equal(name, childName)) {
        if (index == 0) {
          return namedChild;
        }
        index--;
      }
    }
  }

  return null;
}
 

@Override
public Collection<StructureViewExtension> getAllExtensions(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;
}
 

@Nullable
private static <T> T getRootElement(final PsiFile file, final Class<T> domClass, final Module module) {
    if(!(file instanceof XmlFile)) return null;
    final DomManager domManager = DomManager.getDomManager(file.getProject());
    final DomFileElement<DomElement> element = domManager.getFileElement((XmlFile) file, DomElement.class);
    if(element == null) return null;
    final DomElement root = element.getRootElement();
    if(!ReflectionUtil.isAssignable(domClass, root.getClass())) return null;
    return (T) root;
}
 

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;
}
 

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;
}
 

@RequiredReadAction
private static <T extends PsiElement> T findElementInRange(@Nonnull PsiFile file,
                                                           int startOffset,
                                                           int endOffset,
                                                           @Nonnull Class<T> klass,
                                                           @Nonnull Language language,
                                                           @Nullable PsiElement initialElement) {
  PsiElement element1 = file.getViewProvider().findElementAt(startOffset, language);
  PsiElement element2 = file.getViewProvider().findElementAt(endOffset - 1, language);
  if (element1 instanceof PsiWhiteSpace) {
    startOffset = element1.getTextRange().getEndOffset();
    element1 = file.getViewProvider().findElementAt(startOffset, language);
  }
  if (element2 instanceof PsiWhiteSpace) {
    endOffset = element2.getTextRange().getStartOffset();
    element2 = file.getViewProvider().findElementAt(endOffset - 1, language);
  }
  if (element2 == null || element1 == null) return null;
  final PsiElement commonParent = PsiTreeUtil.findCommonParent(element1, element2);
  final T element =
          ReflectionUtil.isAssignable(klass, commonParent.getClass())
          ? (T)commonParent : PsiTreeUtil.getParentOfType(commonParent, klass);

  if (element == initialElement) {
    return element;
  }

  if (element == null || element.getTextRange().getStartOffset() != startOffset || element.getTextRange().getEndOffset() != endOffset) {
    return null;
  }
  return element;
}
 

private boolean isScopeClassFinal(Class scopeClass){
  for (final Object myScopeClass : myScopeClasses) {
    Scope scope = (Scope)myScopeClass;
    if (ReflectionUtil.isAssignable(scope.myClass, scopeClass) && scope.myIsFinalScope) {
      return true;
    }
  }
  return false;
}
 

private boolean isScopeClassAcceptable(Class scopeClass){
  boolean ret = false;

  for (final Object myScopeClass : myScopeClasses) {
    final Class aClass = ((Scope)myScopeClass).myClass;
    if (ReflectionUtil.isAssignable(aClass, scopeClass)) {
      ret = true;
      break;
    }
  }

  return ret;
}
 

public static <T extends PsiReference> void registerReferenceFixes(T ref, 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);
      }
    }
  }
 

@Override
public PsiElement findElementAt(int offset, @Nonnull Class<? extends Language> lang) {
  if (!ReflectionUtil.isAssignable(lang, getBaseLanguage().getClass())) return null;
  return findElementAt(offset);
}
 

private boolean filterMatches(final Class hintClass) {
  return ReflectionUtil.isAssignable(myFilter, hintClass);
}