Java TIntHashSet.toArray方法代码示例

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
public TIntArrayList read(@NotNull DataInput dataInput) throws IOException {
  TIntHashSet result = new TIntHashSet();

  while (((InputStream)dataInput).available() > 0) {
    int id = DataInputOutputUtil.readINT(dataInput);
    if (REMOVED_MARKER == id) {
      id = DataInputOutputUtil.readINT(dataInput);
      result.remove(id);
    }
    else {
      result.add(id);
    }
  }

  return new TIntArrayList(result.toArray());
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
@Override
public void saveTo(DataOutput out, DataExternalizer<Value> externalizer) throws IOException {
  if (needsCompacting()) {
    getMergedData().saveTo(out, externalizer);
  } else {
    final TIntHashSet set = myInvalidated;
    if (set != null && set.size() > 0) {
      for (int inputId : set.toArray()) {
        DataInputOutputUtil.writeINT(out, -inputId); // mark inputId as invalid, to be processed on load in ValueContainerImpl.readFrom
      }
    }

    final ValueContainer<Value> toAppend = getAddedDelta();
    if (toAppend != null && toAppend.size() > 0) {
      toAppend.saveTo(out, externalizer);
    }
  }
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
public FilteredIntIterator(IIntIterator it, TIntHashSet list, boolean listDefinesRemoved) {
    _values = it;
    int[] filterValues = list.toArray();
    Arrays.sort(filterValues);
    _filter = new IntArrayIterator(filterValues);
    _remove = listDefinesRemoved;
    begin();
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
public int[] getFragmentStartingLines() {
  TIntHashSet beginnings = new TIntHashSet();
  if (myMergeList != null) {
    for (int i = 0; i < 2; i++) {
      FragmentSide branchSide = FragmentSide.fromIndex(i);
      beginnings.addAll(myMergeList.getChanges(branchSide).getNonAppliedLineBlocks().getBeginnings(MergeList.BASE_SIDE));
    }
  }
  int[] result = beginnings.toArray();
  Arrays.sort(result);
  return result;
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
@NotNull
private static int[] findAllTypedVarOffsets(final PsiFile file, final Pattern[] substitutionPatterns) {
  final TIntHashSet result = new TIntHashSet();

  file.accept(new PsiRecursiveElementWalkingVisitor() {
    @Override
    public void visitElement(PsiElement element) {
      super.visitElement(element);

      if (element instanceof LeafElement) {
        final String text = element.getText();

        for (Pattern pattern : substitutionPatterns) {
          final Matcher matcher = pattern.matcher(text);

          while (matcher.find()) {
            result.add(element.getTextRange().getStartOffset() + matcher.end());
          }
        }
      }
    }
  });

  final int[] resultArray = result.toArray();
  Arrays.sort(resultArray);
  return resultArray;
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
public int[] get(int key) {
  if (mySingle.containsKey(key)) {
    return new int[]{mySingle.get(key)};
  }
  TIntHashSet items = myMulti.get(key);
  if (items == null) return ArrayUtil.EMPTY_INT_ARRAY;
  return items.toArray();
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
@NotNull
public static TIntArrayList findParametersToRemove(@NotNull PsiMethod method,
                                                   @NotNull final PsiExpression expr,
                                                   @Nullable final PsiExpression[] occurences) {
  final PsiParameter[] parameters = method.getParameterList().getParameters();
  if (parameters.length == 0) return new TIntArrayList();

  PsiMethod[] overridingMethods = OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY);
  final PsiMethod[] allMethods = ArrayUtil.append(overridingMethods, method);

  final TIntHashSet suspects = new TIntHashSet();
  expr.accept(new JavaRecursiveElementWalkingVisitor() {
    @Override public void visitReferenceExpression(final PsiReferenceExpression expression) {
      super.visitReferenceExpression(expression);
      PsiElement resolved = expression.resolve();
      if (resolved instanceof PsiParameter) {
        int i = ArrayUtil.find(parameters, resolved);
        if (i != -1) {
          suspects.add(i);
        }
      }
    }
  });

  final TIntIterator iterator = suspects.iterator();
  while(iterator.hasNext()) {
    final int paramNum = iterator.next();
    for (PsiMethod psiMethod : allMethods) {
      PsiParameter[] psiParameters = psiMethod.getParameterList().getParameters();
      if (paramNum >= psiParameters.length) continue;
      PsiParameter parameter = psiParameters[paramNum];
      if (!ReferencesSearch.search(parameter, parameter.getResolveScope(), false).forEach(new Processor<PsiReference>() {
        public boolean process(final PsiReference reference) {
          PsiElement element = reference.getElement();
          boolean stillCanBeRemoved = false;
          if (element != null) {
            stillCanBeRemoved = isAncestor(expr, element, false) || PsiUtil.isInsideJavadocComment(getPhysical(element));
            if (!stillCanBeRemoved && occurences != null) {
              for (PsiExpression occurence : occurences) {
                if (isAncestor(occurence, element, false)) {
                  stillCanBeRemoved = true;
                  break;
                }
              }
            }
          }
          if (!stillCanBeRemoved) {
            iterator.remove();
            return false;
          }
         return true;
        }
      })) break;
    }
  }

  return new TIntArrayList(suspects.toArray());
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
@Nullable
public int[] getDefinitions(int varId) {
  TIntHashSet set = myMap.get(varId);
  return set == null ? null : set.toArray();
}