From 7a76bbe16013a8cda3b4dc476ca03fbde855a528 Mon Sep 17 00:00:00 2001 From: Aleksey Pivovarov Date: Wed, 28 Oct 2015 15:14:00 +0300 Subject: [PATCH] vcs: add simplier interface for BackgroundableActionEnabledHandler --- .../BackgroundableActionEnabledHandler.java | 23 +++--- .../vcs/impl/BackgroundableActionLock.java | 72 +++++++++++++++++++ .../vcs/impl/ProjectLevelVcsManagerImpl.java | 61 ++++++++++++---- 3 files changed, 131 insertions(+), 25 deletions(-) create mode 100644 platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionLock.java diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionEnabledHandler.java b/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionEnabledHandler.java index 6b344e2ef9d5..bf3544ce35cd 100644 --- a/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionEnabledHandler.java +++ b/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionEnabledHandler.java @@ -15,30 +15,27 @@ */ package com.intellij.openapi.vcs.impl; -import com.intellij.openapi.application.ApplicationManager; - -import java.util.HashSet; -import java.util.Set; +import com.intellij.openapi.project.Project; +@Deprecated public class BackgroundableActionEnabledHandler { - private final Set myInProgress; + private final Project myProject; + private final VcsBackgroundableActions myAction; - public BackgroundableActionEnabledHandler() { - myInProgress = new HashSet(); + BackgroundableActionEnabledHandler(Project project, VcsBackgroundableActions action) { + myProject = project; + myAction = action; } public void register(final Object path) { - ApplicationManager.getApplication().assertIsDispatchThread(); - myInProgress.add(path); + BackgroundableActionLock.lock(myProject, myAction, path); } public boolean isInProgress(final Object path) { - ApplicationManager.getApplication().assertIsDispatchThread(); - return myInProgress.contains(path); + return BackgroundableActionLock.isLocked(myProject, myAction, path); } public void completed(final Object path) { - ApplicationManager.getApplication().assertIsDispatchThread(); - myInProgress.remove(path); + BackgroundableActionLock.unlock(myProject, myAction, path); } } diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionLock.java b/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionLock.java new file mode 100644 index 000000000000..1ed40a559339 --- /dev/null +++ b/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/BackgroundableActionLock.java @@ -0,0 +1,72 @@ +/* + * Copyright 2000-2015 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.openapi.vcs.impl; + +import com.intellij.openapi.project.Project; +import com.intellij.openapi.vcs.ProjectLevelVcsManager; +import org.jetbrains.annotations.CalledInAwt; +import org.jetbrains.annotations.NotNull; + +public class BackgroundableActionLock { + @NotNull private final Project myProject; + @NotNull private final Object[] myKeys; + + BackgroundableActionLock(@NotNull Project project, @NotNull final Object[] keys) { + myProject = project; + myKeys = keys; + } + + @CalledInAwt + public boolean isLocked() { + return isLocked(myProject, myKeys); + } + + @CalledInAwt + public void lock() { + lock(myProject, myKeys); + } + + @CalledInAwt + public void unlock() { + unlock(myProject, myKeys); + } + + + @NotNull + public static BackgroundableActionLock getLock(@NotNull Project project, @NotNull Object... keys) { + return new BackgroundableActionLock(project, keys); + } + + @CalledInAwt + public static boolean isLocked(@NotNull Project project, @NotNull Object... keys) { + return getManager(project).isBackgroundTaskRunning(keys); + } + + @CalledInAwt + public static void lock(@NotNull Project project, @NotNull Object... keys) { + getManager(project).startBackgroundTask(keys); + } + + @CalledInAwt + public static void unlock(@NotNull Project project, @NotNull Object... keys) { + getManager(project).stopBackgroundTask(keys); + } + + @NotNull + private static ProjectLevelVcsManagerImpl getManager(@NotNull Project project) { + return (ProjectLevelVcsManagerImpl)ProjectLevelVcsManager.getInstance(project); + } +} diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/ProjectLevelVcsManagerImpl.java b/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/ProjectLevelVcsManagerImpl.java index 074933c0c45b..280375aa863c 100644 --- a/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/ProjectLevelVcsManagerImpl.java +++ b/platform/vcs-impl/src/com/intellij/openapi/vcs/impl/ProjectLevelVcsManagerImpl.java @@ -70,10 +70,8 @@ import com.intellij.util.text.DateFormatUtil; import org.jdom.Attribute; import org.jdom.DataConversionException; import org.jdom.Element; -import org.jetbrains.annotations.NonNls; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.TestOnly; +import org.jetbrains.annotations.CalledInAwt; +import org.jetbrains.annotations.*; import javax.swing.*; import java.awt.*; @@ -119,7 +117,7 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme private volatile int myBackgroundOperationCounter = 0; - private final Map myBackgroundableActionHandlerMap; + private final Set myBackgroundRunningTasks = ContainerUtil.newHashSet(); private final List> myPendingOutput = ContainerUtil.newArrayList(); @@ -139,7 +137,6 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme myDefaultVcsRootPolicy = DefaultVcsRootPolicy.getInstance(project); - myBackgroundableActionHandlerMap = new EnumMap(VcsBackgroundableActions.class); myInitialization = new VcsInitialization(myProject); myMappings = new NewMappings(myProject, myMessageBus, this, manager); myMappingsToRoots = new MappingsToRoots(myMappings, myProject); @@ -814,15 +811,31 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme return myMappings.haveDefaultMapping(); } + /** + * @deprecated {@link BackgroundableActionLock} + */ + @Deprecated public BackgroundableActionEnabledHandler getBackgroundableActionHandler(final VcsBackgroundableActions action) { ApplicationManager.getApplication().assertIsDispatchThread(); + return new BackgroundableActionEnabledHandler(myProject, action); + } - BackgroundableActionEnabledHandler result = myBackgroundableActionHandlerMap.get(action); - if (result == null) { - result = new BackgroundableActionEnabledHandler(); - myBackgroundableActionHandlerMap.put(action, result); - } - return result; + @CalledInAwt + boolean isBackgroundTaskRunning(@NotNull Object... keys) { + ApplicationManager.getApplication().assertIsDispatchThread(); + return myBackgroundRunningTasks.contains(new ActionKey(keys)); + } + + @CalledInAwt + void startBackgroundTask(@NotNull Object... keys) { + ApplicationManager.getApplication().assertIsDispatchThread(); + LOG.assertTrue(myBackgroundRunningTasks.add(new ActionKey(keys))); + } + + @CalledInAwt + void stopBackgroundTask(@NotNull Object... keys) { + ApplicationManager.getApplication().assertIsDispatchThread(); + LOG.assertTrue(myBackgroundRunningTasks.remove(new ActionKey(keys))); } public void addInitializationRequest(final VcsInitObject vcsInitObject, final Runnable runnable) { @@ -909,4 +922,28 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme public void waitForInitialized() { myInitialization.waitForInitialized(); } + + private static class ActionKey { + private final Object[] myObjects; + + public ActionKey(@NotNull Object... objects) { + myObjects = objects; + } + + @Override + public final boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + return Arrays.equals(myObjects, ((ActionKey)o).myObjects); + } + + @Override + public final int hashCode() { + return Arrays.hashCode(myObjects); + } + + @Override + public String toString() { + return getClass() + " - " + Arrays.toString(myObjects); + } + } }