Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
295,400 | Project () { return myProject; } | getProject |
295,401 | void (Collection<? extends XBreakpointBase<?, ?, ?>> breakpoints) { for (XBreakpointBase<?, ?, ?> breakpoint : breakpoints) { fireBreakpointChanged(breakpoint); } } | fireBreakpointsChanged |
295,402 | boolean (XBreakpoint<?> breakpoint) { return withLockMaybeCancellable(myLock, () -> myAllBreakpoints.contains(breakpoint)); } | isRegistered |
295,403 | void (XBreakpointBase<?, ?, ?> breakpoint) { if (isRegistered(breakpoint)) { if (breakpoint instanceof XLineBreakpointImpl) { myLineBreakpointManager.breakpointChanged((XLineBreakpointImpl)breakpoint); } sendBreakpointEvent(breakpoint.getType(), listener -> listener.breakpointChanged(breakpoint)); } } | fireBreakpointChanged |
295,404 | void (XBreakpoint<?> breakpoint, @Nullable XDebugSession session) { if (isRegistered(breakpoint)) { sendBreakpointEvent(breakpoint.getType(), listener -> listener.breakpointPresentationUpdated(breakpoint, session)); } } | fireBreakpointPresentationUpdated |
295,405 | void (@NotNull final XBreakpoint<?> breakpoint) { removeBreakpoints(List.of(breakpoint)); } | removeBreakpoint |
295,406 | void () { withLockMaybeCancellable(myLock, () -> List.copyOf(myAllBreakpoints).forEach(this::doRemoveBreakpoint)); } | removeAllBreakpoints |
295,407 | void (@NotNull final XBreakpoint<?> breakpoint) { withLockMaybeCancellable(myLock, () -> { if (!isDefaultBreakpoint(breakpoint)) { throw new IllegalStateException("Trying to remove not default breakpoint " + breakpoint); } doRemoveBreakpointImpl(breakpoint, true); }); } | removeDefaultBreakpoint |
295,408 | void (XBreakpoint<?> breakpoint) { if (isDefaultBreakpoint(breakpoint)) { // removing default breakpoint should just disable it breakpoint.setEnabled(false); } else { doRemoveBreakpointImpl(breakpoint, false); } } | doRemoveBreakpoint |
295,409 | void (XBreakpoint<?> breakpoint, boolean isDefaultBreakpoint) { XBreakpointType type = breakpoint.getType(); XBreakpointBase<?, ?, ?> breakpointBase = (XBreakpointBase<?, ?, ?>)breakpoint; withLockMaybeCancellable(myLock, () -> { if (isDefaultBreakpoint) { Set<XBreakpointBase<?, ?, ?>> typeDefaultBreakpoints = myDefaul... | doRemoveBreakpointImpl |
295,410 | void (XBreakpointType type, Consumer<? super XBreakpointListener<XBreakpoint<?>>> event) { if (myFirstLoadDone) { EventDispatcher<XBreakpointListener> dispatcher = myDispatchers.get(type); if (dispatcher != null) { //noinspection unchecked XBreakpointListener<XBreakpoint<?>> multicaster = dispatcher.getMulticaster(); e... | sendBreakpointEvent |
295,411 | boolean (@NotNull XBreakpoint<?> breakpoint) { return withLockMaybeCancellable(myLock, () -> ContainerUtil.exists(myDefaultBreakpoints.values(), s -> s.contains(breakpoint))); } | isDefaultBreakpoint |
295,412 | void (@NotNull XLineBreakpoint<?> breakpoint, @Nullable Icon icon, @Nullable String errorMessage) { XLineBreakpointImpl lineBreakpoint = (XLineBreakpointImpl)breakpoint; CustomizedBreakpointPresentation presentation = lineBreakpoint.getCustomizedPresentation(); if (presentation == null) { if (icon == null && errorMessa... | updateBreakpointPresentation |
295,413 | BreakpointManagerState (@NotNull BreakpointManagerState state) { // create default breakpoints map without locking var defaultBreakpointsMap = StreamEx.of(createDefaultBreakpoints()).toMap(XBreakpointBase::getType, Function.identity()); return withLockMaybeCancellable(myLock, () -> { myDependentBreakpointManager.saveSt... | saveState |
295,414 | boolean (BreakpointState state1, BreakpointState state2, boolean ignoreTimestamp) { long timeStamp1 = state1.getTimeStamp(); long timeStamp2 = state2.getTimeStamp(); if (ignoreTimestamp) { state1.setTimeStamp(timeStamp2); } Element elem1 = XmlSerializer.serialize(state1); Element elem2 = XmlSerializer.serialize(state2)... | statesAreDifferent |
295,415 | void (@NotNull BreakpointManagerState state) { // create default breakpoint without locking var defaultBreakpoints = createDefaultBreakpoints(); // make sure that no RW lock is taken under myLock ApplicationManager.getApplication().runReadAction(() -> { withLockMaybeCancellable(myLock, () -> { myBreakpointsDialogSettin... | loadState |
295,416 | void () { // create default breakpoint without locking var defaultBreakpoints = createDefaultBreakpoints(); withLockMaybeCancellable(myLock, () -> { myDefaultBreakpoints.clear(); //noinspection unchecked defaultBreakpoints.forEach(b -> addBreakpoint(b, true, false)); myFirstLoadDone = true; }); } | noStateLoaded |
295,417 | List<XBreakpointBase> () { //noinspection unchecked return XBreakpointUtil.breakpointTypes().map(this::createDefaultBreakpoint).nonNull().toList(); } | createDefaultBreakpoints |
295,418 | void (BreakpointState breakpointState, final boolean defaultBreakpoint) { XBreakpointBase<?,?,?> breakpoint = createBreakpoint(breakpointState); if (breakpoint != null) { addBreakpoint(breakpoint, defaultBreakpoint, false); } myTime = Math.max(myTime, breakpointState.getTimeStamp()); } | loadBreakpoint |
295,419 | XBreakpointsDialogState () { return myBreakpointsDialogSettings; } | getBreakpointsDialogSettings |
295,420 | void (XBreakpointsDialogState breakpointsDialogSettings) { myBreakpointsDialogSettings = breakpointsDialogSettings; } | setBreakpointsDialogSettings |
295,421 | Set<String> () { return withLockMaybeCancellable(myLock, () -> StreamEx.of(myAllBreakpoints).map(XBreakpointBase::getGroup).nonNull().toSet()); } | getAllGroups |
295,422 | String () { return myDefaultGroup; } | getDefaultGroup |
295,423 | void (String defaultGroup) { myDefaultGroup = defaultGroup; } | setDefaultGroup |
295,424 | BreakpointState (@NotNull XBreakpointType type) { return withLockMaybeCancellable(myLock, () -> myBreakpointsDefaults.computeIfAbsent(type, k -> createBreakpointDefaults(type))); } | getBreakpointDefaults |
295,425 | BreakpointState (@NotNull XBreakpointType type) { BreakpointState state = new BreakpointState(); state.setTypeId(type.getId()); state.setSuspendPolicy(type.getDefaultSuspendPolicy()); return state; } | createBreakpointDefaults |
295,426 | void (@NotNull XBreakpointBase breakpoint) { myLastRemovedBreakpoint = new RemovedBreakpointData(breakpoint); } | rememberRemovedBreakpoint |
295,427 | XBreakpointBase () { return myLastRemovedBreakpoint != null ? myLastRemovedBreakpoint.myBreakpoint : null; } | getLastRemovedBreakpoint |
295,428 | XBreakpoint () { // FIXME[inline-bp]: support multiple breakpoints here if (myLastRemovedBreakpoint != null) { XBreakpoint breakpoint = myLastRemovedBreakpoint.restore(); myLastRemovedBreakpoint = null; return breakpoint; } return null; } | restoreLastRemovedBreakpoint |
295,429 | boolean () { return myLastRemovedBreakpoint != null && myLastRemovedBreakpoint.isRestorable(); } | canRestoreLastRemovedBreakpoint |
295,430 | void (Collection<XBreakpointGroupingRule> rules) { } | createBreakpointsGroupingRules |
295,431 | void (final BreakpointsListener listener, Project project, Disposable disposable) { project.getMessageBus().connect(disposable).subscribe(XBreakpointListener.TOPIC, new MyXBreakpointListener(listener, XDebuggerManager.getInstance(project).getBreakpointManager())); } | addListener |
295,432 | int () { return 0; } | getPriority |
295,433 | GutterIconRenderer (Object breakpoint) { if (breakpoint instanceof XLineBreakpointImpl) { RangeHighlighter highlighter = ((XLineBreakpointImpl<?>)breakpoint).getHighlighter(); if (highlighter != null) { return highlighter.getGutterIconRenderer(); } } return null; } | getBreakpointGutterIconRenderer |
295,434 | void (final Project project) { } | onDialogClosed |
295,435 | void (Project project, Collection<? super BreakpointItem> items) { Arrays.stream(XDebuggerManager.getInstance(project).getBreakpointManager().getAllBreakpoints()) .map(XBreakpointItem::new) .forEach(items::add); } | provideBreakpointItems |
295,436 | void (@NotNull XBreakpoint<?> breakpoint) { myListener.breakpointsChanged(); } | breakpointAdded |
295,437 | void (@NotNull XBreakpoint<?> breakpoint) { myListener.breakpointsChanged(); } | breakpointRemoved |
295,438 | void (@NotNull XBreakpoint<?> breakpoint) { myListener.breakpointsChanged(); } | breakpointChanged |
295,439 | String () { return myFileUrl; } | getFileUrl |
295,440 | void (final String fileUrl) { myFileUrl = fileUrl; } | setFileUrl |
295,441 | int () { return myLine; } | getLine |
295,442 | void (final int line) { myLine = line; } | setLine |
295,443 | boolean () { return myTemporary; } | isTemporary |
295,444 | void (boolean temporary) { myTemporary = temporary; } | setTemporary |
295,445 | XExpression () { checkConverted(); // old versions may have empty expressions serialized if (StringUtil.isEmptyOrSpaces(myExpression)) { return null; } return new XExpressionImpl(XmlStringUtil.unescapeIllegalXmlChars(myExpression), Language.findLanguageByID(myLanguage), myCustomInfo, myMode); } | toXExpression |
295,446 | void (String oldUrl, String newUrl) { myBreakpoints.values().forEach(breakpoint -> { String url = breakpoint.getFileUrl(); if (FileUtil.startsWith(url, oldUrl)) { breakpoint.setFileUrl(newUrl + url.substring(oldUrl.length())); } }); } | fileUrlChanged |
295,447 | void (@NotNull VirtualFileEvent event) { removeBreakpoints(myBreakpoints.get(event.getFile().getUrl())); } | fileDeleted |
295,448 | void (@NotNull EditorFactoryEvent event) { getInlineBreakpointInlayManager().initializeInNewEditor(event.getEditor()); } | editorCreated |
295,449 | void (@NotNull RegistryValue value) { if (!XDebuggerUtil.areInlineBreakpointsEnabled()) { // Multiple breakpoints on the single line should be joined in this case. for (String fileUrl : myBreakpoints.keySet()) { var file = VirtualFileManager.getInstance().findFileByUrl(fileUrl); if (file == null) continue; var document... | afterValueChanged |
295,450 | void (@NotNull VirtualFile file, @NotNull Document document) { myBreakpoints.get(file.getUrl()).stream().filter(b -> b.getHighlighter() == null) .forEach(XLineBreakpointManager.this::queueBreakpointUpdate); } | fileContentLoaded |
295,451 | InlineBreakpointInlayManager () { return InlineBreakpointInlayManager.getInstance(myProject); } | getInlineBreakpointInlayManager |
295,452 | void (XLineBreakpointImpl breakpoint, final boolean initUI) { if (initUI) { updateBreakpointNow(breakpoint); } myBreakpoints.putValue(breakpoint.getFileUrl(), breakpoint); } | registerBreakpoint |
295,453 | void (final XLineBreakpointImpl breakpoint) { myBreakpoints.remove(breakpoint.getFileUrl(), breakpoint); } | unregisterBreakpoint |
295,454 | Collection<XLineBreakpointImpl> (Document document) { VirtualFile file = FileDocumentManager.getInstance().getFile(document); if (file != null) { return myBreakpoints.get(file.getUrl()); } return Collections.emptyList(); } | getDocumentBreakpoints |
295,455 | void (@NotNull Document document) { Collection<XLineBreakpointImpl> breakpoints = getDocumentBreakpoints(document); if (breakpoints.isEmpty() || ApplicationManager.getApplication().isUnitTestMode()) { return; } IntSet positions = new IntOpenHashSet(); List<XLineBreakpoint> toRemove = new SmartList<>(); for (XLineBreakp... | updateBreakpoints |
295,456 | void (@Nullable final Collection<? extends XLineBreakpoint> toRemove) { if (ContainerUtil.isEmpty(toRemove)) { return; } ((XBreakpointManagerImpl)XDebuggerManager.getInstance(myProject).getBreakpointManager()).removeBreakpoints(toRemove); } | removeBreakpoints |
295,457 | void (XLineBreakpointImpl breakpoint) { if (ApplicationManager.getApplication().isDispatchThread()) { updateBreakpointNow(breakpoint); } else { queueBreakpointUpdate(breakpoint); } } | breakpointChanged |
295,458 | void (final XBreakpoint<?> slave) { queueBreakpointUpdate(slave, null); } | queueBreakpointUpdate |
295,459 | void (final XBreakpoint<?> slave, @Nullable Runnable callOnUpdate) { if (slave instanceof XLineBreakpointImpl<?>) { queueBreakpointUpdate((XLineBreakpointImpl<?>)slave, callOnUpdate); } } | queueBreakpointUpdate |
295,460 | void (@NotNull final XLineBreakpointImpl<?> breakpoint) { queueBreakpointUpdate(breakpoint, null); myBreakpointsUpdateQueue.sendFlush(); } | updateBreakpointNow |
295,461 | void () { breakpoint.doUpdateUI(ObjectUtils.notNull(callOnUpdate, EmptyRunnable.INSTANCE)); } | run |
295,462 | void () { myBreakpointsUpdateQueue.queue(new Update("all breakpoints") { @Override public void run() { myBreakpoints.values().forEach(b -> b.doUpdateUI(EmptyRunnable.INSTANCE)); } }); // skip waiting myBreakpointsUpdateQueue.sendFlush(); } | queueAllBreakpointsUpdate |
295,463 | void () { myBreakpoints.values().forEach(b -> b.doUpdateUI(EmptyRunnable.INSTANCE)); } | run |
295,464 | void (@NotNull final DocumentEvent e) { final Document document = e.getDocument(); Collection<XLineBreakpointImpl> breakpoints = getDocumentBreakpoints(document); if (!breakpoints.isEmpty()) { myBreakpointsUpdateQueue.queue(new Update(document) { @Override public void run() { ApplicationManager.getApplication().invokeL... | documentChanged |
295,465 | void () { ApplicationManager.getApplication().invokeLater(() -> { updateBreakpoints(document); }); } | run |
295,466 | void (@NotNull EditorMouseEvent e) { myDragDetected = true; } | mouseDragged |
295,467 | void (@NotNull EditorMouseEvent e) { myDragDetected = false; } | mousePressed |
295,468 | void (@NotNull final EditorMouseEvent e) { final Editor editor = e.getEditor(); final MouseEvent mouseEvent = e.getMouseEvent(); if (mouseEvent.isPopupTrigger() || mouseEvent.isMetaDown() || mouseEvent.isControlDown() || mouseEvent.getButton() != MouseEvent.BUTTON1 || DiffUtil.isDiffEditor(editor) || !isInsideClickable... | mouseClicked |
295,469 | boolean (EditorMouseEvent e, Editor editor) { if (ExperimentalUI.isNewUI() && e.getArea() == EditorMouseEventArea.LINE_NUMBERS_AREA) { return UISettings.getInstance().getShowBreakpointsOverLineNumbers(); } if (e.getArea() != EditorMouseEventArea.LINE_MARKERS_AREA && e.getArea() != EditorMouseEventArea.FOLDING_OUTLINE_A... | isInsideClickableGutterArea |
295,470 | boolean (@NotNull Editor editor) { if (myProject == editor.getProject()) { return true; } for (FileEditor fileEditor : FileEditorManager.getInstance(myProject).getAllEditors()) { if (fileEditor instanceof TextEditor && ((TextEditor)fileEditor).getEditor().equals(editor)) { return true; } } return false; } | isFromMyProject |
295,471 | void (@NotNull final XBreakpoint<?> slave, @NotNull final XBreakpoint<?> master) { queueBreakpointUpdate(slave); } | dependencySet |
295,472 | void (final XBreakpoint<?> breakpoint) { queueBreakpointUpdate(breakpoint); } | dependencyCleared |
295,473 | void (EditorColorsScheme scheme) { updateBreakpointsUI(); } | globalSchemeChange |
295,474 | String () { return myId; } | getId |
295,475 | String () { return myMasterBreakpointId; } | getMasterBreakpointId |
295,476 | boolean () { return myLeaveEnabled; } | isLeaveEnabled |
295,477 | void (final String id) { myId = id; } | setId |
295,478 | void (final String masterBreakpointId) { myMasterBreakpointId = masterBreakpointId; } | setMasterBreakpointId |
295,479 | void (final boolean leaveEnabled) { myLeaveEnabled = leaveEnabled; } | setLeaveEnabled |
295,480 | void (ColoredListCellRenderer renderer, Project project, boolean selected) { setupGenericRenderer(renderer, true); } | setupRenderer |
295,481 | void (ColoredTreeCellRenderer renderer, Project project, boolean selected) { setupGenericRenderer(renderer, false); } | setupRenderer |
295,482 | void (SimpleColoredComponent renderer, boolean plainView) { renderer.setIcon(getIcon()); final SimpleTextAttributes attributes = myBreakpoint.isEnabled() ? SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES : SimpleTextAttributes.GRAYED_ATTRIBUTES; renderer.append(StringUtil.notNullize(getDisplayText()), attributes); String d... | setupGenericRenderer |
295,483 | String () { return XBreakpointUtil.getShortText(myBreakpoint); } | getDisplayText |
295,484 | String () { return ((XBreakpointBase<?, ?, ?>)myBreakpoint).getUserDescription(); } | getUserDescription |
295,485 | Icon () { return ((XBreakpointBase<?, ?, ?>)myBreakpoint).getIcon(); } | getIcon |
295,486 | String () { return getDisplayText() + " " + StringUtil.notNullize(getUserDescription()); } | speedSearchText |
295,487 | String () { return XBreakpointUtil.getDisplayText(myBreakpoint); } | footerText |
295,488 | void () { if (myPropertiesPanel != null) { myPropertiesPanel.saveProperties(); } } | saveState |
295,489 | void (DetailView panel, boolean editorOnly) { XBreakpointBase breakpoint = (XBreakpointBase)myBreakpoint; Project project = breakpoint.getProject(); //saveState(); if (myPropertiesPanel != null) { myPropertiesPanel.dispose(); myPropertiesPanel = null; } if (!editorOnly) { myPropertiesPanel = new XLightBreakpointPropert... | doUpdateDetailView |
295,490 | void (DetailView panel, VirtualFile virtualFile, int line) { TextAttributes attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(DebuggerColors.BREAKPOINT_ATTRIBUTES); // null attributes to avoid the new highlighter for a line breakpoints DetailView.PreviewEditorState state = DetailView.Previe... | showInEditor |
295,491 | void (boolean requestFocus) { Navigatable navigatable = myBreakpoint.getNavigatable(); if (navigatable != null && navigatable.canNavigate()) { navigatable.navigate(requestFocus); } } | navigate |
295,492 | boolean () { Navigatable navigatable = myBreakpoint.getNavigatable(); return navigatable != null && navigatable.canNavigate(); } | canNavigate |
295,493 | boolean () { Navigatable navigatable = myBreakpoint.getNavigatable(); return navigatable != null && navigatable.canNavigateToSource(); } | canNavigateToSource |
295,494 | XBreakpointManagerImpl () { return ((XBreakpointBase<?, ?, ?>)myBreakpoint).getBreakpointManager(); } | getManager |
295,495 | boolean () { return !getManager().isDefaultBreakpoint(myBreakpoint); } | allowedToRemove |
295,496 | void (Project project) { XDebuggerUtil.getInstance().removeBreakpoint(project, myBreakpoint); } | removed |
295,497 | Object () { return myBreakpoint; } | getBreakpoint |
295,498 | boolean () { return myBreakpoint.isEnabled(); } | isEnabled |
295,499 | void (boolean state) { myBreakpoint.setEnabled(state); } | setEnabled |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.