Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
 Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
266,600
void (@NotNull VirtualFileCopyEvent event) { if (isFromMySystem(event)) { myDelegate.fileCopied(event); } }
fileCopied
266,601
void (@NotNull VirtualFileEvent event) { if (isFromMySystem(event)) { myDelegate.fileCreated(event); } }
fileCreated
266,602
void (@NotNull VirtualFileEvent event) { if (isFromMySystem(event)) { myDelegate.fileDeleted(event); } }
fileDeleted
266,603
void (@NotNull VirtualFileMoveEvent event) { if (isFromMySystem(event)) { myDelegate.fileMoved(event); } }
fileMoved
266,604
void (@NotNull VirtualFilePropertyEvent event) { if (isFromMySystem(event)) { myDelegate.propertyChanged(event); } }
propertyChanged
266,605
DataOutputStream (@NotNull VirtualFile file) { return ManagingFS.getInstance().writeAttribute(file, this); }
writeAttribute
266,606
AttributeOutputStream (@NotNull VirtualFile file) { return ManagingFS.getInstance().writeAttribute(file, this); }
writeFileAttribute
266,607
String () { return myId; }
getId
266,608
boolean () { return myFixedSize; }
isFixedSize
266,609
FileAttribute (int newVersion) { return new FileAttribute(newVersion, myFixedSize, myId, myShouldEnumerate); }
newVersion
266,610
int () { return myVersion; }
getVersion
266,611
boolean () { return myVersion != UNDEFINED_VERSION; }
isVersioned
266,612
void () { ourRegisteredIds.clear(); }
resetRegisteredIds
266,613
FileAttribute (@NonNls @NotNull String id, int version, boolean fixedSize) { // shouldEnumerate is not used yet return new FileAttribute(version, fixedSize, id, false); // do not register the instance }
instantiateForRecovery
266,614
String () { return "FileAttribute[" + myId + "]" + "{version: " + myVersion + ", fixedSize: " + myFixedSize + ", shouldEnumerate: " + myShouldEnumerate + '}'; }
toString
266,615
RefreshQueue () { return ApplicationManager.getApplication().getService(RefreshQueue.class); }
getInstance
266,616
RefreshSession (boolean async, boolean recursive, @Nullable Runnable finishRunnable) { return createSession(async, recursive, finishRunnable, ModalityState.defaultModalityState()); }
createSession
266,617
void (boolean async, boolean recursive, @Nullable Runnable finishRunnable, @NotNull VirtualFile @NotNull ... files) { refresh(async, recursive, finishRunnable, ModalityState.defaultModalityState(), files); }
refresh
266,618
void (boolean async, boolean recursive, @Nullable Runnable finishRunnable, @NotNull Collection<? extends @NotNull VirtualFile> files) { refresh(async, recursive, finishRunnable, ModalityState.defaultModalityState(), files); }
refresh
266,619
void (boolean async, boolean recursive, @Nullable Runnable finishRunnable, @NotNull ModalityState state, @NotNull VirtualFile @NotNull ... files) { RefreshSession session = createSession(async, recursive, finishRunnable, state); session.addAllFiles(files); session.launch(); }
refresh
266,620
void (boolean async, boolean recursive, @Nullable Runnable finishRunnable, @NotNull ModalityState state, @NotNull Collection<? extends @NotNull VirtualFile> files) { RefreshSession session = createSession(async, recursive, finishRunnable, state); session.addAllFiles(files); session.launch(); }
refresh
266,621
LazyRangeMarkerFactory (Project project) { return project.getService(LazyRangeMarkerFactory.class); }
getInstance
266,622
boolean (@NotNull InsertionContext context) { return !context.shouldAddCompletionChar() || context.getCompletionChar() != myChar; }
isApplicable
266,623
int (final Editor editor, final int tailOffset) { return insertChar(editor, tailOffset, myChar, myOverwrite); }
processTail
266,624
boolean (final Object o) { if (this == o) return true; if (!(o instanceof CharTailType that)) return false; if (myChar != that.myChar) return false; return true; }
equals
266,625
int () { return myChar; }
hashCode
266,626
boolean (final @NotNull InsertionContext context) { return true; }
isApplicable
266,627
int (final Editor editor, final int tailOffset, final char c) { return insertChar(editor, tailOffset, c, true); }
insertChar
266,628
int (Editor editor, int tailOffset, char c, boolean overwrite) { Document document = editor.getDocument(); int textLength = document.getTextLength(); CharSequence chars = document.getCharsSequence(); if (tailOffset == textLength || !overwrite || chars.charAt(tailOffset) != c) { document.insertString(tailOffset, String....
insertChar
266,629
TailType (final char c) { return new CharTailType(c); }
createSimpleTailType
266,630
int (final Editor editor, final int tailOffset, final int delta) { final CaretModel model = editor.getCaretModel(); if (model.getOffset() == tailOffset) { model.moveToOffset(tailOffset + delta); } return tailOffset + delta; }
moveCaret
266,631
FileType (Editor editor) { PsiFile psiFile = getFile(editor); return psiFile.getFileType(); }
getFileType
266,632
PsiFile (Editor editor) { Project project = editor.getProject(); assert project != null; PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument()); assert psiFile != null; return psiFile; }
getFile
266,633
int (final Editor editor, final int tailOffset) { return tailOffset; }
processTail
266,634
String () { return "UNKNOWN"; }
toString
266,635
int (final Editor editor, final int tailOffset) { return tailOffset; }
processTail
266,636
String () { return "NONE"; }
toString
266,637
boolean (@NotNull InsertionContext context) { CharSequence text = context.getDocument().getCharsSequence(); int tail = context.getTailOffset(); if (text.length() > tail + 1 && text.charAt(tail) == ' ') { char ch = text.charAt(tail + 1); if (ch == '@' || Character.isLetter(ch)) { return false; } } return super.isApplica...
isApplicable
266,638
String () { return "HUMBLE_SPACE_BEFORE_WORD"; }
toString
266,639
int (final Editor editor, final int tailOffset) { Document document = editor.getDocument(); int textLength = document.getTextLength(); CharSequence chars = document.getCharsSequence(); int afterWhitespace = CharArrayUtil.shiftForward(chars, tailOffset, " \n\t"); if (afterWhitespace < textLength && chars.charAt(afterWhi...
processTail
266,640
String () { return "COND_EXPR_COLON"; }
toString
266,641
int (final Editor editor, final int tailOffset) { return tailOffset; }
processTail
266,642
String () { return "UNKNOWN"; }
toString
266,643
int (final Editor editor, final int tailOffset) { return tailOffset; }
processTail
266,644
String () { return "NONE"; }
toString
266,645
boolean (@NotNull InsertionContext context) { CharSequence text = context.getDocument().getCharsSequence(); int tail = context.getTailOffset(); if (text.length() > tail + 1 && text.charAt(tail) == ' ') { char ch = text.charAt(tail + 1); if (ch == '@' || Character.isLetter(ch)) { return false; } } return super.isApplica...
isApplicable
266,646
String () { return "HUMBLE_SPACE_BEFORE_WORD"; }
toString
266,647
int (final Editor editor, final int tailOffset) { Document document = editor.getDocument(); int textLength = document.getTextLength(); CharSequence chars = document.getCharsSequence(); int afterWhitespace = CharArrayUtil.shiftForward(chars, tailOffset, " \n\t"); if (afterWhitespace < textLength && chars.charAt(afterWhi...
processTail
266,648
String () { return "COND_EXPR_COLON"; }
toString
266,649
TailType () { return UNKNOWN; }
unknownType
266,650
TailType () { return NONE; }
noneType
266,651
TailType () { return SEMICOLON; }
semicolonType
266,652
TailType () { return SPACE; }
spaceType
266,653
TailType () { return INSERT_SPACE; }
insertSpaceType
266,654
TailType () { return HUMBLE_SPACE_BEFORE_WORD; }
humbleSpaceBeforeWordType
266,655
TailType () { return DOT; }
dotType
266,656
TailType () { return CASE_COLON; }
caseColonType
266,657
TailType () { return EQUALS; }
equalsType
266,658
TailType () { return COND_EXPR_COLON; }
conditionalExpressionColonType
266,659
Position (final @NotNull PsiElement element, final int startOffset, final int endOffset) { final int offset = element.getTextOffset(); if (offset < startOffset) { return Position.BEFORE; } if (element.getTextOffset() < endOffset) { return Position.INSIDE; } return Position.AFTER; }
getPosition
266,660
boolean (final PsiElement element, final int start, final int end) { return element != null && start <= element.getTextOffset() && element.getTextOffset() + element.getTextLength() <= end; }
elementFit
266,661
boolean () { return returnInstructionInside; }
isReturnInstructionInside
266,662
AutoCompletionDecision (@NotNull LookupElement element) { return new InsertItem(element); }
insertItem
266,663
LookupElement () { return myElement; }
getElement
266,664
List<CompletionConfidence> (@NotNull Language language) { return INSTANCE.allForLanguage(language); }
forLanguage
266,665
int (OffsetKey key) { synchronized (myMap) { final RangeMarker marker = myMap.get(key); if (marker == null) throw new IllegalArgumentException("Offset " + key + " is not registered"); if (!marker.isValid()) { removeOffset(key); throw new IllegalStateException("Offset " + key + " is invalid: " + marker + ", document.val...
getOffset
266,666
boolean (OffsetKey key) { final RangeMarker marker = myMap.get(key); return marker != null && marker.isValid(); }
containsOffset
266,667
void (OffsetKey key, int offset) { synchronized (myMap) { if (offset < 0) { removeOffset(key); return; } saveOffset(key, offset, true); } }
addOffset
266,668
void (OffsetKey key, int offset, boolean externally) { LOG.assertTrue(!myDisposed); if (externally && myMap.containsKey(key)) { myModified.add(key); } RangeMarker old = myMap.get(key); if (old != null) old.dispose(); final RangeMarker marker = myDocument.createRangeMarker(offset, offset); marker.setGreedyToRight(key.is...
saveOffset
266,669
void (OffsetKey key) { synchronized (myMap) { ProgressManager.checkCanceled(); LOG.assertTrue(!myDisposed); myModified.add(key); RangeMarker old = myMap.get(key); if (old != null) old.dispose(); myMap.remove(key); } }
removeOffset
266,670
List<OffsetKey> () { synchronized (myMap) { ProgressManager.checkCanceled(); LOG.assertTrue(!myDisposed); return ContainerUtil.filter(myMap.keySet(), this::containsOffset); } }
getAllOffsets
266,671
String () { synchronized (myMap) { final StringBuilder builder = new StringBuilder("OffsetMap:"); for (final OffsetKey key : myMap.keySet()) { builder.append(key).append("->").append(myMap.get(key)).append(";"); } return builder.toString(); } }
toString
266,672
boolean (OffsetKey key) { synchronized (myMap) { return myModified.contains(key); } }
wasModified
266,673
void () { synchronized (myMap) { myDisposed = true; for (RangeMarker rangeMarker : myMap.values()) { rangeMarker.dispose(); } } }
dispose
266,674
Document () { return myDocument; }
getDocument
266,675
OffsetMap (@NotNull Document anotherDocument) { if (anotherDocument.getTextLength() != myDocument.getTextLength()) { LOG.error("Different document lengths: " + myDocument.getTextLength() + " for " + myDocument + " and " + anotherDocument.getTextLength() + " for " + anotherDocument); } return mapOffsets(anotherDocument,...
copyOffsets
266,676
OffsetMap (@NotNull Document anotherDocument, @NotNull Function<? super Integer, Integer> mapping) { OffsetMap result = new OffsetMap(anotherDocument); for (OffsetKey key : getAllOffsets()) { result.addOffset(key, mapping.apply(getOffset(key))); } return result; }
mapOffsets
266,677
String () { return myName; }
toString
266,678
boolean () { return myMovableToRight; }
isMovableToRight
266,679
OffsetKey (@NonNls String name) { return create(name, true); }
create
266,680
OffsetKey (@NonNls String name, final boolean movableToRight) { return new OffsetKey(name, movableToRight); }
create
266,681
PersistentList<T> (@NotNull String stringKey, @NotNull Language key) { return buildExtensions(getAllBaseLanguageIdsWithAny(key)); }
buildExtensions
266,682
void (String key) { super.invalidateCacheForExtension(key); // clear the entire cache because, if languages are unloaded, we won't be able to find cache keys for unloaded dialects of // a given language clearCache(); if ("any".equals(key)) { for (Language language : Language.getRegisteredLanguages()) { super.invalidate...
invalidateCacheForExtension
266,683
Set<String> (@NotNull Language key) { Set<String> allowed = new HashSet<>(); while (key != null) { allowed.add(keyToString(key)); for (MetaLanguage metaLanguage : MetaLanguage.all()) { if (metaLanguage.matchesLanguage(key)) { allowed.add(metaLanguage.getID()); } } key = key.getBaseLanguage(); } allowed.add("any"); retu...
getAllBaseLanguageIdsWithAny
266,684
PrefixMatcher () { return myMatcher; }
getPrefixMatcher
266,685
CompletionSorter () { return mySorter; }
getSorter
266,686
LookupElement () { return myLookupElement; }
getLookupElement
266,687
CompletionResult (@NotNull LookupElement element) { if (!myMatcher.prefixMatches(element)) { throw new AssertionError("The new element doesn't match the prefix"); } return new CompletionResult(element, myMatcher, mySorter); }
withLookupElement
266,688
boolean () { return myMatcher.isStartMatch(myLookupElement); }
isStartMatch
266,689
String () { return myLookupElement.toString(); }
toString
266,690
boolean (@NotNull LookupElement element) { for (String s : element.getAllLookupStrings()) { if (prefixMatches(s)) { return true; } } return false; }
prefixMatches
266,691
boolean (LookupElement element) { for (String s : element.getAllLookupStrings()) { if (isStartMatch(s)) { return true; } } return false; }
isStartMatch
266,692
boolean (String name) { return prefixMatches(name); }
isStartMatch
266,693
String () { return myPrefix; }
getPrefix
266,694
int (String string) { return 0; }
matchingDegree
266,695
LinkedHashSet<String> (Collection<String> _names) { ProgressManager.checkCanceled(); if (getPrefix().isEmpty()) { return new LinkedHashSet<>(_names); } List<String> sorted = new ArrayList<>(); for (String name : _names) { if (prefixMatches(name)) { sorted.add(name); } } ProgressManager.checkCanceled(); sorted.sort(Stri...
sortMatching
266,696
CompletionSorter () { return CompletionService.getCompletionService().emptySorter(); }
emptySorter
266,697
CompletionSorter (CompletionParameters parameters, PrefixMatcher matcher) { return CompletionService.getCompletionService().defaultSorter(parameters, matcher); }
defaultSorter
266,698
void (final @NotNull V parameters, @NotNull ProcessingContext context, final @NotNull CompletionResultSet result) { addCompletions(parameters, context, result); }
addCompletionVariants
266,699
CompletionService () { return ApplicationManager.getApplication().getService(CompletionService.class); }
getCompletionService