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

more streams 2

Browse Source
This commit is contained in:
Egor.Ushakov
2016-10-20 15:43:01 +03:00
parent 6664c52c20
commit 66cfaab543
10 changed files with 51 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java
+5 -10
View File
@@ -169,7 +169,7 @@ public abstract class DebugProcessImpl extends UserDataHolderBase implements Deb
myNodeRenderersMap.clear();
myRenderers.clear();
try {
NodeRendererSettings.getInstance().getAllRenderers().stream().filter(NodeRenderer::isEnabled).forEach(myRenderers::add);
NodeRendererSettings.getInstance().getAllRenderers().stream().filter(NodeRenderer::isEnabled).forEachOrdered(myRenderers::add);
}
finally {
DebuggerInvocationUtil.swingInvokeLater(myProject, () -> {
@@ -396,18 +396,13 @@ public abstract class DebugProcessImpl extends UserDataHolderBase implements Deb
@NotNull
private static List<ClassFilter> getActiveFilters() {
List<ClassFilter> activeFilters = new ArrayList<>();
DebuggerSettings settings = DebuggerSettings.getInstance();
StreamEx<ClassFilter> stream = StreamEx.of(Extensions.getExtensions(DebuggerClassFilterProvider.EP_NAME))
.flatCollection(DebuggerClassFilterProvider::getFilters);
if (settings.TRACING_FILTERS_ENABLED) {
Arrays.stream(settings.getSteppingFilters())
.filter(ClassFilter::isEnabled)
.forEach(activeFilters::add);
stream = stream.prepend(settings.getSteppingFilters());
}
Arrays.stream(Extensions.getExtensions(DebuggerClassFilterProvider.EP_NAME))
.flatMap(provider -> provider.getFilters().stream())
.filter(ClassFilter::isEnabled)
.forEach(activeFilters::add);
return activeFilters;
return stream.filter(ClassFilter::isEnabled).toList();
}
void deleteStepRequests(@Nullable final ThreadReference stepThread) {
java/debugger/impl/src/com/intellij/debugger/engine/JavaDebugProcess.java
+12 -15
View File
@@ -62,14 +62,11 @@ import com.intellij.xdebugger.impl.XDebuggerUtilImpl;
import com.intellij.xdebugger.ui.XDebugTabLayouter;
import com.sun.jdi.event.Event;
import com.sun.jdi.event.LocatableEvent;
import one.util.streamex.StreamEx;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.java.debugger.JavaDebuggerEditorsProvider;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author egor
*/
@@ -79,6 +76,14 @@ public class JavaDebugProcess extends XDebugProcess {
private final XBreakpointHandler<?>[] myBreakpointHandlers;
private final NodeManagerImpl myNodeManager;
private static final JavaBreakpointHandlerFactory[] ourDefaultBreakpointHandlerFactories = {
JavaBreakpointHandler.JavaLineBreakpointHandler::new,
JavaBreakpointHandler.JavaExceptionBreakpointHandler::new,
JavaBreakpointHandler.JavaFieldBreakpointHandler::new,
JavaBreakpointHandler.JavaMethodBreakpointHandler::new,
JavaBreakpointHandler.JavaWildcardBreakpointHandler::new
};
public static JavaDebugProcess create(@NotNull final XDebugSession session, final DebuggerSession javaSession) {
JavaDebugProcess res = new JavaDebugProcess(session, javaSession);
javaSession.getProcess().setXDebugProcess(res);
@@ -91,18 +96,10 @@ public class JavaDebugProcess extends XDebugProcess {
myEditorsProvider = new JavaDebuggerEditorsProvider();
final DebugProcessImpl process = javaSession.getProcess();
List<XBreakpointHandler> handlers = new ArrayList<>();
handlers.add(new JavaBreakpointHandler.JavaLineBreakpointHandler(process));
handlers.add(new JavaBreakpointHandler.JavaExceptionBreakpointHandler(process));
handlers.add(new JavaBreakpointHandler.JavaFieldBreakpointHandler(process));
handlers.add(new JavaBreakpointHandler.JavaMethodBreakpointHandler(process));
handlers.add(new JavaBreakpointHandler.JavaWildcardBreakpointHandler(process));
Arrays.stream(Extensions.getExtensions(JavaBreakpointHandlerFactory.EP_NAME))
myBreakpointHandlers = StreamEx.of(ourDefaultBreakpointHandlerFactories)
.append(Extensions.getExtensions(JavaBreakpointHandlerFactory.EP_NAME))
.map(factory -> factory.createHandler(process))
.forEach(handlers::add);
myBreakpointHandlers = handlers.toArray(new XBreakpointHandler[handlers.size()]);
.toArray(XBreakpointHandler[]::new);
myJavaSession.getContextManager().addListener(new DebuggerContextListener() {
@Override
java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/JavaBreakpointFiltersPanel.java
+2 -2
View File
@@ -30,6 +30,7 @@ import com.intellij.xdebugger.breakpoints.XBreakpoint;
import com.intellij.xdebugger.breakpoints.ui.XBreakpointCustomPropertiesPanel;
import com.intellij.xdebugger.impl.breakpoints.XBreakpointBase;
import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
import one.util.streamex.StreamEx;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.java.debugger.breakpoints.properties.JavaBreakpointProperties;
import org.jetbrains.java.debugger.breakpoints.properties.JavaExceptionBreakpointProperties;
@@ -40,7 +41,6 @@ import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
@@ -267,7 +267,7 @@ public class JavaBreakpointFiltersPanel<T extends JavaBreakpointProperties, B ex
}
}
}
Arrays.stream(myInstanceFilters).filter(instanceFilter -> !instanceFilter.isEnabled()).forEach(idxs::add);
StreamEx.of(myInstanceFilters).remove(InstanceFilter::isEnabled).forEach(idxs::add);
myInstanceFilters = idxs.toArray(new InstanceFilter[idxs.size()]);
}
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebuggerUtilImpl.java
+4 -10
View File
@@ -71,8 +71,6 @@ import com.intellij.xdebugger.impl.ui.tree.XDebuggerTreeState;
import com.intellij.xdebugger.impl.ui.tree.actions.XDebuggerTreeActionBase;
import com.intellij.xdebugger.settings.XDebuggerSettings;
import com.intellij.xdebugger.ui.DebuggerColors;
import gnu.trove.THashMap;
import one.util.streamex.StreamEx;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.concurrency.AsyncPromise;
@@ -90,13 +88,12 @@ import static org.jetbrains.concurrency.Promises.rejectedPromise;
*/
public class XDebuggerUtilImpl extends XDebuggerUtil {
private XLineBreakpointType<?>[] myLineBreakpointTypes;
private Map<Class<? extends XBreakpointType>, XBreakpointType<?, ?>> myBreakpointTypeByClass;
private Map<Class<? extends XBreakpointType>, XBreakpointType> myBreakpointTypeByClass;
@Override
public XLineBreakpointType<?>[] getLineBreakpointTypes() {
if (myLineBreakpointTypes == null) {
myLineBreakpointTypes =
StreamEx.of(XBreakpointUtil.getBreakpointTypes()).select(XLineBreakpointType.class).toArray(XLineBreakpointType<?>[]::new);
myLineBreakpointTypes = XBreakpointUtil.getBreakpointTypes().select(XLineBreakpointType.class).toArray(XLineBreakpointType<?>[]::new);
}
return myLineBreakpointTypes;
}
@@ -292,12 +289,9 @@ public class XDebuggerUtilImpl extends XDebuggerUtil {
@Override
public <T extends XBreakpointType> T findBreakpointType(@NotNull Class<T> typeClass) {
if (myBreakpointTypeByClass == null) {
myBreakpointTypeByClass = new THashMap<>();
for (XBreakpointType<?, ?> breakpointType : XBreakpointUtil.getBreakpointTypes()) {
myBreakpointTypeByClass.put(breakpointType.getClass(), breakpointType);
}
myBreakpointTypeByClass = XBreakpointUtil.getBreakpointTypes().toMap(XBreakpointType::getClass, t -> t);
}
XBreakpointType<?, ?> type = myBreakpointTypeByClass.get(typeClass);
XBreakpointType type = myBreakpointTypeByClass.get(typeClass);
//noinspection unchecked
return (T)type;
}
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointManagerImpl.java
+2 -6
View File
@@ -75,9 +75,7 @@ public class XBreakpointManagerImpl implements XBreakpointManager, PersistentSta
HttpVirtualFileListener httpVirtualFileListener = this::updateBreakpointInFile;
HttpFileSystem.getInstance().addFileListener(httpVirtualFileListener, project);
}
for (XBreakpointType<?, ?> type : XBreakpointUtil.getBreakpointTypes()) {
addDefaultBreakpoint(type);
}
XBreakpointUtil.getBreakpointTypes().forEach(this::addDefaultBreakpoint);
}
}
@@ -399,9 +397,7 @@ public class XBreakpointManagerImpl implements XBreakpointManager, PersistentSta
ApplicationManager.getApplication().runReadAction(() -> {
state.getDefaultBreakpoints().forEach(breakpointState -> loadBreakpoint(breakpointState, true));
Arrays.stream(XBreakpointUtil.getBreakpointTypes())
.filter(type -> !myDefaultBreakpoints.containsKey(type))
.forEach(this::addDefaultBreakpoint);
XBreakpointUtil.getBreakpointTypes().remove(myDefaultBreakpoints::containsKey).forEach(this::addDefaultBreakpoint);
myBreakpoints.values().forEach(this::doRemoveBreakpoint);
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointPanelProvider.java
+4 -4
View File
@@ -38,6 +38,7 @@ import com.intellij.xdebugger.impl.breakpoints.ui.grouping.XBreakpointGroupingBy
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
@@ -122,10 +123,9 @@ public class XBreakpointPanelProvider extends BreakpointPanelProvider<XBreakpoin
@Override
public void provideBreakpointItems(Project project, Collection<BreakpointItem> items) {
XBreakpointManager manager = XDebuggerManager.getInstance(project).getBreakpointManager();
for (XBreakpointType<?, ?> type : XBreakpointUtil.getBreakpointTypes()) {
manager.getBreakpoints(type).stream().map(XBreakpointItem::new).forEach(items::add);
}
Arrays.stream(XDebuggerManager.getInstance(project).getBreakpointManager().getAllBreakpoints())
.map(XBreakpointItem::new)
.forEach(items::add);
}
private static class MyXBreakpointListener implements XBreakpointListener<XBreakpoint<?>> {
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointUtil.java
+4 -4
View File
@@ -34,13 +34,13 @@ import com.intellij.xdebugger.impl.XDebuggerUtilImpl;
import com.intellij.xdebugger.impl.XSourcePositionImpl;
import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem;
import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointPanelProvider;
import one.util.streamex.StreamEx;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.concurrency.Promise;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.jetbrains.concurrency.Promises.rejectedPromise;
@@ -64,11 +64,11 @@ public class XBreakpointUtil {
@Nullable
public static XBreakpointType<?, ?> findType(@NotNull @NonNls String id) {
return Arrays.stream(getBreakpointTypes()).filter(breakpointType -> id.equals(breakpointType.getId())).findFirst().orElse(null);
return getBreakpointTypes().filter(breakpointType -> id.equals(breakpointType.getId())).findFirst().orElse(null);
}
public static XBreakpointType<?, ?>[] getBreakpointTypes() {
return XBreakpointType.EXTENSION_POINT_NAME.getExtensions();
public static StreamEx<XBreakpointType> getBreakpointTypes() {
return StreamEx.of(XBreakpointType.EXTENSION_POINT_NAME.getExtensions());
}
@NotNull
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/BreakpointsDialog.java
+5 -6
View File
@@ -306,12 +306,11 @@ public class BreakpointsDialog extends DialogWrapper {
}
}.registerCustomShortcutSet(ActionManager.getInstance().getAction(IdeActions.ACTION_EDIT_SOURCE).getShortcutSet(), tree, myDisposable);
final DefaultActionGroup breakpointTypes = new DefaultActionGroup();
for (XBreakpointType<?, ?> type : XBreakpointUtil.getBreakpointTypes()) {
if (type.isAddBreakpointButtonVisible()) {
breakpointTypes.addAll(new AddXBreakpointAction(type));
}
}
DefaultActionGroup breakpointTypes = new DefaultActionGroup();
XBreakpointUtil.getBreakpointTypes()
.filter(XBreakpointType::isAddBreakpointButtonVisible)
.map(AddXBreakpointAction::new)
.forEach(breakpointTypes::add);
ToolbarDecorator decorator = ToolbarDecorator.createDecorator(tree).
setAddAction(new AnActionButtonRunnable() {
platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/grouping/XBreakpointTypeGroup.java
+2 -3
View File
@@ -1,5 +1,5 @@
/*
* Copyright 2000-2015 JetBrains s.r.o.
* Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,7 +15,6 @@
*/
package com.intellij.xdebugger.impl.breakpoints.ui.grouping;
import com.intellij.util.ArrayUtil;
import com.intellij.xdebugger.breakpoints.XBreakpointType;
import com.intellij.xdebugger.breakpoints.XLineBreakpointType;
import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroup;
@@ -75,6 +74,6 @@ public class XBreakpointTypeGroup extends XBreakpointGroup {
}
private static int indexOfType(XBreakpointType type) {
return ArrayUtil.find(XBreakpointUtil.getBreakpointTypes(), type);
return (int)XBreakpointUtil.getBreakpointTypes().indexOf(type).orElse(-1);
}
}
platform/xdebugger-impl/testSrc/com/intellij/xdebugger/XDebuggerTestUtil.java
+11 -15
View File
@@ -436,21 +436,17 @@ public class XDebuggerTestUtil {
public static <T extends XBreakpointType> XBreakpoint addBreakpoint(@NotNull final Project project,
@NotNull final Class<T> exceptionType,
@NotNull final XBreakpointProperties properties) {
final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
XBreakpointType[] types = XBreakpointUtil.getBreakpointTypes();
final Ref<XBreakpoint> breakpoint = Ref.create(null);
for (XBreakpointType type : types) {
if (exceptionType.isInstance(type)) {
final T breakpointType = exceptionType.cast(type);
new WriteAction() {
@Override
protected void run(@NotNull Result result) throws Throwable {
breakpoint.set(breakpointManager.addBreakpoint(breakpointType, properties));
}
}.execute();
break;
}
}
XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
Ref<XBreakpoint> breakpoint = Ref.create(null);
XBreakpointUtil.getBreakpointTypes().select(exceptionType).findFirst().ifPresent(type -> {
final T breakpointType = exceptionType.cast(type);
new WriteAction() {
@Override
protected void run(@NotNull Result result) throws Throwable {
breakpoint.set(breakpointManager.addBreakpoint(breakpointType, properties));
}
}.execute();
});
return breakpoint.get();
}