MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

provide ability to add more than default breakpoint per breakpoint type

Browse Source 
GitOrigin-RevId: 98a83ebe2849f21edce62da04a4ba6127ad755f7
This commit is contained in:
Arseny Chernyaev
2019-07-03 18:50:15 +03:00
committed by intellij-monorepo-bot
parent 7472012b07
commit e65f106133
5 changed files with 74 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java
+6 -5
View File
@@ -339,11 +339,12 @@ public class BreakpointManager {
if (breakpointElement != null) {
XBreakpointManager manager = XDebuggerManager.getInstance(myProject).getBreakpointManager();
JavaExceptionBreakpointType type = XDebuggerUtil.getInstance().findBreakpointType(JavaExceptionBreakpointType.class);
XBreakpoint<JavaExceptionBreakpointProperties> xBreakpoint = manager.getDefaultBreakpoint(type);
Breakpoint breakpoint = getJavaBreakpoint(xBreakpoint);
if (breakpoint != null) {
breakpoint.readExternal(breakpointElement);
addBreakpoint(breakpoint);
for (XBreakpoint<JavaExceptionBreakpointProperties> defaultBreakpoint : manager.getDefaultBreakpoints(type)) {
Breakpoint breakpoint = getJavaBreakpoint(defaultBreakpoint);
if (breakpoint != null) {
breakpoint.readExternal(breakpointElement);
addBreakpoint(breakpoint);
}
}
}
}
platform/xdebugger-api/src/com/intellij/xdebugger/breakpoints/XBreakpointManager.java
+3 -2
View File
@@ -9,6 +9,7 @@ import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import java.util.Collection;
import java.util.Set;
/**
* Use {@link com.intellij.xdebugger.XDebuggerManager#getBreakpointManager()} to obtain instance of this service
@@ -50,8 +51,8 @@ public interface XBreakpointManager {
boolean isDefaultBreakpoint(@NotNull XBreakpoint<?> breakpoint);
@Nullable
<B extends XBreakpoint<?>> B getDefaultBreakpoint(@NotNull XBreakpointType<B, ?> type);
@NotNull
<B extends XBreakpoint<?>> Set<B> getDefaultBreakpoints(@NotNull XBreakpointType<B, ?> type);
<B extends XBreakpoint<P>, P extends XBreakpointProperties> void addBreakpointListener(@NotNull XBreakpointType<B, P> type,
@NotNull XBreakpointListener<B> listener);
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointManagerImpl.java
+53 -25
View File
@@ -26,6 +26,7 @@ import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author nik
@@ -34,9 +35,9 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
private static final Logger LOG = Logger.getInstance(XBreakpointManagerImpl.class);
private final MultiValuesMap<XBreakpointType, XBreakpointBase<?,?,?>> myBreakpoints = new MultiValuesMap<>(true);
private final Map<XBreakpointType, XBreakpointBase<?,?,?>> myDefaultBreakpoints = new LinkedHashMap<>();
private final Map<XBreakpointType, Set<XBreakpointBase<?,?,?>>> myDefaultBreakpoints = new LinkedHashMap<>();
private final Map<XBreakpointType, BreakpointState<?,?,?>> myBreakpointsDefaults = new LinkedHashMap<>();
private final Set<XBreakpointBase<?,?,?>> myAllBreakpoints = new HashSet<>();
private final Set<XBreakpointBase<?,?,?>> myAllBreakpoints = new LinkedHashSet<>();
private final Map<XBreakpointType, EventDispatcher<XBreakpointListener>> myDispatchers = new HashMap<>();
private XBreakpointsDialogState myBreakpointsDialogSettings;
private volatile EventDispatcher<XBreakpointListener> myAllBreakpointsDispatcher;
@@ -117,9 +118,14 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
@Override
@NotNull
public <T extends XBreakpointProperties> XBreakpoint<T> addBreakpoint(final XBreakpointType<XBreakpoint<T>,T> type, @Nullable final T properties) {
return addBreakpoint(type, properties, false);
}
@NotNull
public <T extends XBreakpointProperties> XBreakpoint<T> addBreakpoint(final XBreakpointType<XBreakpoint<T>,T> type, @Nullable final T properties, boolean defaultBreakpoint) {
ApplicationManager.getApplication().assertWriteAccessAllowed();
XBreakpointBase<?, T, ?> breakpoint = createBreakpoint(type, properties, true, false);
addBreakpoint(breakpoint, false, true);
XBreakpointBase<?, T, ?> breakpoint = createBreakpoint(type, properties, true, defaultBreakpoint);
addBreakpoint(breakpoint, defaultBreakpoint, true);
return breakpoint;
}
@@ -138,8 +144,8 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
boolean initUI) {
XBreakpointType type = breakpoint.getType();
if (defaultBreakpoint) {
LOG.assertTrue(!myDefaultBreakpoints.containsKey(type), "Cannot have more than one default breakpoint (type " + type.getId() + ")");
myDefaultBreakpoints.put(type, breakpoint);
Set<XBreakpointBase<?, ?, ?>> typeDefaultBreakpoints = myDefaultBreakpoints.computeIfAbsent(type, k -> new LinkedHashSet<>());
typeDefaultBreakpoints.add(breakpoint);
}
else {
myBreakpoints.put(type, breakpoint);
@@ -184,11 +190,16 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
@Override
public void removeBreakpoint(@NotNull final XBreakpoint<?> breakpoint) {
ApplicationManager.getApplication().assertWriteAccessAllowed();
doRemoveBreakpoint(breakpoint);
doRemoveBreakpoint(breakpoint, false);
}
private void doRemoveBreakpoint(XBreakpoint<?> breakpoint) {
if (isDefaultBreakpoint(breakpoint)) {
public void removeBreakpoint(XBreakpoint<?> breakpoint, boolean forceRemoveDefaultBreakpoints) {
ApplicationManager.getApplication().assertWriteAccessAllowed();
doRemoveBreakpoint(breakpoint, forceRemoveDefaultBreakpoints);
}
private void doRemoveBreakpoint(XBreakpoint<?> breakpoint, boolean forceRemoveDefaultBreakpoints) {
if (isDefaultBreakpoint(breakpoint) && !forceRemoveDefaultBreakpoints) {
// removing default breakpoint should just disable it
breakpoint.setEnabled(false);
}
@@ -249,11 +260,8 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
@NotNull
public <B extends XBreakpoint<?>> Collection<? extends B> getBreakpoints(@NotNull final XBreakpointType<B,?> type) {
ApplicationManager.getApplication().assertReadAccessAllowed();
List<B> result = new ArrayList<>();
B defaultBreakpoint = getDefaultBreakpoint(type);
if (defaultBreakpoint != null) {
result.add(defaultBreakpoint);
}
Set<B> defaultBreakpoints = getDefaultBreakpoints(type);
List<B> result = new ArrayList<>(defaultBreakpoints);
Collection<XBreakpointBase<?, ?, ?>> breakpoints = myBreakpoints.get(type);
if (breakpoints != null) {
result.addAll((Collection<? extends B>)breakpoints);
@@ -270,10 +278,14 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
}
@Override
@Nullable
public <B extends XBreakpoint<?>> B getDefaultBreakpoint(@NotNull XBreakpointType<B, ?> type) {
@NotNull
public <B extends XBreakpoint<?>> Set<B> getDefaultBreakpoints(@NotNull XBreakpointType<B, ?> type) {
Set<XBreakpointBase<?, ?, ?>> breakpointsSet = myDefaultBreakpoints.get(type);
if (breakpointsSet == null) {
return Collections.emptySet();
}
//noinspection unchecked
return (B)myDefaultBreakpoints.get(type);
return breakpointsSet.stream().map(breakpoint -> (B)breakpoint).collect(Collectors.toSet());
}
@Override
@@ -296,8 +308,7 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
@Override
public boolean isDefaultBreakpoint(@NotNull XBreakpoint<?> breakpoint) {
//noinspection SuspiciousMethodCalls
return myDefaultBreakpoints.values().contains(breakpoint);
return getDefaultBreakpoints(breakpoint.getType()).contains(breakpoint);
}
private <T extends XBreakpointProperties> EventDispatcher<XBreakpointListener> getOrCreateDispatcher(final XBreakpointType<?,T> type) {
@@ -370,10 +381,12 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
myDependentBreakpointManager.saveState();
List<BreakpointState<?, ?, ?>> defaultBreakpoints = new SmartList<>();
for (XBreakpointBase<?, ?, ?> breakpoint : myDefaultBreakpoints.values()) {
final BreakpointState breakpointState = breakpoint.getState();
if (differsFromDefault(breakpoint.getType(), breakpointState)) {
defaultBreakpoints.add(breakpointState);
for (Set<XBreakpointBase<?, ?, ?>> typeDefaultBreakpoints : myDefaultBreakpoints.values()) {
for (XBreakpointBase<?, ?, ?> breakpoint : typeDefaultBreakpoints) {
final BreakpointState breakpointState = breakpoint.getState();
if (differsFromDefault(breakpoint.getType(), breakpointState)) {
defaultBreakpoints.add(breakpointState);
}
}
}
@@ -435,9 +448,9 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
ApplicationManager.getApplication().runReadAction(() -> {
ContainerUtil.notNullize(state.getDefaultBreakpoints()).forEach(breakpointState -> loadBreakpoint(breakpointState, true));
XBreakpointUtil.breakpointTypes().remove(myDefaultBreakpoints::containsKey).forEach(this::addDefaultBreakpoint);
loadDefaultBreakpointsFromType();
myBreakpoints.values().forEach(this::doRemoveBreakpoint);
myBreakpoints.values().forEach(breakpoint -> doRemoveBreakpoint(breakpoint, false));
ContainerUtil.notNullize(state.getBreakpoints()).forEach(breakpointState -> loadBreakpoint(breakpointState, false));
@@ -457,6 +470,21 @@ public class XBreakpointManagerImpl implements XBreakpointManager {
myDefaultGroup = state.getDefaultGroup();
}
@SuppressWarnings("unchecked")
private void loadDefaultBreakpointsFromType() {
for (XBreakpointType breakpointType : XBreakpointUtil.breakpointTypes()) {
XBreakpointBase defaultBreakpoint = (XBreakpointBase) createDefaultBreakpoint(breakpointType);
if (defaultBreakpoint == null) {
continue;
}
BreakpointState defaultBreakpointState = defaultBreakpoint.getState();
if (getDefaultBreakpoints(breakpointType).stream().allMatch(existingBreakpoint -> statesAreDifferent(defaultBreakpointState, ((XBreakpointBase) existingBreakpoint).getState(), false))) {
addBreakpoint(defaultBreakpoint, true, false);
}
}
}
private <P extends XBreakpointProperties> void addDefaultBreakpoint(XBreakpointType<?, P> type) {
final XBreakpoint<P> breakpoint = createDefaultBreakpoint(type);
if (breakpoint != null) {
platform/xdebugger-impl/testSrc/com/intellij/xdebugger/XBreakpointManagerTest.java
+9 -8
View File
@@ -13,6 +13,7 @@ import org.jetbrains.annotations.NotNull;
import java.io.IOException;
import java.util.List;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
@@ -22,26 +23,26 @@ import static org.assertj.core.api.Assertions.assertThat;
public class XBreakpointManagerTest extends XBreakpointsTestCase {
public void testAddRemove() {
XBreakpoint<MyBreakpointProperties> defaultBreakpoint = myBreakpointManager.getDefaultBreakpoint(MY_SIMPLE_BREAKPOINT_TYPE);
assertSameElements(getAllBreakpoints(), defaultBreakpoint);
Set<XBreakpoint<MyBreakpointProperties>> defaultBreakpoints = myBreakpointManager.getDefaultBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE);
assertSameElements(getAllBreakpoints(), defaultBreakpoints);
XLineBreakpoint<MyBreakpointProperties> lineBreakpoint =
addLineBreakpoint(myBreakpointManager, "url", 239, new MyBreakpointProperties("123"));
XBreakpoint<MyBreakpointProperties> breakpoint = addBreakpoint(myBreakpointManager, new MyBreakpointProperties("abc"));
assertSameElements(getAllBreakpoints(), breakpoint, lineBreakpoint, defaultBreakpoint);
assertSameElements(getAllBreakpoints(), breakpoint, lineBreakpoint, defaultBreakpoints);
assertSame(lineBreakpoint, assertOneElement(myBreakpointManager.getBreakpoints(MY_LINE_BREAKPOINT_TYPE)));
assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), breakpoint, defaultBreakpoint);
assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), breakpoint, defaultBreakpoints);
removeBreakPoint(myBreakpointManager, lineBreakpoint);
assertSameElements(getAllBreakpoints(), breakpoint, defaultBreakpoint);
assertSameElements(getAllBreakpoints(), breakpoint, defaultBreakpoints);
assertTrue(myBreakpointManager.getBreakpoints(MY_LINE_BREAKPOINT_TYPE).isEmpty());
assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), breakpoint, defaultBreakpoint);
assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), breakpoint, defaultBreakpoints);
removeBreakPoint(myBreakpointManager, breakpoint);
assertSameElements(getAllBreakpoints(), defaultBreakpoint);
assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), defaultBreakpoint);
assertSameElements(getAllBreakpoints(), defaultBreakpoints);
assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), defaultBreakpoints);
}
public void testSerialize() {
platform/xdebugger-testFramework/src/com/intellij/xdebugger/XDebuggerTestUtil.java
+3 -3
View File
@@ -553,9 +553,9 @@ public class XDebuggerTestUtil {
void setDefaultBreakpointEnabled(@NotNull final Project project, Class<? extends XBreakpointType<B, ?>> bpTypeClass, boolean enabled) {
final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
XBreakpointType<B, ?> bpType = XDebuggerUtil.getInstance().findBreakpointType(bpTypeClass);
XBreakpoint<?> bp = breakpointManager.getDefaultBreakpoint(bpType);
if (bp != null) {
bp.setEnabled(enabled);
Set<B> defaultBreakpoints = breakpointManager.getDefaultBreakpoints(bpType);
for (B defaultBreakpoint : defaultBreakpoints) {
defaultBreakpoint.setEnabled(enabled);
}
}