import gnu.trove.TIntObjectProcedure; //导入依赖的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.TIntObjectProcedure; //导入依赖的package包/类
@Override
public String toString() {
  @NonNls final StringBuilder s = new StringBuilder();
  s.append("defensivelyMarked = ").append(defensivelyMarked);
  s.append("; wolfPassFinfished = ").append(wolfPassFinished);
  s.append("; errorFound = ").append(errorFound);
  s.append("; dirtyScopes: (");
  dirtyScopes.forEachEntry(new TIntObjectProcedure<RangeMarker>() {
    @Override
    public boolean execute(int passId, RangeMarker rangeMarker) {
      s.append(" pass: ").append(passId).append(" -> ").append(rangeMarker == WHOLE_FILE_DIRTY_MARKER ? "Whole file" : rangeMarker).append(";");
      return true;
    }
  });
  s.append(")");
  return s.toString();
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
/**
 * Removes data for all tabs and fold regions that start at or after the given offset.
 * 
 * @param offset  target offset
 */
public void removeAllDataAtOrAfter(final int offset) {
  if (myFoldingData != DUMMY && !myFoldingData.isEmpty()) {
    myFoldingData.retainEntries(new TIntObjectProcedure<FoldingData>() {
      @Override
      public boolean execute(int a, FoldingData b) {
        return a < offset;
      }
    });
  }
  int i;
  for (i = 0; i < myTabPositions.size(); i++) {
    if (myTabPositions.get(i).offset >= offset) {
      break;
    }
  }
  myTabPositions.subList(i, myTabPositions.size()).clear();
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
public void checkTimeout() {
  LOG.debug("Checking timeout");
  final List<TimeoutHandler> timedOut = new ArrayList<TimeoutHandler>();
  synchronized (myLock) {
    final long time = System.currentTimeMillis();
    myTimeoutHandlers.retainEntries(new TIntObjectProcedure<TimeoutHandler>() {
      public boolean execute(int a, TimeoutHandler b) {
        if (time > b.myLastTime) {
          timedOut.add(b);
          return false;
        }
        return true;
      }
    });
  }
  for (TimeoutHandler handler : timedOut) {
    LOG.debug("performing timeout action: " + handler.myAction);
    handler.myAction.run();
  }
  scheduleTimeoutCheck();
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的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 false;
      }
    });
  }
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
public void merge(DefinitionMap map2) {
  map2.myMap.forEachEntry(new TIntObjectProcedure<TIntHashSet>() {
    public boolean execute(int num, TIntHashSet defs) {
      TIntHashSet defs2 = myMap.get(num);
      if (defs2 == null) {
        defs2 = new TIntHashSet(defs.toArray());
        myMap.put(num, defs2);
      }
      else {
        defs2.addAll(defs.toArray());
      }

      return true;
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
protected List<StructureViewTreeElement> collectMyElements(final Set<String> referencedNamedIds)
{
	final TIntObjectHashMap<PsiElement> offset2Element = new TIntObjectHashMap<PsiElement>();

	collectChildrenFromElement(myElement, referencedNamedIds, offset2Element);


	final List<StructureViewTreeElement> children = new ArrayList<StructureViewTreeElement>(offset2Element.size());
	offset2Element.forEachEntry(new TIntObjectProcedure<PsiElement>()
	{
		@Override
		public boolean execute(int textOffset, PsiElement element)
		{
			children.add(createStructureViewElement(element));
			return true;
		}
	});
	return children;
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
public String toString()
{
	final StringBuilder s = new StringBuilder("{");
	forEachEntry(new TIntObjectProcedure<int[]>()
	{
		@Override
		public boolean execute(int id, int[] set)
		{
			DfaValue value = myFactory.getValue(id);
			s.append(value).append(" -> ").append(Arrays.toString(set)).append(", ");
			return true;
		}
	});
	s.append("}");
	return s.toString();
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
public boolean eq(final TIntObjectHashMap<TIntHashSet> m1, final TIntObjectHashMap<TIntHashSet> m2) {
  if (m1.size() != m2.size()) return false;

  return m1.forEachEntry(new TIntObjectProcedure<TIntHashSet>() {
    public boolean execute(int num, TIntHashSet defs1) {
      final TIntHashSet defs2 = m2.get(num);
      return defs2 != null && defs2.equals(defs1);
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
public void putAll(IntIntMultiMaplet m) {
  m.forEachEntry(new TIntObjectProcedure<TIntHashSet>() {
    @Override
    public boolean execute(int key, TIntHashSet value) {
      put(key, value);
      return true;
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
public void replaceAll(IntIntMultiMaplet m) {
  m.forEachEntry(new TIntObjectProcedure<TIntHashSet>() {
    @Override
    public boolean execute(int key, TIntHashSet value) {
      replace(key, value);
      return true;
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
public void putAll(IntIntMultiMaplet m) {
  m.forEachEntry(new TIntObjectProcedure<TIntHashSet>() {
    @Override
    public boolean execute(int key, TIntHashSet values) {
      put(key, values);
      return true;
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
public void putAll(IntObjectMultiMaplet<V> m) {
  m.forEachEntry(new TIntObjectProcedure<Collection<V>>() {
    @Override
    public boolean execute(int key, Collection<V> value) {
      put(key, value);
      return true;
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
public void replaceAll(IntObjectMultiMaplet<V> m) {
  m.forEachEntry(new TIntObjectProcedure<Collection<V>>() {
    @Override
    public boolean execute(int key, Collection<V> value) {
      replace(key, value);
      return true;
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
protected CacheEntry clone() {
  final CacheEntry result = new CacheEntry(visualLine, myEditor);

  result.startLogicalLine = startLogicalLine;
  result.startLogicalColumn = startLogicalColumn;
  result.startOffset = startOffset;
  result.startSoftWrapLinesBefore = startSoftWrapLinesBefore;
  result.startSoftWrapLinesCurrent = startSoftWrapLinesCurrent;
  result.startSoftWrapColumnDiff = startSoftWrapColumnDiff;
  result.startFoldedLines = startFoldedLines;
  result.startFoldingColumnDiff = startFoldingColumnDiff;

  result.endOffset = endOffset;
  result.endLogicalLine = endLogicalLine;
  result.endLogicalColumn = endLogicalColumn;
  result.endVisualColumn = endVisualColumn;
  result.endSoftWrapLinesBefore = endSoftWrapLinesBefore;
  result.endSoftWrapLinesCurrent = endSoftWrapLinesCurrent;
  result.endSoftWrapColumnDiff = endSoftWrapColumnDiff;
  result.endFoldedLines = endFoldedLines;
  result.endFoldingColumnDiff = endFoldingColumnDiff;

  myFoldingData.forEachEntry(new TIntObjectProcedure<FoldingData>() {
    @Override
    public boolean execute(int offset, FoldingData foldData) {
      result.store(foldData, offset);
      return true;
    }
  });
  for (TabData tabPosition : myTabPositions) {
    result.storeTabData(tabPosition);
  }

  return result;
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
private static void checkConsistencyWithFoldingsAndTabs(CacheEntry entry) {
  Map<Integer, FoldRegion> actualFoldRegions = new HashMap<Integer, FoldRegion>();
  List<Integer> actualTabPositions = new ArrayList<Integer>();
  for (int i = entry.startOffset; i < entry.endOffset; i++) {
    FoldRegion region = myEditor.getFoldingModel().getCollapsedRegionAtOffset(i);
    if (region == null) {
      if (myEditor.getDocument().getCharsSequence().charAt(i) == '\t') {
        actualTabPositions.add(i);
      }
    }
    else {
      if (region.getStartOffset() == i) {
        actualFoldRegions.put(i, region);
      }
    }
  }
  final Map<Integer, FoldRegion> cachedFoldRegions = new HashMap<Integer, FoldRegion>();
  entry.getFoldingData().forEachEntry(new TIntObjectProcedure<FoldingData>() {
    @Override
    public boolean execute(int offset, FoldingData data) {
      cachedFoldRegions.put(offset, data.getFoldRegion());
      return true;
    }
  });
  assertEquals(actualFoldRegions, cachedFoldRegions);
  List<Integer> cachedTabPositions = new ArrayList<Integer>();
  for (TabData tabData : entry.getTabData()) {
    cachedTabPositions.add(tabData.offset);
  }
  assertEquals(actualTabPositions, cachedTabPositions);
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
public String toString() {
  final StringBuilder s = new StringBuilder();
  forEachEntry(new TIntObjectProcedure<Object>() {
    @Override
    public boolean execute(int key, Object value) {
      s.append(s.length() == 0 ? "" : ", ").append(Key.getKeyByIndex(key)).append(" -> ").append(value);
      return true;
    }
  });
  return "[" + s.toString() + "]";
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
public boolean eq(final DefinitionMap m2) {
  if (myMap.size() != m2.myMap.size()) return false;

  return myMap.forEachEntry(new TIntObjectProcedure<TIntHashSet>() {
    @Override
    public boolean execute(int num, TIntHashSet defs1) {
      final TIntHashSet defs2 = m2.myMap.get(num);
      return defs2 != null && defs2.equals(defs1);
    }
  });
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
public synchronized List<Breakpoint> getBreakpoints() {
  final ArrayList<Breakpoint> breakpoints = new ArrayList<Breakpoint>();
  myBreakpoints.forEachEntry(new TIntObjectProcedure<Map<String, Breakpoint>>() {
    public boolean execute(int i, Map<String, Breakpoint> map) {
      breakpoints.addAll(map.values());
      return true;
    }
  });
  return breakpoints;
}
 

import gnu.trove.TIntObjectProcedure; //导入依赖的package包/类
@Override
void putAll(IntObjectMaplet<V> m) {
  m.forEachEntry(new TIntObjectProcedure<V>() {
    @Override
    public boolean execute(int key, V value) {
      myMap.put(key, value);
      return true;
    }
  });
}