Java TObjectIntHashMap.put方法代码示例

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

    int numVariables = in.readInt ();
    var2idx = new TObjectIntHashMap (numVariables);
    for (int vi = 0; vi < numVariables; vi++) {
      Variable var = (Variable) in.readObject ();
      var2idx.put (var, vi);
    }

    int numRows = in.readInt ();
    values = new ArrayList (numRows);
    for (int ri = 0; ri < numRows; ri++) {
      Object[] row = (Object[]) in.readObject ();
      values.add (row);
    }

    scale = (version >= 2) ? in.readDouble () : 1.0;
  }
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
public synchronized void increment(@NotNull String groupName,
                                   @NotNull NotificationSource source,
                                   @NotNull NotificationCategory category,
                                   @NotNull ProjectSystemId projectSystemId) {

  final TObjectIntHashMap<NotificationCategory> counter =
    ContainerUtil.getOrCreate(
      ContainerUtil.getOrCreate(
        ContainerUtil.getOrCreate(
          map,
          projectSystemId,
          ContainerUtil.<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>>newHashMap()),
        groupName,
        ContainerUtil.<NotificationSource, TObjectIntHashMap<NotificationCategory>>newHashMap()
      ),
      source,
      new MyTObjectIntHashMap<NotificationCategory>()
    );
  if (!counter.increment(category)) counter.put(category, 1);
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
private static int[] getRoute(ASTNode node, TObjectIntHashMap<ASTNode> index){
  final List<ASTNode> parents = new ArrayList<ASTNode>(20);
  while(node != null){
    ASTNode nodeTreeParent = node.getTreeParent();
    if (nodeTreeParent == null) break;
    if (!index.contains(node)) {
      ASTNode current = nodeTreeParent.getFirstChildNode();
      int rootIndex = 0;

      while(current != null){
        index.put(current, rootIndex);
        current = current.getTreeNext();
        rootIndex++;
      }
    }
    parents.add(node);
    node = nodeTreeParent;
  }
  final int[] root = new int[parents.size()];
  for(int i = 0; i < root.length; i++){
    final ASTNode parent = parents.get(root.length - i - 1);
    root[i] = index.get(parent);
  }
  return root;
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
private static String generateUniqueVariableName(@NonNls final String className, final TObjectIntHashMap<String> class2variableIndex,
                                                 final PsiClass aClass) {
  final String shortName;
  if (className.startsWith("javax.swing.J")) {
    shortName = className.substring("javax.swing.J".length());
  }
  else {
    final int idx = className.lastIndexOf('.');
    if (idx != -1) {
      shortName = className.substring(idx + 1);
    }
    else {
      shortName = className;
    }
  }

  if (!class2variableIndex.containsKey(className)) class2variableIndex.put(className, 0);
  String result;
  do {
    class2variableIndex.increment(className);
    int newIndex = class2variableIndex.get(className);

    result = Character.toLowerCase(shortName.charAt(0)) + shortName.substring(1) + newIndex;
  } while(aClass.findFieldByName(result, true) != null);
  return result;
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
@Override
public void fun(TObjectIntHashMap<GrVariable> map, Instruction instruction) {
  if (!(instruction instanceof ReadWriteVariableInstruction)) return;

  final ReadWriteVariableInstruction rwInstruction = (ReadWriteVariableInstruction)instruction;
  if (!rwInstruction.isWrite()) return;

  final GrVariable variable = getVariable(instruction.getElement());
  if (variable == null) return;

  int currentVal = map.get(variable);
  if (currentVal == 2) return;

  if (currentVal == 0 || currentVal == 1 && !(variable.getParent() instanceof GrForInClause)) currentVal++;
  map.put(variable, currentVal);
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
public synchronized void increment(@Nonnull String groupName,
                                   @Nonnull NotificationSource source,
                                   @Nonnull NotificationCategory category,
                                   @Nonnull ProjectSystemId projectSystemId) {

  final TObjectIntHashMap<NotificationCategory> counter =
          ContainerUtil.getOrCreate(
                  ContainerUtil.getOrCreate(
                          ContainerUtil.getOrCreate(
                                  map,
                                  projectSystemId,
                                  ContainerUtil.<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>>newHashMap()),
                          groupName,
                          ContainerUtil.<NotificationSource, TObjectIntHashMap<NotificationCategory>>newHashMap()
                  ),
                  source,
                  new TObjectIntHashMap<NotificationCategory>()
          );
  if (!counter.increment(category)) counter.put(category, 1);
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
private static TObjectIntHashMap<String> buildNamesIndex(Instruction[] flow) {
    TObjectIntHashMap<String> namesIndex = new TObjectIntHashMap<String>();
    int idx = 0;
    for (Instruction instruction : flow) {
        if (instruction instanceof ReadWriteVariableInstruction) {
            String name = ((ReadWriteVariableInstruction) instruction).getVariableName();
            if (!namesIndex.contains(name)) {
                namesIndex.put(name, idx++);
            }
        }
    }
    return namesIndex;
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
private TObjectIntHashMap<Instruction> visitPostOrderIterative(Instruction start, ArrayList<Instruction> instructionsInPostOrderTraversalOfReverseControlFlowGraph) {
	
	TObjectIntHashMap<Instruction>postOrderNumbers = new TObjectIntHashMap<Instruction>();
	
	ArrayList<Instruction> stack = new ArrayList<Instruction>();
	TIntHashSet visitedIndices = new TIntHashSet(code.getNumberOfInstructions());
	TIntHashSet processedIndices = new TIntHashSet(code.getNumberOfInstructions());
	
	stack.add(start);
	while(stack.size() > 0) {
		Instruction top = stack.get(stack.size() - 1);
		if(visitedIndices.contains(top.getIndex())) {
			stack.remove(stack.size() - 1);
			if(!processedIndices.contains(top.getIndex())) {
				processedIndices.add(top.getIndex());
				
				instructionsInPostOrderTraversalOfReverseControlFlowGraph.add(0, top);
				postOrderNumbers.put(top, instructionsInPostOrderTraversalOfReverseControlFlowGraph.size());

			}
		}
		// Remember that we were here, then add the predecessors in reverse order to the stack.
		else {
			visitedIndices.add(top.getIndex());
			int insertionIndex = 0;
			for(Instruction predecessor : top.getOrderedPredecessors()) {
				if(!visitedIndices.contains(predecessor.getIndex())) {
					stack.add(stack.size() - insertionIndex, predecessor);
					insertionIndex++;
				}
			}
		}

	}

	return postOrderNumbers;
	
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
@Override
public TObjectIntHashMap<K> read(@NotNull final DataInput in) throws IOException {
  final int size = in.readInt();
  final TObjectIntHashMap<K> map = new TObjectIntHashMap<K>(size);
  for (int i = 0; i < size; i++) {
    map.put(myKeyDataExternalizer.read(in), in.readInt());
  }
  return map;
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
private TObjectIntHashMap<String> getAnnotationsOrderMap() {
  final TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
  for (int i = 0; i < myAnnotationMethods.length; i++) {
    map.put(myAnnotationMethods[i].getName(), i);
  }
  return map;
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
@NotNull
public List<JavaArrangementOverriddenMethodsInfo> getOverriddenMethods() {
  List<JavaArrangementOverriddenMethodsInfo> result = new ArrayList<JavaArrangementOverriddenMethodsInfo>();
  final TObjectIntHashMap<PsiMethod> weights = new TObjectIntHashMap<PsiMethod>();
  Comparator<Pair<PsiMethod, PsiMethod>> comparator = new Comparator<Pair<PsiMethod, PsiMethod>>() {
    @Override
    public int compare(Pair<PsiMethod, PsiMethod> o1, Pair<PsiMethod, PsiMethod> o2) {
      return weights.get(o1.first) - weights.get(o2.first);
    }
  };
  for (Map.Entry<PsiClass, List<Pair<PsiMethod, PsiMethod>>> entry : myOverriddenMethods.entrySet()) {
    JavaArrangementOverriddenMethodsInfo info = new JavaArrangementOverriddenMethodsInfo(entry.getKey().getName());
    weights.clear();
    int i = 0;
    for (PsiMethod method : entry.getKey().getMethods()) {
      weights.put(method, i++);
    }
    ContainerUtil.sort(entry.getValue(), comparator);
    for (Pair<PsiMethod, PsiMethod> pair : entry.getValue()) {
      JavaElementArrangementEntry overridingMethodEntry = myMethodEntriesMap.get(pair.second);
      if (overridingMethodEntry != null) {
        info.addMethodEntry(overridingMethodEntry);
      }
    }
    if (!info.getMethodEntries().isEmpty()) {
      result.add(info);
    }
  }

  return result;
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
@NotNull
private static OrderMap fromList(@NotNull List<HighlightSeverity> orderList) {
  TObjectIntHashMap<HighlightSeverity> map = new TObjectIntHashMap<HighlightSeverity>();
  for (int i = 0; i < orderList.size(); i++) {
    HighlightSeverity severity = orderList.get(i);
    map.put(severity, i);
  }
  return new OrderMap(map);
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
public void ensureSubProjectsStructure(@NotNull ExternalProjectPojo topLevelProject,
                                       @NotNull Collection<ExternalProjectPojo> subProjects) {
  ExternalSystemNode<ExternalProjectPojo> topLevelProjectNode = ensureProjectNodeExists(topLevelProject);
  Map<String/*config path*/, ExternalProjectPojo> toAdd = ContainerUtilRt.newHashMap();
  for (ExternalProjectPojo subProject : subProjects) {
    toAdd.put(subProject.getPath(), subProject);
  }
  toAdd.remove(topLevelProject.getPath());

  final TObjectIntHashMap<Object> taskWeights = new TObjectIntHashMap<Object>();
  for (int i = 0; i < topLevelProjectNode.getChildCount(); i++) {
    ExternalSystemNode<?> child = topLevelProjectNode.getChildAt(i);
    Object childElement = child.getDescriptor().getElement();
    if (childElement instanceof ExternalTaskExecutionInfo) {
      taskWeights.put(childElement, subProjects.size() + i);
      continue;
    }
    if (toAdd.remove(((ExternalProjectPojo)childElement).getPath()) == null) {
      removeNodeFromParent(child);
      //noinspection AssignmentToForLoopParameter
      i--;
    }
  }
  if (!toAdd.isEmpty()) {
    for (Map.Entry<String, ExternalProjectPojo> entry : toAdd.entrySet()) {
      ExternalProjectPojo
        element = new ExternalProjectPojo(entry.getValue().getName(), entry.getValue().getPath());
      insertNodeInto(new ExternalSystemNode<ExternalProjectPojo>(descriptor(element, myUiAware.getProjectIcon())),
                     topLevelProjectNode);
    }
  }
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
private void computeDistancesToTarget() {
  myNonTreeEdges = new MultiMap<Node, GraphEdge<Node>>();
  mySortedNodes = new ArrayList<Node>();
  myNextNodes = new HashMap<Node, Node>();
  TObjectIntHashMap<Node> distances = new TObjectIntHashMap<Node>();
  Deque<Node> nodes = new ArrayDeque<Node>();
  nodes.addLast(myFinish);
  distances.put(myFinish, 0);
  while (!nodes.isEmpty()) {
    myProgressIndicator.checkCanceled();
    Node node = nodes.removeFirst();
    mySortedNodes.add(node);
    int d = distances.get(node) + 1;
    Iterator<Node> iterator = myGraph.getIn(node);
    while (iterator.hasNext()) {
      Node prev = iterator.next();
      if (distances.containsKey(prev)) {
        int dPrev = distances.get(prev);
        myNonTreeEdges.putValue(prev, new GraphEdge<Node>(prev, node, d - dPrev));
        continue;
      }
      distances.put(prev, d);
      myNextNodes.put(prev, node);
      nodes.addLast(prev);
    }
  }
}
 

import gnu.trove.TObjectIntHashMap; //导入方法依赖的package包/类
private static <E extends ArrangementEntry> void sortByName(@NotNull List<E> entries) {
  if (entries.size() < 2) {
    return;
  }
  final TObjectIntHashMap<E> weights = new TObjectIntHashMap<E>();
  int i = 0;
  for (E e : entries) {
    weights.put(e, ++i);
  }
  ContainerUtil.sort(entries, new Comparator<E>() {
    @Override
    public int compare(E e1, E e2) {
      String name1 = e1 instanceof NameAwareArrangementEntry ? ((NameAwareArrangementEntry)e1).getName() : null;
      String name2 = e2 instanceof NameAwareArrangementEntry ? ((NameAwareArrangementEntry)e2).getName() : null;
      if (name1 != null && name2 != null) {
        return name1.compareTo(name2);
      }
      else if (name1 == null && name2 == null) {
        return weights.get(e1) - weights.get(e2);
      }
      else if (name2 == null) {
        return -1;
      }
      else {
        return 1;
      }
    }
  });
}