Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
250,700 | void (@NotNull DocumentEvent e) { if (!myMarker.isValid()) { invalidated(e); } } | documentChanged |
250,701 | OffsetsInFile () { return myHostOffsets; } | getHostOffsets |
250,702 | ClassifierFactory<LookupElement> (final LookupElementWeigher weigher) { final String id = weigher.toString(); return new ClassifierFactory<>(id) { @Override public Classifier<LookupElement> createClassifier(Classifier<LookupElement> next) { return new CachingComparingClassifier(next, weigher); } }; } | weighingFactory |
250,703 | Classifier<LookupElement> (Classifier<LookupElement> next) { return new CachingComparingClassifier(next, weigher); } | createClassifier |
250,704 | CompletionSorterImpl (ClassifierFactory<LookupElement> classifierFactory) { return enhanced(classifierFactory, myMembers.size()); } | withClassifier |
250,705 | CompletionSorterImpl (@NotNull String anchorId, boolean beforeAnchor, ClassifierFactory<LookupElement> classifierFactory) { final int i = idIndex(anchorId); return enhanced(classifierFactory, beforeAnchor ? Math.max(0, i) : i + 1); } | withClassifier |
250,706 | CompletionSorterImpl (@NotNull Predicate<? super ClassifierFactory<LookupElement>> removeCondition) { return new CompletionSorterImpl(ContainerUtil.filter(myMembers, t -> !removeCondition.test(t))); } | withoutClassifiers |
250,707 | CompletionSorterImpl (ClassifierFactory<LookupElement> classifierFactory, int index) { final List<ClassifierFactory<LookupElement>> copy = new ArrayList<>(myMembers); copy.add(index, classifierFactory); return new CompletionSorterImpl(copy); } | enhanced |
250,708 | int (final String id) { return ContainerUtil.indexOf(myMembers, factory -> id.equals(factory.getId())); } | idIndex |
250,709 | boolean (Object o) { return this == o || o instanceof CompletionSorterImpl that && myMembers.equals(that.myMembers); } | equals |
250,710 | int () { return myHashCode; } | hashCode |
250,711 | Classifier<LookupElement> (final int index, final List<? extends ClassifierFactory<LookupElement>> components, Classifier<LookupElement> tail) { if (index == components.size()) { return tail; } return components.get(index).createClassifier(createClassifier(index + 1, components, tail)); } | createClassifier |
250,712 | Classifier<LookupElement> (Classifier<LookupElement> tail) { return createClassifier(0, myMembers, tail); } | buildClassifier |
250,713 | Comparable (@NotNull LookupElement element, @NotNull WeighingContext context) { return getBestMatchingDegree(element, CompletionService.getItemMatcher(element, context)); } | weigh |
250,714 | int (LookupElement element, PrefixMatcher matcher) { int max = Integer.MIN_VALUE; for (String lookupString : element.getAllLookupStrings()) { max = Math.max(max, matcher.matchingDegree(lookupString)); } return max == Integer.MIN_VALUE ? Integer.MAX_VALUE : -max; } | getBestMatchingDegree |
250,715 | void (@NotNull LookupElement added, @NotNull ProcessingContext context) { synchronized (this) { myCount++; for (String string : CompletionUtil.iterateLookupStrings(added)) { if (string.length() == 0) continue; myElements.putValue(string, added); mySortedStrings.add(string); final NavigableSet<String> after = mySortedSt... | addElement |
250,716 | void (LookupElement shorter, LookupElement longer) { if (myCondition.shouldLift(shorter, longer)) { myToLift.putValue(longer, shorter); myReversedToLift.putValue(shorter, longer); } } | updateLongerItem |
250,717 | Iterable<LookupElement> (@NotNull Iterable<? extends LookupElement> source, @NotNull ProcessingContext context) { return liftShorterElements(source, null, context); } | classify |
250,718 | Iterable<LookupElement> (@NotNull Iterable<? extends LookupElement> source, @Nullable Set<? super LookupElement> lifted, @NotNull ProcessingContext context) { Set<LookupElement> srcSet = new ReferenceOpenHashSet<>(source instanceof Collection ? ((Collection<?>)source).size() : myCount); ContainerUtil.addAll(srcSet, sou... | liftShorterElements |
250,719 | void (@NotNull LookupElement element, @NotNull ProcessingContext context) { synchronized (this) { for (String s : CompletionUtil.iterateLookupStrings(element)) { myElements.remove(s, element); if (myElements.get(s).isEmpty()) { mySortedStrings.remove(s); } } removeFromMap(element, myToLift, myReversedToLift); removeFro... | removeElement |
250,720 | void (LookupElement key, @NotNull MultiMap<LookupElement, LookupElement> mainMap, @NotNull MultiMap<LookupElement, LookupElement> inverseMap) { Collection<LookupElement> removed = mainMap.remove(key); if (removed == null) return; for (LookupElement reference : new ArrayList<>(removed)) { inverseMap.remove(reference, ke... | removeFromMap |
250,721 | boolean (LookupElement shorterElement, LookupElement longerElement) { return true; } | shouldLift |
250,722 | Iterator<LookupElement> () { Set<LookupElement> processed = new ReferenceOpenHashSet<>(mySrcSet.size()); Set<Collection<LookupElement>> arraysProcessed = new ReferenceOpenHashSet<>(); final Iterable<? extends LookupElement> next = myNext == null ? mySource : myNext.classify(mySource, myContext); Iterator<LookupElement>... | iterator |
250,723 | Iterator<LookupElement> (LookupElement element) { List<LookupElement> toLift; synchronized (LiftShorterItemsClassifier.this) { toLift = new ArrayList<>(myToLift.get(element)); } List<LookupElement> shorter = addShorterElements(toLift); List<LookupElement> singleton = Collections.singletonList(element); if (shorter != n... | createValueIterator |
250,724 | boolean (K key, V value) { List<V> elements = (List<V>)get(key); int i = ContainerUtil.indexOfIdentity(elements, value); if (i >= 0) { elements.remove(i); if (elements.isEmpty()) { remove(key); } return true; } return false; } | remove |
250,725 | boolean () { return myCaseSensitive; } | isCaseSensitive |
250,726 | boolean (String name) { return myMatcher.isStartMatch(name); } | isStartMatch |
250,727 | boolean (LookupElement element) { for (String s : CompletionUtil.iterateLookupStrings(element)) { FList<TextRange> ranges = myCaseInsensitiveMatcher.matchingFragments(s); if (ranges == null) continue; if (ranges.isEmpty() || skipUnderscores(s) >= ranges.get(0).getStartOffset()) { return true; } } return false; } | isStartMatch |
250,728 | boolean () { return myTypoTolerant; } | isTypoTolerant |
250,729 | int (@NotNull String name) { return CharArrayUtil.shiftForward(name, 0, "_"); } | skipUnderscores |
250,730 | boolean (final @NotNull String name) { if (name.startsWith("_") && CodeInsightSettings.getInstance().getCompletionCaseSensitive() == CodeInsightSettings.FIRST_LETTER && firstLetterCaseDiffers(name)) { return false; } return myMatcher.matches(name); } | prefixMatches |
250,731 | boolean (String name) { int nameFirst = skipUnderscores(name); int prefixFirst = skipUnderscores(myPrefix); return nameFirst < name.length() && prefixFirst < myPrefix.length() && caseDiffers(name.charAt(nameFirst), myPrefix.charAt(prefixFirst)); } | firstLetterCaseDiffers |
250,732 | boolean (char c1, char c2) { return Character.isLowerCase(c1) != Character.isLowerCase(c2) || Character.isUpperCase(c1) != Character.isUpperCase(c2); } | caseDiffers |
250,733 | boolean (final @NotNull LookupElement element) { return prefixMatchersInternal(element, !element.isCaseSensitive()); } | prefixMatches |
250,734 | boolean (final LookupElement element, final boolean itemCaseInsensitive) { for (final String name : element.getAllLookupStrings()) { if (itemCaseInsensitive && StringUtil.startsWithIgnoreCase(name, myPrefix) || prefixMatches(name)) { return true; } if (itemCaseInsensitive && CodeInsightSettings.ALL != CodeInsightSettin... | prefixMatchersInternal |
250,735 | PrefixMatcher (final @NotNull String prefix) { if (prefix.equals(myPrefix)) { return this; } return new CamelHumpMatcher(prefix, myCaseSensitive, myTypoTolerant); } | cloneWithPrefix |
250,736 | MinusculeMatcher (final boolean caseSensitive) { String prefix = applyMiddleMatching(myPrefix); NameUtil.MatcherBuilder builder = NameUtil.buildMatcher(prefix); if (caseSensitive) { int setting = CodeInsightSettings.getInstance().getCompletionCaseSensitive(); if (setting == CodeInsightSettings.FIRST_LETTER) { builder =... | createMatcher |
250,737 | String (String prefix) { if (Registry.is("ide.completion.middle.matching") && !prefix.isEmpty() && !ourForceStartMatching) { return "*" + StringUtil.replace(prefix, ".", ". ").trim(); } return prefix; } | applyMiddleMatching |
250,738 | String () { return myPrefix; } | toString |
250,739 | void (Disposable parent) { ourForceStartMatching = true; Disposer.register(parent, new Disposable() { @Override public void dispose() { //noinspection AssignmentToStaticFieldFromInstanceMethod ourForceStartMatching = false; } }); } | forceStartMatching |
250,740 | void () { //noinspection AssignmentToStaticFieldFromInstanceMethod ourForceStartMatching = false; } | dispose |
250,741 | int (String string) { return matchingDegree(string, matchingFragments(string)); } | matchingDegree |
250,742 | int (String string, @Nullable FList<? extends TextRange> fragments) { int underscoreEnd = skipUnderscores(string); if (underscoreEnd > 0) { FList<TextRange> ciRanges = myCaseInsensitiveMatcher.matchingFragments(string); if (ciRanges != null && !ciRanges.isEmpty()) { int matchStart = ciRanges.get(0).getStartOffset(); if... | matchingDegree |
250,743 | Comparable (@NotNull LookupElement element, @NotNull WeighingContext context) { return !CompletionService.isStartMatch(element, context); } | weigh |
250,744 | boolean (PsiElement @NotNull [] result, Class<?> clazz) { for (PsiElement element : result) { if (element == null) { PluginException.logPluginError(LOG, "Null target element is returned by 'getGotoDeclarationTargets' in " + clazz.getName(), null, clazz ); return false; } } return true; } | assertNotNullElements |
250,745 | void (boolean greedy) { myContainerElement.setGreedyToRight(greedy); } | setGreedyToRight |
250,746 | int () { return myElements.size(); } | getElementsCount |
250,747 | void (PsiElement element, Expression expression, boolean alwaysStopAt) { final RangeMarker key = wrapElement(element); myAlwaysStopAtMap.put(key, alwaysStopAt ? Boolean.TRUE : Boolean.FALSE); replaceElement(key, expression); } | replaceElement |
250,748 | RangeMarker (final PsiElement element) { TextRange range = InjectedLanguageManager.getInstance(element.getProject()).injectedToHost(element, element.getTextRange()); return myDocument.createRangeMarker(range); } | wrapElement |
250,749 | RangeMarker (final PsiReference ref) { PsiElement element = ref.getElement(); return myDocument.createRangeMarker(ref.getRangeInElement().shiftRight( InjectedLanguageManager.getInstance(myFile.getProject()).injectedToHost(element, element.getTextRange().getStartOffset()) )); } | wrapReference |
250,750 | void (PsiElement element, @NonNls String varName, Expression expression, boolean alwaysStopAt) { replaceElement(element, varName, expression, alwaysStopAt, false); } | replaceElement |
250,751 | void (PsiReference ref, String varName, Expression expression, boolean alwaysStopAt) { final RangeMarker key = wrapReference(ref); myAlwaysStopAtMap.put(key, alwaysStopAt ? Boolean.TRUE : Boolean.FALSE); myVariableNamesMap.put(key, varName); replaceElement(key, expression); } | replaceElement |
250,752 | void (@NotNull PsiElement element, @NotNull TextRange textRange, String varName, Expression expression, boolean alwaysStopAt) { final TextRange elementTextRange = InjectedLanguageManager.getInstance(element.getProject()).injectedToHost(element, element.getTextRange()); final RangeMarker key = myDocument.createRangeMark... | replaceElement |
250,753 | void (final RangeMarker key, final Expression expression) { myExpressions.put(key, expression); myElements.add(key); } | replaceElement |
250,754 | void (PsiElement element, String varName, String dependantVariableName, boolean alwaysStopAt) { final RangeMarker key = wrapElement(element); myAlwaysStopAtMap.put(key, alwaysStopAt ? Boolean.TRUE : Boolean.FALSE); myVariableNamesMap.put(key, varName); myVariableExpressions.put(key, dependantVariableName); myElements.a... | replaceElement |
250,755 | void (PsiReference ref, @NonNls String varName, @NonNls String dependantVariableName, boolean alwaysStopAt) { final RangeMarker key = wrapReference(ref); myAlwaysStopAtMap.put(key, alwaysStopAt ? Boolean.TRUE : Boolean.FALSE); myVariableNamesMap.put(key, varName); myVariableExpressions.put(key, dependantVariableName); ... | replaceElement |
250,756 | void (PsiElement element, TextRange textRange, String primaryVariableName, String otherVariableName, boolean alwaysStopAt) { final TextRange elementTextRange = InjectedLanguageManager.getInstance(element.getProject()).injectedToHost(element, element.getTextRange()); final RangeMarker key = myDocument.createRangeMarker(... | replaceElement |
250,757 | void (@NotNull PsiElement element, Expression expression) { final RangeMarker key = wrapElement(element); replaceElement(key, expression); } | replaceElement |
250,758 | void (@NotNull PsiElement element, TextRange rangeWithinElement, Expression expression) { final RangeMarker key = myDocument.createRangeMarker(rangeWithinElement.shiftRight(element.getTextRange().getStartOffset())); replaceElement(key, expression); } | replaceElement |
250,759 | void (TextRange rangeWithinElement, String replacementText) { final RangeMarker key = myDocument.createRangeMarker(rangeWithinElement.shiftRight(myContainerElement.getStartOffset())); ConstantNode value = new ConstantNode(replacementText); replaceElement(key, value); } | replaceRange |
250,760 | void (TextRange rangeWithinElement, Expression expression) { final RangeMarker key = myDocument.createRangeMarker(rangeWithinElement); replaceElement(key, expression); } | replaceRange |
250,761 | void (PsiElement element) { element = PsiTreeUtil.nextLeaf(element); setEndVariableBefore(element); } | setEndVariableAfter |
250,762 | void (PsiElement element) { if (myEndElement != null) { myElements.remove(myEndElement); } myEndElement = wrapElement(element); myElements.add(myEndElement); } | setEndVariableBefore |
250,763 | void (PsiElement element) { mySelection = wrapElement(element); myElements.add(mySelection); } | setSelection |
250,764 | void (@Nullable Comparator<? super Variable> comparator) { myVariableComparator = comparator; } | setVariableOrdering |
250,765 | Template () { return initInlineTemplate(buildTemplate()); } | buildInlineTemplate |
250,766 | Template (Template template) { template.setInline(true); if (myFile.isPhysical()) { ApplicationManager.getApplication().assertWriteAccessAllowed(); } //this is kinda hacky way of doing things, but have not got a better idea DocumentUtil.executeInBulk(myDocument, true, () -> { for (RangeMarker element : myElements) { if... | initInlineTemplate |
250,767 | Template () { TemplateManager manager = TemplateManager.getInstance(myFile.getProject()); final Template template = manager.createTemplate("", ""); return initTemplate(template); } | buildTemplate |
250,768 | Template (Template template) { String text = getDocumentTextFragment(myContainerElement.getStartOffset(),myContainerElement.getEndOffset()); final int containerStart = myContainerElement.getStartOffset(); int start = 0; for (final RangeMarker element : myElements) { int offset = element.getStartOffset() - containerStar... | initTemplate |
250,769 | void (Template template) { if (myVariableComparator == null || !(template instanceof TemplateImpl templateImpl)) { return; } List<Variable> variables = new ArrayList<>(templateImpl.getVariables()); variables.sort(myVariableComparator); for (int i = variables.size() - 1; i >= 0; i--) { templateImpl.removeVariable(i); } ... | orderTemplateVariables |
250,770 | String (final int startOffset, final int endOffset) { return myDocument.getCharsSequence().subSequence(startOffset, endOffset).toString(); } | getDocumentTextFragment |
250,771 | void (@NotNull PsiElement element, @NlsSafe String replacementText) { replaceElement(element, new ConstantNode(replacementText)); } | replaceElement |
250,772 | void (@NotNull PsiElement element, TextRange rangeWithinElement, String replacementText) { final RangeMarker key = myDocument.createRangeMarker(rangeWithinElement.shiftRight(element.getTextRange().getStartOffset())); ConstantNode value = new ConstantNode(replacementText); replaceElement(key, value); } | replaceElement |
250,773 | void () { final Project project = myFile.getProject(); VirtualFile file = myFile.getVirtualFile(); assert file != null: "Virtual file is null for " + myFile; OpenFileDescriptor descriptor = new OpenFileDescriptor(project, file); final Editor editor = FileEditorManager.getInstance(project).openTextEditor(descriptor, tru... | run |
250,774 | void (final boolean inline) { Template template = new TemplateImpl("", ""); if (inline) { template = initInlineTemplate(template); } else { template = initTemplate(template); myDocument.replaceString(myContainerElement.getStartOffset(), myContainerElement.getEndOffset(), ""); } NonInteractiveTemplateUtil.runNonInteract... | runNonInteractively |
250,775 | void (final @NotNull Editor editor, final boolean inline) { final Template template; if (inline) { template = buildInlineTemplate(); } else { template = buildTemplate(); editor.getDocument().replaceString(myContainerElement.getStartOffset(), myContainerElement.getEndOffset(), ""); } editor.getCaretModel().moveToOffset(... | run |
250,776 | void (PsiElement element, @NonNls String varName, Expression expression, boolean alwaysStopAt, boolean skipOnStart) { final RangeMarker key = wrapElement(element); myAlwaysStopAtMap.put(key, alwaysStopAt ? Boolean.TRUE : Boolean.FALSE); myVariableNamesMap.put(key, varName); mySkipOnStartMap.put(key, skipOnStart); repla... | replaceElement |
250,777 | void (TextRange rangeWithinElement, String varName, Expression expression, boolean alwaysStopAt) { final RangeMarker key = myDocument.createRangeMarker(rangeWithinElement.shiftRight(myContainerElement.getStartOffset())); myAlwaysStopAtMap.put(key, alwaysStopAt ? Boolean.TRUE : Boolean.FALSE); myVariableNamesMap.put(key... | replaceRange |
250,778 | void (TextRange rangeWithinElement, String varName, String dependantVariableName, boolean alwaysStopAt) { final RangeMarker key = myDocument.createRangeMarker(rangeWithinElement.shiftRight(myContainerElement.getStartOffset())); myAlwaysStopAtMap.put(key, alwaysStopAt ? Boolean.TRUE : Boolean.FALSE); myVariableNamesMap.... | replaceElement |
250,779 | TemplateManager (Project project) { return project.getService(TemplateManager.class); } | getInstance |
250,780 | Variable (@NonNls @NotNull String name, @NotNull Expression defaultValueExpression, boolean isAlwaysStopAt) { return addVariable(name, defaultValueExpression, defaultValueExpression, isAlwaysStopAt); } | addVariable |
250,781 | Variable (@NonNls @NotNull String name, Expression expression, Expression defaultValueExpression, boolean isAlwaysStopAt) { return addVariable(name, expression, defaultValueExpression, isAlwaysStopAt, false); } | addVariable |
250,782 | boolean (@NotNull Property key) { return myUseStaticImport; } | getValue |
250,783 | void (@NotNull Property key, boolean value) { myUseStaticImport = value; } | setValue |
250,784 | boolean (@NotNull Property key) { return false; } | getDefaultValue |
250,785 | TemplateBuilder (@NotNull PsiElement element) { return new TemplateBuilderImpl(element); } | createTemplateBuilder |
250,786 | Macro (@NonNls String name) { return ContainerUtil.getFirstItem(myMacroTable.get(name)); } | createMacro |
250,787 | List<Macro> (@NonNls String name) { return (List<Macro>)myMacroTable.get(name); } | getMacros |
250,788 | Macro[] () { final Collection<? extends Macro> values = myMacroTable.values(); return values.toArray(new Macro[0]); } | getMacros |
250,789 | void (@NotNull Macro extension, @NotNull PluginDescriptor pluginDescriptor) { myMacroTable.putValue(extension.getName(), extension); } | extensionAdded |
250,790 | void (@NotNull Macro extension, @NotNull PluginDescriptor pluginDescriptor) { myMacroTable.remove(extension.getName(), extension); } | extensionRemoved |
250,791 | TemplateContext () { TemplateContext cloneResult = new TemplateContext(); cloneResult.myContextStates.putAll(myContextStates); return cloneResult; } | createCopy |
250,792 | boolean (@NotNull LiveTemplateContextsSnapshot allContexts, @NotNull TemplateImpl thisTemplate, @NotNull TemplateImpl defaultTemplate) { return getDifference(allContexts, thisTemplate.getTemplateContext(), defaultTemplate.getTemplateContext()) == null; } | contextsEqual |
250,793 | boolean (@NotNull TemplateContextType contextType) { LiveTemplateContextsSnapshot allContexts = LiveTemplateContextService.getInstance().getSnapshot(); synchronized (myContextStates) { return isEnabledNoSync(this, allContexts, contextType.getContextId()); } } | isEnabled |
250,794 | boolean (@NotNull LiveTemplateContextsSnapshot allContexts, @NotNull TemplateContext thisContext, @NotNull LiveTemplateContext contextType) { synchronized (thisContext.myContextStates) { return isEnabledNoSync(thisContext, allContexts, contextType.getContextId()); } } | isEnabled |
250,795 | boolean (@NotNull TemplateContext thisContext, @NotNull LiveTemplateContextsSnapshot allContexts, @NotNull String contextTypeId) { Boolean storedValue = thisContext.getOwnValueNoSync(contextTypeId); if (storedValue == null) { LiveTemplateContext liveTemplateContext = allContexts.getLiveTemplateContext(contextTypeId); S... | isEnabledNoSync |
250,796 | void (TemplateContextType contextType, boolean value) { synchronized (myContextStates) { myContextStates.put(contextType.getContextId(), value); } } | setEnabled |
250,797 | void (@NotNull TemplateContext defContext) { Map<String, Boolean> copy = new HashMap<>(myContextStates); myContextStates.clear(); myContextStates.putAll(defContext.myContextStates); myContextStates.putAll(copy); } | setDefaultContext |
250,798 | void (@NotNull Element element, @NotNull LiveTemplateContextService ltContextService) { Map<String, String> internMap = ltContextService.getInternalIds(); for (Element option : element.getChildren("option")) { String name = option.getAttributeValue("name"); String value = option.getAttributeValue("value"); if (name != ... | readTemplateContext |
250,799 | void (@NotNull Element element) { readTemplateContext(element, LiveTemplateContextService.getInstance()); } | readTemplateContext |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.