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
289,500
T (@NotNull U underlyingValue) { return myRestoration.apply(underlyingValue, this); }
dereference
289,501
T (@NotNull U underlyingValue) { return myRestoration.apply(underlyingValue); }
dereference
289,502
T (@NotNull U underlyingValue) { return myRestoration.apply(underlyingValue, this); }
dereference
289,503
ModelPatch (@NotNull Project project, @NotNull Consumer<? super ModelBranch> action) { throw new UnsupportedOperationException(); }
performInBranch
289,504
T () { return myValue; }
dereference
289,505
boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; HardPointerEq<?> pointer = (HardPointerEq<?>)o; return Objects.equals(myValue, pointer.myValue); }
equals
289,506
int () { return myValue.hashCode(); }
hashCode
289,507
SearchRequest (@NotNull String searchString) { return () -> searchString; }
of
289,508
SearchRequest (@NotNull String searchString, @NotNull SearchScope searchScope) { return of(searchString, searchScope, searchScope); }
of
289,509
SearchRequest (@NotNull String searchString, @NotNull SearchScope searchScope, @NotNull SearchScope injectionSearchScope) { return new SearchRequest() { @Override public @NotNull String getSearchString() { return searchString; } @Override public @NotNull SearchScope getSearchScope() { return searchScope; } @Override public @NotNull SearchScope getInjectionSearchScope() { return injectionSearchScope; } }; }
of
289,510
String () { return searchString; }
getSearchString
289,511
SearchScope () { return searchScope; }
getSearchScope
289,512
SearchScope () { return injectionSearchScope; }
getInjectionSearchScope
289,513
Language () { Language language = Language.findLanguageByID(hostLanguage); if (language == null) { throw new PluginException("Cannot find language '" + hostLanguage + "'", getPluginDescriptor().getPluginId()); } return language; }
getHostLanguage
289,514
PsiSymbolReferenceHints (@NotNull Class<? extends PsiSymbolReference> referenceClass) { assert referenceClass != PsiSymbolReference.class; return new PsiSymbolReferenceHints() { @Override public @NotNull Class<? extends PsiSymbolReference> getReferenceClass() { return referenceClass; } }; }
referenceClassHint
289,515
PsiSymbolReferenceHints (int offsetInElement) { assert offsetInElement >= 0; return new PsiSymbolReferenceHints() { @Override public int getOffsetInElement() { return offsetInElement; } }; }
offsetHint
289,516
int () { return offsetInElement; }
getOffsetInElement
289,517
String (@NotNull PsiSymbolReference reference) { return reference.getRangeInElement().substring(reference.getElement().getText()); }
getReferenceText
289,518
PsiSymbolReferenceService () { return ApplicationManager.getApplication().getService(PsiSymbolReferenceService.class); }
getService
289,519
PsiElement () { return myElement; }
getElement
289,520
TextRange () { return TextRange.from(0, myElement.getTextLength()); }
getRangeInElement
289,521
PsiSymbolService () { return ApplicationManager.getApplication().getService(PsiSymbolService.class); }
getInstance
289,522
void (@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) { if (!LOG.isDebugEnabled()) { start(buffer, startOffset, endOffset, initialState); return; } long start = System.currentTimeMillis(); start(buffer, startOffset, endOffset, initialState); long startDuration = System.currentTimeMillis() - start; if (startDuration > LEXER_START_THRESHOLD) { LOG.debug("Starting lexer took: ", startDuration, "; at ", startOffset, " - ", endOffset, "; state: ", initialState, "; text: ", StringUtil.shortenTextWithEllipsis(buffer.toString(), 1024, 500) ); } }
startMeasured
289,523
void (@NotNull CharSequence buf, int start, int end) { startMeasured(buf, start, end, 0); }
start
289,524
void (@NotNull CharSequence buf) { startMeasured(buf, 0, buf.length(), 0); }
start
289,525
CharSequence () { return getBufferSequence().subSequence(getTokenStart(), getTokenEnd()); }
getTokenSequence
289,526
String () { return getTokenSequence().toString(); }
getTokenText
289,527
void (@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) { myBuffer = buffer; myStart = startOffset; myState = myQuoteChar == NO_QUOTE_CHAR ? AFTER_FIRST_QUOTE : initialState; myLastState = initialState; myBufferEnd = endOffset; myEnd = locateToken(myStart); mySeenEscapedSpacesOnly = true; }
start
289,528
int () { return myLastState; }
getState
289,529
IElementType () { if (myStart >= myEnd) return null; if (myBuffer.charAt(myStart) != '\\') { mySeenEscapedSpacesOnly = false; return myOriginalLiteralToken; } if (myStart + 1 >= myEnd) { return handleSingleSlashEscapeSequence(); } char nextChar = myBuffer.charAt(myStart + 1); mySeenEscapedSpacesOnly &= nextChar == ' '; if (myCanEscapeEolOrFramingSpaces && (nextChar == '\n' || nextChar == ' ' && (mySeenEscapedSpacesOnly || isTrailingSpace(myStart+2)))) { return StringEscapesTokenTypes.VALID_STRING_ESCAPE_TOKEN; } if (nextChar == 'u') { return getUnicodeEscapeSequenceType(); } if (nextChar == 'x' && myAllowHex) { return getHexCodedEscapeSeq(); } switch (nextChar) { case '0': if (shouldAllowSlashZero()) return StringEscapesTokenTypes.VALID_STRING_ESCAPE_TOKEN; case '1': case '2': case '3': case '4': case '5': case '6': case '7': if (!myAllowOctal) return StringEscapesTokenTypes.INVALID_CHARACTER_ESCAPE_TOKEN; case 'n': case 'r': case 'b': case 't': case 'f': case '\'': case '\"': case '\\': return StringEscapesTokenTypes.VALID_STRING_ESCAPE_TOKEN; } if (myAdditionalValidEscapes != null && myAdditionalValidEscapes.indexOf(nextChar) != -1) { return StringEscapesTokenTypes.VALID_STRING_ESCAPE_TOKEN; } return StringEscapesTokenTypes.INVALID_CHARACTER_ESCAPE_TOKEN; }
getTokenType
289,530
boolean () { return false; }
shouldAllowSlashZero
289,531
IElementType () { return StringEscapesTokenTypes.INVALID_CHARACTER_ESCAPE_TOKEN; }
handleSingleSlashEscapeSequence
289,532
IElementType () { // \xFF return getStandardLimitedHexCodedEscapeSeq(4); }
getHexCodedEscapeSeq
289,533
IElementType () { // \uFFFF return getStandardLimitedHexCodedEscapeSeq(6); }
getUnicodeEscapeSequenceType
289,534
IElementType (int offsetLimit) { for (int i = myStart + 2; i < myStart + offsetLimit; i++) { if (i >= myEnd || !StringUtil.isHexDigit(myBuffer.charAt(i))) return StringEscapesTokenTypes.INVALID_UNICODE_ESCAPE_TOKEN; } return StringEscapesTokenTypes.VALID_STRING_ESCAPE_TOKEN; }
getStandardLimitedHexCodedEscapeSeq
289,535
boolean (int start) { for (int i = start; i < myBufferEnd; i += 2) { char c = myBuffer.charAt(i); if (c != '\\') return false; if (i == myBufferEnd - 1) return false; if (myBuffer.charAt(i + 1) != ' ') return false; } return true; }
isTrailingSpace
289,536
int () { return myStart; }
getTokenStart
289,537
int () { return myEnd; }
getTokenEnd
289,538
int (int start) { if (start == myBufferEnd) { myState = AFTER_LAST_QUOTE; } if (myState == AFTER_LAST_QUOTE) return start; int i = start; if (myBuffer.charAt(i) == '\\') { LOG.assertTrue(myState == AFTER_FIRST_QUOTE, this); i++; if (i == myBufferEnd || myBuffer.charAt(i) == '\n' && !myCanEscapeEolOrFramingSpaces) { myState = AFTER_LAST_QUOTE; return i; } if (myAllowOctal && myBuffer.charAt(i) >= '0' && myBuffer.charAt(i) <= '7') { char first = myBuffer.charAt(i); i++; if (i < myBufferEnd && myBuffer.charAt(i) >= '0' && myBuffer.charAt(i) <= '7') { i++; if (i < myBufferEnd && first <= '3' && myBuffer.charAt(i) >= '0' && myBuffer.charAt(i) <= '7') { i++; } } return i; } if (myAllowHex && myBuffer.charAt(i) == 'x') { return locateHexEscapeSequence(start, i); } if (myBuffer.charAt(i) == 'u') { return locateUnicodeEscapeSequence(start, i); } int additionalLocation = locateAdditionalEscapeSequence(start, i); if (additionalLocation != -1) { return additionalLocation; } return i + 1; } LOG.assertTrue(myState == AFTER_FIRST_QUOTE || myBuffer.charAt(i) == myQuoteChar, this); while (i < myBufferEnd) { if (myBuffer.charAt(i) == '\\') { return i; } if (myState == AFTER_FIRST_QUOTE && myBuffer.charAt(i) == myQuoteChar) { if (i + 1 == myBufferEnd) myState = AFTER_LAST_QUOTE; return i + 1; } i++; myState = AFTER_FIRST_QUOTE; } return i; }
locateToken
289,539
int (int start, int i) { i++; for (; i < start + 4; i++) { if (i == myBufferEnd || myBuffer.charAt(i) == '\n' || myBuffer.charAt(i) == myQuoteChar) { return i; } } return i; }
locateHexEscapeSequence
289,540
int (int start, int i) { i++; for (; i < start + 6; i++) { if (i == myBufferEnd || myBuffer.charAt(i) == '\n' || myBuffer.charAt(i) == myQuoteChar) { return i; } } return i; }
locateUnicodeEscapeSequence
289,541
int (int start, int indexOfCharAfterSlash) { return -1; }
locateAdditionalEscapeSequence
289,542
void () { myLastState = myState; myStart = myEnd; myEnd = locateToken(myStart); }
advance
289,543
CharSequence () { return myBuffer; }
getBufferSequence
289,544
int () { return myBufferEnd; }
getBufferEnd
289,545
String () { return "StringLiteralLexer {" + "myAllowHex=" + myAllowHex + ", myAllowOctal=" + myAllowOctal + ", mySeenEscapedSpacesOnly=" + mySeenEscapedSpacesOnly + ", myAdditionalValidEscapes='" + myAdditionalValidEscapes + '\'' + ", myCanEscapeEolOrFramingSpaces=" + myCanEscapeEolOrFramingSpaces + ", myOriginalLiteralToken=" + myOriginalLiteralToken + ", myQuoteChar=" + myQuoteChar + ", myBufferEnd=" + myBufferEnd + ", myLastState=" + myLastState + ", myState=" + myState + ", myEnd=" + myEnd + ", myStart=" + myStart + ", myToken=" + (myBuffer == null || myEnd < myStart || myEnd > myBuffer.length() ? null : myBuffer.subSequence(myStart, myEnd)) + '}'; }
toString
289,546
T (int last) { //noinspection unchecked return (T)myArray[last]; }
getRaw
289,547
int (int first, int last, Object[] result, int destinationPos) { int length = last - first; System.arraycopy(myArray, first, result, destinationPos, length); return length; }
copyFromTo
289,548
TokenList () { return myTokens; }
getTokens
289,549
void (@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) { assert Comparing.equal(buffer, myTokens.getTokenizedText()); assert startOffset == 0; assert endOffset == buffer.length(); assert initialState == 0; myIndex = 0; }
start
289,550
int () { return myIndex; }
getState
289,551
int () { return myTokens.getTokenStart(myIndex); }
getTokenStart
289,552
int () { return myTokens.getTokenEnd(myIndex); }
getTokenEnd
289,553
void () { myIndex++; }
advance
289,554
CharSequence () { return myTokens.getTokenizedText(); }
getBufferSequence
289,555
int () { return myTokens.getTokenizedText().length(); }
getBufferEnd
289,556
boolean (IElementType type) { return mySet.contains(type); }
reject
289,557
Lexer () { return getDelegate(); }
getOriginal
289,558
void (@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) { super.start(buffer, startOffset, endOffset, initialState); myPrevTokenEnd = -1; locateToken(); }
start
289,559
void () { myPrevTokenEnd = getDelegate().getTokenEnd(); super.advance(); locateToken(); }
advance
289,560
int () { return myPrevTokenEnd; }
getPrevTokenEnd
289,561
LexerPosition () { return getDelegate().getCurrentPosition(); }
getCurrentPosition
289,562
void (@NotNull LexerPosition position) { getDelegate().restore(position); myPrevTokenEnd = -1; }
restore
289,563
void () { while(true){ Lexer delegate = getDelegate(); IElementType tokenType = delegate.getTokenType(); if (tokenType == null) break; if (myFilter == null || !myFilter.reject(tokenType)) { if (myStateFilter == null || !myStateFilter[delegate.getState()]){ break; } } delegate.advance(); } }
locateToken
289,564
FlexLexer () { return myFlex; }
getFlex
289,565
void (final @NotNull CharSequence buffer, int startOffset, int endOffset, final int initialState) { myText = buffer; myTokenStart = myTokenEnd = startOffset; myBufferEnd = endOffset; myFlex.reset(myText, startOffset, endOffset, initialState); myTokenType = null; }
start
289,566
int () { locateToken(); return myState; }
getState
289,567
IElementType () { locateToken(); return myTokenType; }
getTokenType
289,568
int () { locateToken(); return myTokenStart; }
getTokenStart
289,569
int () { locateToken(); return myTokenEnd; }
getTokenEnd
289,570
void () { locateToken(); myTokenType = null; }
advance
289,571
CharSequence () { return myText; }
getBufferSequence
289,572
int () { return myBufferEnd; }
getBufferEnd
289,573
void () { if (myTokenType != null) return; myTokenStart = myTokenEnd; if (myFailed) return; try { myState = myFlex.yystate(); myTokenType = myFlex.advance(); myTokenEnd = myFlex.getTokenEnd(); } catch (ProcessCanceledException e) { throw e; } catch (Throwable e) { myFailed = true; myTokenType = TokenType.BAD_CHARACTER; myTokenEnd = myBufferEnd; LOG.warn(myFlex.getClass().getName(), e); } }
locateToken
289,574
String () { return "FlexAdapter for " + myFlex.getClass().getName(); }
toString
289,575
MergeFunction () { return myMergeFunction; }
getMergeFunction
289,576
IElementType (final IElementType type, final Lexer originalLexer) { if (!myTokenSet.contains(type)) { return type; } while (true) { final IElementType tokenType = originalLexer.getTokenType(); if (tokenType != type) break; originalLexer.advance(); } return type; }
merge
289,577
LexerPosition () { final int offset = getTokenStart(); final int intState = getState(); return new LexerPositionImpl(offset, intState); }
getCurrentPosition
289,578
void (@NotNull LexerPosition position) { start(getBufferSequence(), position.getOffset(), getBufferEnd(), position.getState()); }
restore
289,579
void (IElementType type) { addToken(myBaseLexer.getTokenEnd(), type); }
addToken
289,580
void (int endOffset, IElementType type) { myTypeCache.addLast(type); myEndOffsetCache.addLast(endOffset); }
addToken
289,581
void (@NotNull Lexer baseLexer) { advanceLexer(baseLexer); }
lookAhead
289,582
void () { if (!myTypeCache.isEmpty()) { myTypeCache.pullFirst(); myTokenStart = myEndOffsetCache.pullFirst(); } if (myTypeCache.isEmpty()) { doLookAhead(); } }
advance
289,583
void () { myLastOffset = myTokenStart; myLastState = myBaseLexer.getState(); lookAhead(myBaseLexer); assert !myTypeCache.isEmpty(); }
doLookAhead
289,584
CharSequence () { return myBaseLexer.getBufferSequence(); }
getBufferSequence
289,585
int () { return myBaseLexer.getBufferEnd(); }
getBufferEnd
289,586
int () { return myTypeCache.size(); }
getCacheSize
289,587
void (int size) { while (myTypeCache.size() > size) { myTypeCache.removeLast(); myEndOffsetCache.removeLast(); } }
resetCacheSize
289,588
IElementType (int index, IElementType token) { return myTypeCache.set(index, token); }
replaceCachedType
289,589
IElementType (int index) { return myTypeCache.get(index); }
getCachedType
289,590
int (int index) { return myEndOffsetCache.get(index); }
getCachedOffset
289,591
int () { int offset = myTokenStart - myLastOffset; return myLastState | (offset << 16); }
getState
289,592
int () { return myEndOffsetCache.peekFirst(); }
getTokenEnd
289,593
int () { return myTokenStart; }
getTokenStart
289,594
LookAheadLexerPosition () { return new LookAheadLexerPosition(this, ImmutableUserMap.EMPTY); }
getCurrentPosition
289,595
void (final @NotNull LexerPosition _position) { restore((LookAheadLexerPosition)_position); }
restore
289,596
void (@NotNull LookAheadLexerPosition position) { start(myBaseLexer.getBufferSequence(), position.lastOffset, myBaseLexer.getBufferEnd(), position.lastState); for (int i = 0; i < position.advanceCount; i++) { advance(); } }
restore
289,597
IElementType () { return myTypeCache.peekFirst(); }
getTokenType
289,598
void (@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) { myBaseLexer.start(buffer, startOffset, endOffset, initialState & 0xFFFF); myTokenStart = startOffset; myTypeCache.clear(); myEndOffsetCache.clear(); doLookAhead(); }
start
289,599
ImmutableUserMap () { return customMap; }
getCustomMap