import gnu.trove.TIntProcedure; //导入依赖的package包/类
private static LinkedHashSet<Integer> getReachable(final LinkedHashSet<Integer> fragmentInsns, final Instruction[] flow, TIntObjectHashMap<TIntHashSet> dfaResult, final int[] postorder) {
  final LinkedHashSet<Integer> result = new LinkedHashSet<Integer>();
  for (Instruction insn : flow) {
    if (insn instanceof ReadWriteVariableInstruction &&
        !((ReadWriteVariableInstruction) insn).isWrite()) {
      final int ref = insn.num();
      TIntHashSet defs = dfaResult.get(ref);
      defs.forEach(new TIntProcedure() {
        public boolean execute(int def) {
          if (fragmentInsns.contains(def)) {
            if (!fragmentInsns.contains(ref) || postorder[ref] < postorder[def]) {
              result.add(ref);
              return false;
            }
          }
          return true;
        }
      });
    }
  }

  return result;
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public static <X> void save(final TIntHashSet x, final DataOutput out) {
  try {
    DataInputOutputUtil.writeINT(out, x.size());
    x.forEach(new TIntProcedure() {
      @Override
      public boolean execute(int value) {
        try {
          DataInputOutputUtil.writeINT(out, value);
          return true;
        }
        catch (IOException e) {
          throw new BuildDataCorruptedException(e);
        }
      }
    });
  }
  catch (IOException c) {
    throw new BuildDataCorruptedException(c);
  }
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
@Override
public void save(@NotNull final DataOutput out, final TIntHashSet value) throws IOException {
  final Ref<IOException> exRef = new Ref<IOException>(null);
  value.forEach(new TIntProcedure() {
    @Override
    public boolean execute(int elem) {
      try {
        DataInputOutputUtil.writeINT(out, elem);
      }
      catch (IOException e) {
        exRef.set(e);
        return false;
      }
      return true;
    }
  });
  final IOException exception = exRef.get();
  if (exception != null) {
    throw exception;
  }
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
@Override
public void removeAll(int key, TIntHashSet values) {
  final TIntHashSet collection = myMap.get(key);
  if (collection != null) {
    values.forEach(new TIntProcedure() {
      @Override
      public boolean execute(int value) {
        collection.remove(value);
        return true;
      }
    });
    if (collection.isEmpty()) {
      myMap.remove(key);
    }
  }
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
static int[] calcInLoop(ControlFlow controlFlow) {
  final int[] loop = new int[controlFlow.getInstructionCount()]; // loop[i] = loop number(strongly connected component number) of i-th instruction or 0 if outside loop

  MyGraph graph = new MyGraph(controlFlow);
  final DFSTBuilder<Instruction> builder = new DFSTBuilder<Instruction>(graph);
  TIntArrayList sccs = builder.getSCCs();
  sccs.forEach(new TIntProcedure() {
    private int myTNumber;
    private int component;

    @Override
    public boolean execute(int size) {
      int value = size > 1 ? ++component : 0;
      for (int i = 0; i < size; i++) {
        Instruction instruction = builder.getNodeByTNumber(myTNumber + i);
        loop[instruction.getIndex()] = value;
      }
      myTNumber += size;
      return true;
    }
  });

  return loop;
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public static <Node> List<Chunk<Node>> buildChunks(Graph<Node> graph) {
  final DFSTBuilder<Node> dfstBuilder = new DFSTBuilder<Node>(graph);
  final TIntArrayList sccs = dfstBuilder.getSCCs();
  final List<Chunk<Node>> chunks = new ArrayList<Chunk<Node>>();
  sccs.forEach(new TIntProcedure() {
    int myTNumber = 0;
    public boolean execute(int size) {
      Set<Node> packs = new LinkedHashSet<Node>();
      for (int j = 0; j < size; j++) {
        packs.add(dfstBuilder.getNodeByTNumber(myTNumber + j));
      }
      chunks.add(new Chunk<Node>(packs));
      myTNumber += size;
      return true;
    }
  });

  return chunks;
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public IntroduceParameterSettingsUI(PsiLocalVariable onLocalVariable,
                                    PsiExpression onExpression,
                                    PsiMethod methodToReplaceIn,
                                    TIntArrayList parametersToRemove) {
  myHasInitializer = onLocalVariable != null && onLocalVariable.getInitializer() != null;
  myIsInvokedOnDeclaration = onExpression == null;
  final PsiParameter[] parameters = methodToReplaceIn.getParameterList().getParameters();
  myParametersToRemove = new PsiParameter[parameters.length];
  myParametersToRemoveChecked = new boolean[parameters.length];
  parametersToRemove.forEach(new TIntProcedure() {
    public boolean execute(final int paramNum) {
      myParametersToRemove[paramNum] = parameters[paramNum];
      return true;
    }
  });
  myIsLocalVariable = onLocalVariable != null;
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
private static void removeParametersFromCall(@NotNull final PsiExpressionList argList, TIntArrayList parametersToRemove) {
  final PsiExpression[] exprs = argList.getExpressions();
  parametersToRemove.forEachDescending(new TIntProcedure() {
    public boolean execute(final int paramNum) {
      try {
        if (paramNum < exprs.length) {
          exprs[paramNum].delete();
        }
      }
      catch (IncorrectOperationException e) {
        LOG.error(e);
      }
      return true;
    }
  });
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public void findConflicts(IntroduceParameterData data, UsageInfo[] usages, final MultiMap<PsiElement, String> conflicts) {
  final PsiMethod method = data.getMethodToReplaceIn();
  final int parametersCount = method.getParameterList().getParametersCount();
  for (UsageInfo usage : usages) {
    if (!isMethodUsage(usage)) continue;
    final PsiElement element = usage.getElement();
    final PsiCall call = RefactoringUtil.getCallExpressionByMethodReference(element);
    final PsiExpressionList argList = call.getArgumentList();
    if (argList != null) {
      final int actualParamLength = argList.getExpressions().length;
      if ((method.isVarArgs() && actualParamLength + 1 < parametersCount) ||
          (!method.isVarArgs() && actualParamLength < parametersCount)) {
        conflicts.putValue(call, "Incomplete call(" + call.getText() +"): " + parametersCount + " parameters expected but only " + actualParamLength + " found");
      }
      data.getParametersToRemove().forEach(new TIntProcedure() {
        public boolean execute(int paramNum) {
          if (paramNum >= actualParamLength) {
            conflicts.putValue(call, "Incomplete call(" + call.getText() +"): expected to delete the " + paramNum + " parameter but only " + actualParamLength + " parameters found");
          }
          return true;
        }
      });
    }
  }
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public static boolean processTextOccurrences(@NotNull CharSequence text,
                                             int startOffset,
                                             int endOffset,
                                             @NotNull StringSearcher searcher,
                                             @Nullable ProgressIndicator progress,
                                             @NotNull TIntProcedure processor) {
  if (endOffset > text.length()) {
    throw new AssertionError("end>length");
  }
  for (int index = startOffset; index < endOffset; index++) {
    if (progress != null) progress.checkCanceled();
    //noinspection AssignmentToForLoopParameter
    index = searcher.scan(text, index, endOffset);
    if (index < 0) break;
    if (checkJavaIdentifier(text, startOffset, endOffset, searcher, index)) {
      if (!processor.execute(index)) return false;
    }
  }
  return true;
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public void testTrailingSoftWrapOffsetShiftOnTyping() throws IOException {
  // The main idea is to type on a logical line before soft wrap in order to ensure that its offset is correctly shifted back.
  String text = 
    "line1<caret>\n" +
    "second line that is long enough to be soft wrapped";
  init(15, text);

  TIntHashSet offsetsBefore = collectSoftWrapStartOffsets(1);
  assertTrue(!offsetsBefore.isEmpty());
  
  type('2');
  final TIntHashSet offsetsAfter = collectSoftWrapStartOffsets(1);
  assertSame(offsetsBefore.size(), offsetsAfter.size());
  offsetsBefore.forEach(new TIntProcedure() {
    @Override
    public boolean execute(int value) {
      assertTrue(offsetsAfter.contains(value + 1));
      return true;
    }
  });
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
private static void removeParametersFromCall(final GrClosureSignatureUtil.ArgInfo<PsiElement>[] actualArgs,final TIntArrayList parametersToRemove) {
  parametersToRemove.forEach(new TIntProcedure() {
    @Override
    public boolean execute(final int paramNum) {
      try {
        final GrClosureSignatureUtil.ArgInfo<PsiElement> actualArg = actualArgs[paramNum];
        if (actualArg == null) return true;
        for (PsiElement arg : actualArg.args) {
          arg.delete();
        }
      }
      catch (IncorrectOperationException e) {
        LOG.error(e);
      }
      return true;
    }
  });
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
private static void removeParametersFromCall(GrMethodCallExpression methodCall, GrIntroduceParameterSettings settings) {
  final GroovyResolveResult resolveResult = methodCall.advancedResolve();
  final PsiElement resolved = resolveResult.getElement();
  LOG.assertTrue(resolved instanceof PsiMethod);
  final GrClosureSignature signature = GrClosureSignatureUtil.createSignature((PsiMethod)resolved, resolveResult.getSubstitutor());
  final GrClosureSignatureUtil.ArgInfo<PsiElement>[] argInfos = GrClosureSignatureUtil.mapParametersToArguments(signature, methodCall);
  LOG.assertTrue(argInfos != null);
  settings.parametersToRemove().forEach(new TIntProcedure() {
    @Override
    public boolean execute(int value) {
      final List<PsiElement> args = argInfos[value].args;
      for (PsiElement arg : args) {
        arg.delete();
      }
      return true;
    }
  });
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public static void removeParametersFromCall(final GrClosureSignatureUtil.ArgInfo<PsiElement>[] actualArgs, final TIntArrayList parametersToRemove) {
  parametersToRemove.forEach(new TIntProcedure() {
    @Override
    public boolean execute(final int paramNum) {
      try {
        final GrClosureSignatureUtil.ArgInfo<PsiElement> actualArg = actualArgs[paramNum];
        for (PsiElement arg : actualArg.args) {
          arg.delete();
        }
      }
      catch (IncorrectOperationException e) {
        LOG.error(e);
      }
      return true;
    }
  });
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public static <X> void save(final TIntHashSet x, final DataOutput out) {
  try {
    out.writeInt(x.size());
    x.forEach(new TIntProcedure() {
      @Override
      public boolean execute(int value) {
        try {
          out.writeInt(value);
          return true;
        }
        catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
    });
  }
  catch (IOException c) {
    throw new RuntimeException(c);
  }
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
@Override
public void save(final DataOutput out, final TIntHashSet value) throws IOException {
  final Ref<IOException> exRef = new Ref<IOException>(null);
  value.forEach(new TIntProcedure() {
    @Override
    public boolean execute(int elem) {
      try {
        out.writeInt(elem);
      }
      catch (IOException e) {
        exRef.set(e);
        return false;
      }
      return true;
    }
  });
  final IOException exception = exRef.get();
  if (exception != null) {
    throw exception;
  }
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
@NotNull
@Override
public DataIndexer<Integer, Void, FileContent> getIndexer() {
  return new DataIndexer<Integer, Void, FileContent>() {
    @Override
    @NotNull
    public Map<Integer, Void> map(FileContent inputData) {
      final Map<Integer, Void> result = new THashMap<Integer, Void>();
      TIntHashSet built = TrigramBuilder.buildTrigram(inputData.getContentAsText());
      built.forEach(new TIntProcedure() {
        @Override
        public boolean execute(int value) {
          result.put(value, null);
          return true;
        }
      });
      return result;
    }
  };
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
private static void removeParametersFromCall(final GrClosureSignatureUtil.ArgInfo<PsiElement>[] actualArgs,final TIntArrayList parametersToRemove) {
  parametersToRemove.forEach(new TIntProcedure() {
    public boolean execute(final int paramNum) {
      try {
        final GrClosureSignatureUtil.ArgInfo<PsiElement> actualArg = actualArgs[paramNum];
        if (actualArg == null) return true;
        for (PsiElement arg : actualArg.args) {
          arg.delete();
        }
      }
      catch (IncorrectOperationException e) {
        LOG.error(e);
      }
      return true;
    }
  });
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
public static void removeParametersFromCall(final GrClosureSignatureUtil.ArgInfo<PsiElement>[] actualArgs, final TIntArrayList parametersToRemove) {
  parametersToRemove.forEach(new TIntProcedure() {
    public boolean execute(final int paramNum) {
      try {
        final GrClosureSignatureUtil.ArgInfo<PsiElement> actualArg = actualArgs[paramNum];
        for (PsiElement arg : actualArg.args) {
          arg.delete();
        }
      }
      catch (IncorrectOperationException e) {
        LOG.error(e);
      }
      return true;
    }
  });
}
 

import gnu.trove.TIntProcedure; //导入依赖的package包/类
List<DfaValue> getMemberValues() {
  final List<DfaValue> result = new ArrayList<DfaValue>(size());
  forEach(new TIntProcedure() {
    @Override
    public boolean execute(int c1) {
      DfaValue value = myFactory.getValue(c1);
      result.add(value);
      return true;
    }
  });
  return result;
}