Java TIntObjectHashMap类代码示例

import gnu.trove.TIntObjectHashMap; //导入依赖的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.TIntObjectHashMap; //导入依赖的package包/类
public void fun(TIntObjectHashMap<TIntHashSet> m, Instruction instruction) {
  if (instruction instanceof ReadWriteVariableInstruction) {
    final ReadWriteVariableInstruction varInsn = (ReadWriteVariableInstruction) instruction;
    final String name = varInsn.getVariableName();
    if (name == null) return;
    assert myVarToIndexMap.containsKey(name);
    final int num = myVarToIndexMap.get(name);
    if (varInsn.isWrite()) {
      TIntHashSet defs = m.get(num);
      if (defs == null) {
        defs = new TIntHashSet();
        m.put(num, defs);
      } else defs.clear();
      defs.add(varInsn.num());
    }
  }
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
protected void initForGraph (FactorGraph m)
{
  super.initForGraph (m);

  int numNodes = m.numVariables ();
  factorTouched = new TIntObjectHashMap (numNodes);
  hasConverged = false;

  if (factory == null) {
    factory = new AlmostRandomTreeFactory ();
  }

  if (terminator == null) {
    terminator = new DefaultConvergenceTerminator ();
  } else {
    terminator.reset ();
  }
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
private void readObject (ObjectInputStream in) throws IOException, ClassNotFoundException
{
  in.readInt (); // version =

  int N1 = in.readInt ();
  backing = new TIntObjectHashMap (N1);

  for (int i = 0; i < N1; i++) {
    int k1 = in.readInt ();
    int N2 = in.readInt ();
    for (int j = 0; j < N2; j++) {
      int k2 = in.readInt ();
      Object value = in.readObject ();
      put (k1, k2, value);
    }
  }
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
public Icon patchIcon(Icon baseIcon, VirtualFile file, int flags, Project project) {
  if (project == null) return baseIcon;

  final TIntObjectHashMap<Icon> icons = file.getUserData(ICON_KEY);
  if (icons != null) {
    final Icon icon = icons.get(flags);
    if (icon != null) {
      return icon;
    }
  }

  final PsiFile element = PsiManager.getInstance(project).findFile(file);
  if (element != null) {
    if (XsltSupport.isXsltFile(element)) {
      return cacheIcon(file, flags, icons, XsltSupport.createXsltIcon(baseIcon));
    }
  }
  return baseIcon;
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
public void save(@NotNull final DataOutput dataOutput, TIntObjectHashMap<TIntArrayList> classAndMethodsMap)
  throws IOException {
  DataInputOutputUtil.writeINT(dataOutput, classAndMethodsMap.size());
  final int[] classNameIds = classAndMethodsMap.keys();
  Arrays.sort(classNameIds);

  int prevClassNameId = 0;
  for(int classNameId:classNameIds) {
    DataInputOutputUtil.writeINT(dataOutput, classNameId - prevClassNameId);
    TIntArrayList value = classAndMethodsMap.get(classNameId);
    DataInputOutputUtil.writeINT(dataOutput, value.size());

    final int[] methodNameIds = value.toNativeArray();
    Arrays.sort(methodNameIds);
    int prevMethodNameId = 0;
    for (int methodNameId : methodNameIds) {
      DataInputOutputUtil.writeINT(dataOutput, methodNameId - prevMethodNameId);
      prevMethodNameId = methodNameId;
    }
    prevClassNameId = classNameId;
  }
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
public TIntObjectHashMap<TIntArrayList> read(@NotNull DataInput dataInput) throws IOException {
  int numberOfClasses = DataInputOutputUtil.readINT(dataInput);
  TIntObjectHashMap<TIntArrayList> result = new TIntObjectHashMap<TIntArrayList>();
  int prevClassNameId = 0;

  while (numberOfClasses-- > 0) {
    int classNameId = DataInputOutputUtil.readINT(dataInput) + prevClassNameId;
    int numberOfMethods = DataInputOutputUtil.readINT(dataInput);
    TIntArrayList methodNameIds = new TIntArrayList(numberOfMethods);

    int prevMethodNameId = 0;
    while (numberOfMethods-- > 0) {
      final int methodNameId = DataInputOutputUtil.readINT(dataInput) + prevMethodNameId;
      methodNameIds.add(methodNameId);
      prevMethodNameId = methodNameId;
    }

    result.put(classNameId, methodNameIds);
    prevClassNameId = classNameId;
  }
  return result;
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
static ProblemDescriptor checkFileHeader(@NotNull PsiFile file, @NotNull InspectionManager manager, boolean onTheFly) {
  TIntObjectHashMap<String> offsetToProperty = new TIntObjectHashMap<String>();
  FileTemplate defaultTemplate = FileTemplateManager.getInstance(file.getProject()).getDefaultTemplate(FileTemplateManager.FILE_HEADER_TEMPLATE_NAME);
  Pattern pattern = getTemplatePattern(defaultTemplate, file.getProject(), offsetToProperty);
  Matcher matcher = pattern.matcher(file.getViewProvider().getContents());
  if (!matcher.matches()) {
    return null;
  }

  PsiComment element = PsiTreeUtil.findElementOfClassAtRange(file, matcher.start(1), matcher.end(1), PsiComment.class);
  if (element == null) {
    return null;
  }

  LocalQuickFix[] fixes = createQuickFix(matcher, offsetToProperty, file.getProject());
  String description = InspectionsBundle.message("default.file.template.description");
  return manager.createProblemDescriptor(element, description, onTheFly, fixes, ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
BindingImpl(final int index, final PsiType type) {
  myBindings = new TIntObjectHashMap<PsiType>();
  myCyclic = type instanceof PsiTypeVariable;

  myBindings.put(index, type);

  if (type instanceof Bottom) {
    final Set<PsiTypeVariable> cluster = myFactory.getClusterOf(index);

    if (cluster != null) {
      for (PsiTypeVariable var : cluster) {
        myBindings.put(var.getIndex(), type);
      }
    }
  }
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
public static String fillMethodParameters(final PsiMethod method, @Nullable final TIntObjectHashMap<SubLookupElement> replaceElements) {
  final TIntObjectHashMap<SubLookupElement> notNullReplaceElements = replaceElements == null ?
      new TIntObjectHashMap<SubLookupElement>(0) :
      replaceElements;

  final PsiParameter[] parameters = method.getParameterList().getParameters();
  final StringBuilder sb = new StringBuilder();
  for (int i = 0; i < parameters.length; i++) {
    if (i != 0) {
      sb.append(", ");
    }
    final PsiParameter parameter = parameters[i];
    final SubLookupElement replaceElement = notNullReplaceElements.get(i);
    if (replaceElement != null) {
      sb.append(replaceElement.getInsertString());
    } else {
      sb.append(parameter.getName());
    }
  }
  return sb.toString();
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
public ContextRelevantStaticMethod(final PsiMethod psiMethod, @Nullable final TIntObjectHashMap<PsiVariable> parameters) {
  this.psiMethod = psiMethod;
  if (parameters == null) {
    this.parameters = null;
  } else {
    this.parameters = new TIntObjectHashMap<SubLookupElement>(parameters.size());
    parameters.forEachEntry(new TIntObjectProcedure<PsiVariable>() {
      @SuppressWarnings("ConstantConditions")
      @Override
      public boolean execute(final int pos, final PsiVariable var) {
        ContextRelevantStaticMethod.this.parameters.put(pos, new VariableSubLookupElement(var));
        return true;
      }
    });
  }
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
private static void runTest(int nameCount, String name) throws InterruptedException, ExecutionException {
  System.out.println("----- " + name + " ------ name count: "+nameCount);

  TIntObjectHashMap<CharSequence> map = generateNames(nameCount);
  final int[] ids = map.keys();
  checkNames(map, ids);
  warmUp(ids);

  measureAverageTime(ids, 1, LONG_RANDOM_ACCESS);
  measureAverageTime(ids, 4, LONG_RANDOM_ACCESS);

  measureAverageTime(ids, 1, LONG_RANDOM_ACCESS_WITH_GET_PATH);
  measureAverageTime(ids, 4, LONG_RANDOM_ACCESS_WITH_GET_PATH);

  measureAverageTime(ids, 1, LINEAR_SCAN_AND_RANDOM_ACCESS_WITH_GET_PATH);
  measureAverageTime(ids, 4, LINEAR_SCAN_AND_RANDOM_ACCESS_WITH_GET_PATH);
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
public void testKObjectMapCloneDoesNotDependOnTheSource() {
  TIntObjectHashMap<int[]> map = new TIntObjectHashMap<int[]>();
  map.put(0, new int[2]);
  map.put(1, new int[2]);

  TIntObjectHashMap<int[]> clone = map.clone();
  assertEquals(clone.size(), 2);
  int[] keys = clone.keys();
  assertEquals(keys.length, 2);
  assertEquals(ContainerUtil.newHashSet(0,1), ContainerUtil.newHashSet(keys[0],keys[1]));

  map.clear();

  assertEquals(clone.size(), 2);
  keys = clone.keys();
  assertEquals(keys.length, 2);
  assertEquals(ContainerUtil.newHashSet(0,1), ContainerUtil.newHashSet(keys[0],keys[1]));
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
private void checkConsistency(ScheduledPass pass, TIntObjectHashMap<Pair<ScheduledPass, Integer>> id2Visits) {
  for (ScheduledPass succ : ContainerUtil.concat(pass.mySuccessorsOnCompletion, pass.mySuccessorsOnSubmit)) {
    int succId = succ.myPass.getId();
    Pair<ScheduledPass, Integer> succPair = id2Visits.get(succId);
    if (succPair == null) {
      succPair = Pair.create(succ, succ.myRunningPredecessorsCount.get());
      id2Visits.put(succId, succPair);
    }
    int newPred = succPair.second - 1;
    id2Visits.put(succId, Pair.create(succ, newPred));
    assert newPred >= 0;
    if (newPred == 0) {
      checkConsistency(succ, id2Visits);
    }
  }
}
 

import gnu.trove.TIntObjectHashMap; //导入依赖的package包/类
public DetectedFrameworksData(Project project) {
  myDetectedFrameworks = new MultiMap<Integer, DetectedFrameworkDescription>();
  File file = new File(FrameworkDetectorRegistryImpl.getDetectionDirPath() + File.separator + project.getName() + "." + project.getLocationHash() +
                       File.separator + "files");
  myNewFiles = new TIntObjectHashMap<TIntHashSet>();
  try {
    myExistentFrameworkFiles = new PersistentHashMap<Integer, TIntHashSet>(file, EnumeratorIntegerDescriptor.INSTANCE, new TIntHashSetExternalizer());
  }
  catch (IOException e) {
    LOG.info(e);
    PersistentHashMap.deleteFilesStartingWith(file);
    try {
      myExistentFrameworkFiles = new PersistentHashMap<Integer, TIntHashSet>(file, EnumeratorIntegerDescriptor.INSTANCE, new TIntHashSetExternalizer());
    }
    catch (IOException e1) {
      LOG.error(e1);
    }
  }
}