Java UsageInfo.EMPTY_ARRAY属性代码示例

@NotNull
@Override
protected UsageInfo[] findUsages() {
  if (!myProperties.hasSomethingToDo()) {
    return UsageInfo.EMPTY_ARRAY;
  }
  final List<UsageInfo> list = new ArrayList<UsageInfo>();

  if (myProperties.updateAndroidManifest) {
    addManifestRefactoring(list);
    // TODO: Update build.gradle as well
  }

  if (myProperties.updateLayouts) {
    addLayoutRefactoring(list);
  }

  final int size = list.size();
  return list.toArray(new UsageInfo[size]);
}
 

@NotNull
@Override
protected UsageInfo[] findUsages() {
  final GrVariable var = (GrVariable)myHelper.getToSearchFor();
  if (var != null) {
    final List<UsageInfo> result = new ArrayList<UsageInfo>();
    for (PsiReference ref : ReferencesSearch.search(var)) {
      final PsiElement element = ref.getElement();
      if (element.getLanguage() != GroovyLanguage.INSTANCE) {
        result.add(new OtherLanguageUsageInfo(ref));
        continue;
      }

      final GrCall call = GroovyRefactoringUtil.getCallExpressionByMethodReference(element);
      if (call == null) continue;

      result.add(new ExternalUsageInfo(element));
    }
    return result.toArray(new UsageInfo[result.size()]);
  }
  return UsageInfo.EMPTY_ARRAY;
}
 

@NotNull
protected UsageInfo[] findUsages() {
  ArrayList<UsageInfo> usagesVector = new ArrayList<UsageInfo>();
  try {
    if (myMigrationMap == null) {
      return UsageInfo.EMPTY_ARRAY;
    }
    for (int i = 0; i < myMigrationMap.getEntryCount(); i++) {
      MigrationMapEntry entry = myMigrationMap.getEntryAt(i);
      UsageInfo[] usages;
      if (entry.getType() == MigrationMapEntry.PACKAGE) {
        usages = MigrationUtil.findPackageUsages(myProject, myPsiMigration, entry.getOldName());
      }
      else {
        usages = MigrationUtil.findClassUsages(myProject, myPsiMigration, entry.getOldName());
      }

      for (UsageInfo usage : usages) {
        usagesVector.add(new MigrationUsageInfo(usage, entry));
      }
    }
  }
  finally {
    myPsiMigration.finish();
    myPsiMigration = null;
  }
  return usagesVector.toArray(new MigrationUsageInfo[usagesVector.size()]);
}
 

public UsageInfo[] findUsages() {
  ArrayList<UsageInfo> result = new ArrayList<UsageInfo>();
  final PsiElement element = myChangeInfo.getMethod();
  if (element instanceof PsiMethod) {
    final PsiMethod method = (PsiMethod)element;

    findSimpleUsages(method, result);

    final UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]);
    return UsageViewUtil.removeDuplicatedUsages(usageInfos);
  }
  return UsageInfo.EMPTY_ARRAY;
}
 

@Override
public UsageInfo[] findUsages(ChangeInfo info) {
  if (info instanceof JavaChangeInfo) {
    return new JavaChangeSignatureUsageSearcher((JavaChangeInfo)info).findUsages();
  }
  else {
    return UsageInfo.EMPTY_ARRAY;
  }
}
 

@Override
@NotNull
protected UsageInfo[] findUsages() {
  final List<UsageInfo> result = new ArrayList<UsageInfo>();
  for (MemberInfo memberInfo : myMembersToMove) {
    final PsiMember member = memberInfo.getMember();
    if (member.hasModifierProperty(PsiModifier.STATIC)) {
      for (PsiReference reference : ReferencesSearch.search(member)) {
        result.add(new UsageInfo(reference));
      }
    }
  }
  return result.isEmpty() ? UsageInfo.EMPTY_ARRAY : result.toArray(new UsageInfo[result.size()]);
}
 

@Override
@NotNull
protected UsageInfo[] findUsages() {
  final List<SmartPsiElementPointer> toInvert = new ArrayList<SmartPsiElementPointer>();

  final LinkedHashSet<PsiElement> elementsToInvert = new LinkedHashSet<PsiElement>();
  myDelegate.collectRefElements(myElement, myRenameProcessor, myNewName, elementsToInvert);
  for (PsiElement element : elementsToInvert) {
    toInvert.add(mySmartPointerManager.createSmartPsiElementPointer(element));
  }

  final UsageInfo[] renameUsages = myRenameProcessor != null ? myRenameProcessor.findUsages() : UsageInfo.EMPTY_ARRAY;

  final SmartPsiElementPointer[] usagesToInvert = toInvert.toArray(new SmartPsiElementPointer[toInvert.size()]);

  //merge rename and invert usages
  Map<PsiElement, UsageInfo> expressionsToUsages = new HashMap<PsiElement, UsageInfo>();
  List<UsageInfo> result = new ArrayList<UsageInfo>();
  for (UsageInfo renameUsage : renameUsages) {
    expressionsToUsages.put(renameUsage.getElement(), renameUsage);
    result.add(renameUsage);
  }

  for (SmartPsiElementPointer pointer : usagesToInvert) {
    final PsiElement expression = pointer.getElement();
    if (!expressionsToUsages.containsKey(expression)) {
      final UsageInfo usageInfo = new UsageInfo(expression);
      expressionsToUsages.put(expression, usageInfo);
      result.add(usageInfo); //fake UsageInfo
      myToInvert.put(usageInfo, pointer);
    } else {
      myToInvert.put(expressionsToUsages.get(expression), pointer);
    }
  }

  return result.toArray(new UsageInfo[result.size()]);
}
 

@Override
public UsageInfo[] findUsages(ChangeInfo info) {
  if (info instanceof PyChangeInfo) {
    final List<UsageInfo> usages = PyRefactoringUtil.findUsages(((PyChangeInfo)info).getMethod(), true);
    final Query<PyFunction> search = PyOverridingMethodsSearch.search(((PyChangeInfo)info).getMethod(), true);
    final Collection<PyFunction> functions = search.findAll();
    for (PyFunction function : functions) {
      usages.add(new UsageInfo(function));
      usages.addAll(PyRefactoringUtil.findUsages(function, true));
    }
    return usages.toArray(new UsageInfo[usages.size()]);
  }
  return UsageInfo.EMPTY_ARRAY;
}
 

@Override
public UsageInfo[] findUsages(ChangeInfo info) {
  if (info instanceof JavaChangeInfo) {
    return new GrChageSignatureUsageSearcher((JavaChangeInfo)info).findUsages();
  }
  return UsageInfo.EMPTY_ARRAY;
}
 

@NotNull
@Override
protected UsageInfo[] findUsages() {
  return UsageInfo.EMPTY_ARRAY;
}