public TIntObjectHashMap<TIntHashSet> resolve(
DirectedGraph<Integer, RDFEdge> graph,
Set<Set<Integer>> literalSubjectPairs,
Document document,
KnowledgeBase kb) {
TIntObjectHashMap<TIntHashSet> resolvedSubjects = new TIntObjectHashMap<TIntHashSet>();
TIntHashSet ham = new TIntHashSet();
TIntHashSet spam = new TIntHashSet();
resolvedSubjects.put(0, spam);
resolvedSubjects.put(1, ham);
for (Set<Integer> c : literalSubjectPairs) {
TIntHashSet subjects = getAmbiguousURIRefs(c);
if (subjects.size() > 1) {
ham.add(subjects.toArray()[new Random().nextInt(subjects.size())]);
if (resolvedSubjects.size() < subjects.size()) {
for (int s : subjects.toArray()) {
if (!ham.contains(s)) {
spam.add(s);
}
}
}
}
}
return resolvedSubjects;
}
public void testSet() {
// Long-long
TLongHashSet llist = new TLongHashSet();
assertTrue(serializesCorrectly(llist, "set-l-1"));
llist.add(0);
llist.add(1);
assertTrue(serializesCorrectly(llist, "set-l-2"));
llist.add(Long.MIN_VALUE);
assertTrue(serializesCorrectly(llist, "set-l-3"));
llist.add(Long.MAX_VALUE);
assertTrue(serializesCorrectly(llist, "set-l-4"));
// Int-int
TIntHashSet ilist = new TIntHashSet();
assertTrue(serializesCorrectly(ilist, "set-i-1"));
ilist.add(0);
ilist.add(1);
assertTrue(serializesCorrectly(ilist, "set-i-2"));
ilist.add(Integer.MIN_VALUE);
assertTrue(serializesCorrectly(ilist, "set-i-3"));
ilist.add(Integer.MAX_VALUE);
assertTrue(serializesCorrectly(ilist, "set-i-4"));
// Double-double
TDoubleHashSet dlist = new TDoubleHashSet();
assertTrue(serializesCorrectly(dlist, "set-d-1"));
dlist.add(0);
dlist.add(1);
assertTrue(serializesCorrectly(dlist, "set-d-2"));
dlist.add(Double.MIN_VALUE);
assertTrue(serializesCorrectly(dlist, "set-d-3"));
dlist.add(Double.MAX_VALUE);
assertTrue(serializesCorrectly(dlist, "set-d-4"));
dlist.add(Double.POSITIVE_INFINITY);
assertTrue(serializesCorrectly(dlist, "set-d-5"));
dlist.add(Double.NEGATIVE_INFINITY);
assertTrue(serializesCorrectly(dlist, "set-d-6"));
// NOTE: trove doesn't deal well with NaN
// ddmap.add( Double.NaN, Double.NaN );
// assertTrue( serializesCorrectly( ddmap ) );
// Float-float
TFloatHashSet flist = new TFloatHashSet();
assertTrue(serializesCorrectly(flist, "set-f-1"));
flist.add(0);
flist.add(1);
assertTrue(serializesCorrectly(flist, "set-f-2"));
flist.add(Float.MIN_VALUE);
assertTrue(serializesCorrectly(flist, "set-f-3"));
flist.add(Float.MAX_VALUE);
assertTrue(serializesCorrectly(flist, "set-f-4"));
flist.add(Float.POSITIVE_INFINITY);
assertTrue(serializesCorrectly(flist, "set-f-5"));
flist.add(Float.NEGATIVE_INFINITY);
assertTrue(serializesCorrectly(flist, "set-f-6"));
// NOTE: trove doesn't deal well with NaN
// ffmap.add( Float.NaN );
// assertTrue( serializesCorrectly( ffmap ) );
}
private void applyChildrenChangeEvents(VirtualFile parent, List<VFileEvent> events) {
final NewVirtualFileSystem delegate = getDelegate(parent);
TIntArrayList childrenIdsUpdated = new TIntArrayList();
List<VirtualFile> childrenToBeUpdated = new SmartList<VirtualFile>();
assert parent != null && parent != mySuperRoot;
final int parentId = getFileId(parent);
assert parentId != 0;
TIntHashSet parentChildrenIds = new TIntHashSet(FSRecords.list(parentId));
boolean hasRemovedChildren = false;
for (VFileEvent event : events) {
if (event instanceof VFileCreateEvent) {
String name = ((VFileCreateEvent) event).getChildName();
final VirtualFile fake = new FakeVirtualFile(parent, name);
final FileAttributes attributes = delegate.getAttributes(fake);
if (attributes != null) {
final int childId = createAndFillRecord(delegate, fake, parentId, attributes);
assert parent instanceof VirtualDirectoryImpl : parent;
final VirtualDirectoryImpl dir = (VirtualDirectoryImpl) parent;
VirtualFileSystemEntry child = dir.createChild(name, childId, dir.getFileSystem());
childrenToBeUpdated.add(child);
childrenIdsUpdated.add(childId);
parentChildrenIds.add(childId);
}
} else if (event instanceof VFileDeleteEvent) {
VirtualFile file = ((VFileDeleteEvent) event).getFile();
if (!file.exists()) {
LOG.error("Deleting a file, which does not exist: " + file.getPath());
continue;
}
hasRemovedChildren = true;
int id = getFileId(file);
childrenToBeUpdated.add(file);
childrenIdsUpdated.add(-id);
parentChildrenIds.remove(id);
}
}
FSRecords.updateList(parentId, parentChildrenIds.toArray());
if (hasRemovedChildren) clearIdCache();
VirtualDirectoryImpl parentImpl = (VirtualDirectoryImpl) parent;
for (int i = 0, len = childrenIdsUpdated.size(); i < len; ++i) {
final int childId = childrenIdsUpdated.get(i);
final VirtualFile childFile = childrenToBeUpdated.get(i);
if (childId > 0) {
parentImpl.addChild((VirtualFileSystemEntry) childFile);
} else {
FSRecords.deleteRecordRecursively(-childId);
parentImpl.removeChild(childFile);
invalidateSubtree(childFile);
}
}
}
private static TIntHashSet collectSoftWrapStartOffsets(int documentLine) {
TIntHashSet result = new TIntHashSet();
for (SoftWrap softWrap : myEditor.getSoftWrapModel().getSoftWrapsForLine(documentLine)) {
result.add(softWrap.getStart());
}
return result;
}
@NotNull
private Pair<TIntHashSet, Integer> findRowsToSelectAndScroll(
@NotNull GraphTableModel model, @NotNull VisibleGraph<Integer> visibleGraph) {
TIntHashSet rowsToSelect = new TIntHashSet();
if (model.getRowCount() == 0) {
// this should have been covered by facade.getVisibleCommitCount,
// but if the table is empty (no commits match the filter), the GraphFacade is not updated,
// because it can't handle it
// => it has previous values set.
return Pair.create(rowsToSelect, null);
}
Integer rowToScroll = null;
for (int row = 0;
row < visibleGraph.getVisibleCommitCount()
&& (rowsToSelect.size() < mySelectedCommits.size() || rowToScroll == null);
row++) { // stop iterating if found all hashes
int commit = visibleGraph.getRowInfo(row).getCommit();
if (mySelectedCommits.contains(commit)) {
rowsToSelect.add(row);
}
if (myVisibleSelectedCommit != null && myVisibleSelectedCommit == commit) {
rowToScroll = row;
}
}
return Pair.create(rowsToSelect, rowToScroll);
}
public Selection(@NotNull VcsLogGraphTable table) {
myTable = table;
List<Integer> selectedRows = ContainerUtil.sorted(toList(myTable.getSelectedRows()));
Couple<Integer> visibleRows = ScrollingUtil.getVisibleRows(myTable);
myScrollToTop = visibleRows.first - 1 == 0;
VisibleGraph<Integer> graph = myTable.getVisibleGraph();
mySelectedCommits = new TIntHashSet();
Integer visibleSelectedCommit = null;
Integer delta = null;
for (int row : selectedRows) {
if (row < graph.getVisibleCommitCount()) {
Integer commit = graph.getRowInfo(row).getCommit();
mySelectedCommits.add(commit);
if (visibleRows.first - 1 <= row
&& row <= visibleRows.second
&& visibleSelectedCommit == null) {
visibleSelectedCommit = commit;
delta = myTable.getCellRect(row, 0, false).y - myTable.getVisibleRect().y;
}
}
}
if (visibleSelectedCommit == null && visibleRows.first - 1 >= 0) {
visibleSelectedCommit = graph.getRowInfo(visibleRows.first - 1).getCommit();
delta = myTable.getCellRect(visibleRows.first - 1, 0, false).y - myTable.getVisibleRect().y;
}
myVisibleSelectedCommit = visibleSelectedCommit;
myDelta = delta;
}
@NotNull
private static FontInfo doGetFontAbleToDisplay(
int codePoint, int size, @JdkConstants.FontStyle int style) {
synchronized (lock) {
if (ourUndisplayableChars.contains(codePoint)) return ourSharedDefaultFont;
final Collection<FontInfo> descriptors = ourUsedFonts.values();
for (FontInfo font : descriptors) {
if (font.getSize() == size && font.getStyle() == style && font.canDisplay(codePoint)) {
return font;
}
}
for (int i = 0; i < ourFontNames.size(); i++) {
String name = ourFontNames.get(i);
FontInfo font = new FontInfo(name, size, style);
if (font.canDisplay(codePoint)) {
ourUsedFonts.put(new FontKey(name, size, style), font);
ourFontNames.remove(i);
return font;
}
}
ourUndisplayableChars.add(codePoint);
return ourSharedDefaultFont;
}
}
/** Insert a term into this document, occurs at given block id */
public void insert(String t, int blockId) {
insert(t);
TIntHashSet blockids = null;
if ((blockids = term_blocks.get(t)) == null) {
term_blocks.put(t, blockids = new TIntHashSet(/*TODO */ ));
}
blockids.add(blockId);
blockCount++;
}
@NotNull
@Override
public PsiFunctionalExpression[] findFunExpressionsInFile(
@NotNull Integer[] funExpressions, @NotNull PsiFileWithStubSupport file) {
TIntHashSet requiredIndices = new TIntHashSet(funExpressions.length);
for (int funExpr : funExpressions) {
requiredIndices.add(funExpr);
}
return JavaCompilerElementRetriever.retrieveFunExpressionsByIndices(requiredIndices, file);
}
private void loadCommitsData(
@NotNull final TIntIntHashMap commits,
@NotNull final Consumer<List<T>> consumer,
@Nullable ProgressIndicator indicator) {
final List<T> result = ContainerUtil.newArrayList();
final TIntHashSet toLoad = new TIntHashSet();
long taskNumber = myCurrentTaskIndex++;
for (int id : commits.keys()) {
T details = getFromCache(id);
if (details == null || details instanceof LoadingDetails) {
toLoad.add(id);
cacheCommit(id, taskNumber);
} else {
result.add(details);
}
}
if (toLoad.isEmpty()) {
sortCommitsByRow(result, commits);
consumer.consume(result);
} else {
Task.Backgroundable task =
new Task.Backgroundable(
null, "Loading Selected Details", true, PerformInBackgroundOption.ALWAYS_BACKGROUND) {
@Override
public void run(@NotNull final ProgressIndicator indicator) {
indicator.checkCanceled();
try {
TIntObjectHashMap<T> map = preLoadCommitData(toLoad);
map.forEachValue(
value -> {
result.add(value);
return true;
});
sortCommitsByRow(result, commits);
notifyLoaded();
} catch (VcsException e) {
LOG.error(e);
}
}
@Override
public void onSuccess() {
consumer.consume(result);
}
};
if (indicator != null) {
ProgressManager.getInstance().runProcessWithProgressAsynchronously(task, indicator);
} else {
ProgressManager.getInstance().run(task);
}
}
}
private void runLoadCommitsData(@NotNull Iterable<Integer> hashes) {
long taskNumber = myCurrentTaskIndex++;
TIntIntHashMap commits = getCommitsMap(hashes);
TIntHashSet toLoad = new TIntHashSet();
for (int id : commits.keys()) {
cacheCommit(id, taskNumber);
toLoad.add(id);
}
myLoader.queue(new TaskDescriptor(toLoad));
}
public void visitEnum(String name, String desc, String value) {
final int methodName = myContext.get(name);
final String methodDescr = "()" + desc;
myUsages.add(
UsageRepr.createMethodUsage(myContext, methodName, myType.myClassName, methodDescr));
myUsages.add(
UsageRepr.createMetaMethodUsage(
myContext, methodName, myType.myClassName, methodDescr));
myUsedArguments.add(methodName);
}
public void processTerm(String t) {
// null means the term has been filtered out (eg stopwords)
if (t != null) {
// add term to document posting list
for (String fieldName : termFields) {
int tmp = fieldNames.get(fieldName);
if (tmp > 0) {
fields.add(tmp - 1);
}
}
if (ELSE_ENABLED && fields.size() == 0) {
fields.add(ELSE_FIELD_ID);
}
((BlockFieldDocumentPostingList) termsInDocument).insert(t, fields.toArray(), blockId);
numOfTokensInDocument++;
if (++numOfTokensInBlock >= BLOCK_SIZE && blockId < MAX_BLOCKS) {
numOfTokensInBlock = 0;
blockId++;
}
fields.clear();
}
}
public boolean canDisplay(char c) {
try {
if (c < 128) return true;
if (mySafeCharacters.contains(c)) return true;
if (canDisplayImpl(c)) {
mySafeCharacters.add(c);
return true;
}
return false;
} catch (Exception e) {
// JRE has problems working with the font. Just skip.
return false;
}
}
@Override
public void removeAssociatedValue(int inputId) {
ValueContainerImpl<Value> merged = myMerged;
if (merged != null) {
merged.removeAssociatedValue(inputId);
}
ValueContainerImpl<Value> added = myAdded;
if (added != null) added.removeAssociatedValue(inputId);
TIntHashSet invalidated = myInvalidated;
if (invalidated == null) {
invalidated = new TIntHashSet(1);
}
invalidated.add(inputId);
myInvalidated = invalidated; // volatile write
}
private static void addIdAndSuperClasses(PsiFile file, @NotNull TIntHashSet forward) {
if (file instanceof PsiJavaFile
&& file.getName().equals("Object.class")
&& ((PsiJavaFile) file).getPackageName().equals("java.lang")) {
return;
}
VirtualFile virtualFile = PsiUtilCore.getVirtualFile(file);
if (virtualFile instanceof VirtualFileWithId
&& forward.add(getAbsId(virtualFile))
&& file instanceof PsiClassOwner) {
for (PsiClass aClass : ((PsiClassOwner) file).getClasses()) {
for (PsiClass superClass : aClass.getSupers()) {
addIdAndSuperClasses(superClass.getContainingFile(), forward);
}
}
}
}
private void updateBreakpoints(@NotNull Document document) {
Collection<XLineBreakpointImpl> breakpoints = myBreakpoints.getKeysByValue(document);
if (breakpoints == null) {
return;
}
TIntHashSet lines = new TIntHashSet();
List<XBreakpoint<?>> toRemove = new SmartList<XBreakpoint<?>>();
for (XLineBreakpointImpl breakpoint : breakpoints) {
breakpoint.updatePosition();
if (!breakpoint.isValid() || !lines.add(breakpoint.getLine())) {
toRemove.add(breakpoint);
}
}
removeBreakpoints(toRemove);
}
@NotNull
private static List<VFileEvent> validateEvents(@NotNull List<VFileEvent> events) {
final List<EventWrapper> deletionEvents = ContainerUtil.newArrayList();
for (int i = 0, size = events.size(); i < size; i++) {
final VFileEvent event = events.get(i);
if (event instanceof VFileDeleteEvent && event.isValid()) {
deletionEvents.add(new EventWrapper((VFileDeleteEvent) event, i));
}
}
final TIntHashSet invalidIDs;
if (deletionEvents.isEmpty()) {
invalidIDs = EmptyIntHashSet.INSTANCE;
} else {
ContainerUtil.quickSort(deletionEvents, DEPTH_COMPARATOR);
invalidIDs = new TIntHashSet(deletionEvents.size());
final Set<VirtualFile> dirsToBeDeleted = new THashSet<VirtualFile>(deletionEvents.size());
nextEvent:
for (EventWrapper wrapper : deletionEvents) {
final VirtualFile candidate = wrapper.event.getFile();
VirtualFile parent = candidate;
while (parent != null) {
if (dirsToBeDeleted.contains(parent)) {
invalidIDs.add(wrapper.id);
continue nextEvent;
}
parent = parent.getParent();
}
if (candidate.isDirectory()) {
dirsToBeDeleted.add(candidate);
}
}
}
final List<VFileEvent> filtered = new ArrayList<VFileEvent>(events.size() - invalidIDs.size());
for (int i = 0, size = events.size(); i < size; i++) {
final VFileEvent event = events.get(i);
if (event.isValid() && !(event instanceof VFileDeleteEvent && invalidIDs.contains(i))) {
filtered.add(event);
}
}
return filtered;
}
@Override
public TIntDoubleHashMap getRating(
Document document, List<TokenSequence<SemanticEntity>> entities) {
DirectedGraph<Integer, RDFEdge> graph = document.getGraph();
TIntHashSet nodes = new TIntHashSet();
for (TokenSequence<SemanticEntity> ts : entities) {
nodes.add(ts.getValue().getSubjectIndex());
}
final TIntDoubleHashMap m = new TIntDoubleHashMap();
for (int node : nodes.toArray()) {
m.put(node, Math.min(graph.getOutEdges(node).size(), graph.getInEdges(node).size()));
}
return m;
}
public void visit(String name, Object value) {
final String methodDescr = getMethodDescr(value);
final int methodName = myContext.get(name);
if (value instanceof Type) {
final String className = ((Type) value).getClassName().replace('.', '/');
if (className != null) {
myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(className)));
}
}
myUsages.add(
UsageRepr.createMethodUsage(myContext, methodName, myType.myClassName, methodDescr));
myUsages.add(
UsageRepr.createMetaMethodUsage(
myContext, methodName, myType.myClassName, methodDescr));
myUsedArguments.add(methodName);
}
private void update(@NotNull List<BreakpointWithHighlighter> breakpoints) {
final TIntHashSet intHash = new TIntHashSet();
for (BreakpointWithHighlighter breakpoint : breakpoints) {
SourcePosition sourcePosition = breakpoint.getSourcePosition();
breakpoint.reload();
if (breakpoint.isValid()) {
if (sourcePosition == null
|| breakpoint.getSourcePosition().getLine() != sourcePosition.getLine()) {
fireBreakpointChanged(breakpoint);
}
if (intHash.contains(breakpoint.getLineIndex())) {
remove(breakpoint);
} else {
intHash.add(breakpoint.getLineIndex());
}
} else {
remove(breakpoint);
}
}
}
private void parseProblemGlyphs() {
myCheckedForProblemGlyphs = true;
BufferedImage buffer = UIUtil.createImage(20, 20, BufferedImage.TYPE_INT_RGB);
final Graphics graphics = buffer.getGraphics();
if (!(graphics instanceof Graphics2D)) {
return;
}
final FontRenderContext context = ((Graphics2D) graphics).getFontRenderContext();
char[] charBuffer = new char[1];
for (char c = 0; c < 128; c++) {
if (!myFont.canDisplay(c)) {
continue;
}
charBuffer[0] = c;
final GlyphVector vector = myFont.createGlyphVector(context, charBuffer);
final float y = vector.getGlyphMetrics(0).getAdvanceY();
if (Math.round(y) != 0) {
mySymbolsToBreakDrawingIteration.add(c);
}
}
myHasGlyphsToBreakDrawingIteration = !mySymbolsToBreakDrawingIteration.isEmpty();
}
private static void findReadsBeforeWrites(
Instruction[] flow,
TIntHashSet[] definitelyAssigned,
List<ReadWriteVariableInstruction> result,
TObjectIntHashMap<String> namesIndex,
int[] postorder,
int[] invpostorder,
boolean onlyFirstRead) {
// skip instructions that are not reachable from the start
int start = ArrayUtil.find(invpostorder, 0);
for (int i = start; i < flow.length; i++) {
int j = invpostorder[i];
Instruction curr = flow[j];
if (curr instanceof ReadWriteVariableInstruction) {
ReadWriteVariableInstruction rw = (ReadWriteVariableInstruction) curr;
int name = namesIndex.get(rw.getVariableName());
TIntHashSet vars = definitelyAssigned[j];
if (rw.isWrite()) {
if (vars == null) {
vars = new TIntHashSet();
definitelyAssigned[j] = vars;
}
vars.add(name);
} else {
if (vars == null || !vars.contains(name)) {
result.add(rw);
if (onlyFirstRead) {
if (vars == null) {
vars = new TIntHashSet();
definitelyAssigned[j] = vars;
}
vars.add(name);
}
}
}
}
for (Instruction succ : curr.allSuccessors()) {
if (postorder[succ.num()] > postorder[curr.num()]) {
TIntHashSet currDefinitelyAssigned = definitelyAssigned[curr.num()];
TIntHashSet succDefinitelyAssigned = definitelyAssigned[succ.num()];
if (currDefinitelyAssigned != null) {
int[] currArray = currDefinitelyAssigned.toArray();
if (succDefinitelyAssigned == null) {
succDefinitelyAssigned = new TIntHashSet();
succDefinitelyAssigned.addAll(currArray);
definitelyAssigned[succ.num()] = succDefinitelyAssigned;
} else {
succDefinitelyAssigned.retainAll(currArray);
}
} else {
if (succDefinitelyAssigned != null) {
succDefinitelyAssigned.clear();
} else {
succDefinitelyAssigned = new TIntHashSet();
definitelyAssigned[succ.num()] = succDefinitelyAssigned;
}
}
}
}
}
}
public AnnotationVisitor visitArray(String name) {
myUsedArguments.add(myContext.get(name));
return this;
}
@Override
public void markGenerated(Collection<VirtualFile> files) {
for (final VirtualFile file : files) {
myGeneratedSources.add(FileBasedIndex.getFileId(file));
}
}
