From c122a4ceb82f4b42bef9cef9e3e310fa259e08e9 Mon Sep 17 00:00:00 2001 From: Konstantin Kolosovsky Date: Fri, 14 Jun 2019 22:33:19 +0300 Subject: [PATCH] vcs: Convert "PartiallyExcludedFilesStateHolder" to kotlin GitOrigin-RevId: 42fa1db97d081f733595017055ab27c8efac22c6 --- .../ui/PartiallyExcludedFilesStateHolder.kt | 278 ++++++------------ .../vcs/commit/PartialCommitInclusionModel.kt | 5 +- .../vcs/BasePartiallyExcludedChangesTest.kt | 5 +- 3 files changed, 93 insertions(+), 195 deletions(-) diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/PartiallyExcludedFilesStateHolder.kt b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/PartiallyExcludedFilesStateHolder.kt index 0287fc730e06..53f6ca5a0e8c 100644 --- a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/PartiallyExcludedFilesStateHolder.kt +++ b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/PartiallyExcludedFilesStateHolder.kt @@ -1,231 +1,131 @@ // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. -package com.intellij.openapi.vcs.changes.ui; +package com.intellij.openapi.vcs.changes.ui -import com.intellij.openapi.Disposable; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Pair; -import com.intellij.openapi.vcs.ex.ExclusionState; -import com.intellij.openapi.vcs.ex.LineStatusTracker; -import com.intellij.openapi.vcs.ex.PartialLocalLineStatusTracker; -import com.intellij.openapi.vcs.impl.LineStatusTrackerManager; -import com.intellij.util.ui.update.MergingUpdateQueue; -import com.intellij.util.ui.update.Update; -import gnu.trove.THashSet; -import org.jetbrains.annotations.CalledInAwt; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; +import com.intellij.openapi.Disposable +import com.intellij.openapi.project.Project +import com.intellij.openapi.vcs.ex.ExclusionState +import com.intellij.openapi.vcs.ex.LineStatusTracker +import com.intellij.openapi.vcs.ex.PartialLocalLineStatusTracker +import com.intellij.openapi.vcs.impl.LineStatusTrackerManager +import com.intellij.util.ui.update.MergingUpdateQueue +import com.intellij.util.ui.update.Update +import gnu.trove.THashSet +import org.jetbrains.annotations.CalledInAwt +import java.util.* -import java.util.*; -import java.util.stream.Stream; +abstract class PartiallyExcludedFilesStateHolder(project: Project, private var myChangelistId: String) : Disposable { + protected val myUpdateQueue = + MergingUpdateQueue(PartiallyExcludedFilesStateHolder::class.java.name, 300, true, MergingUpdateQueue.ANY_COMPONENT, this) -public abstract class PartiallyExcludedFilesStateHolder implements Disposable { - @NotNull protected final MergingUpdateQueue myUpdateQueue = - new MergingUpdateQueue(PartiallyExcludedFilesStateHolder.class.getName(), 300, true, MergingUpdateQueue.ANY_COMPONENT, this); + private val myIncludedElements = THashSet() + private val myTrackerExclusionStates = HashMap() - private final Set myIncludedElements = new THashSet<>(); - private final Map myTrackerExclusionStates = new HashMap<>(); - - @NotNull private String myChangelistId; - - public PartiallyExcludedFilesStateHolder(@NotNull Project project, @NotNull String changelistId) { - myChangelistId = changelistId; - - PartialLocalLineStatusTracker.Listener trackerListener = new MyTrackerListener(); - MyTrackerManagerListener trackerManagerListener = new MyTrackerManagerListener(trackerListener, this); - trackerManagerListener.install(project); + init { + MyTrackerManagerListener().install(project) } - @Override - public void dispose() { - } + override fun dispose() = Unit + protected abstract val trackableElements: Sequence + protected abstract fun findElementFor(tracker: PartialLocalLineStatusTracker): T? + protected abstract fun findTrackerFor(element: T): PartialLocalLineStatusTracker? - @NotNull - protected abstract Stream getTrackableElementsStream(); + private val trackers + get() = trackableElements.mapNotNull { element -> findTrackerFor(element)?.let { tracker -> element to tracker } } - @Nullable - protected abstract T findElementFor(@NotNull PartialLocalLineStatusTracker tracker); - - @Nullable - protected abstract PartialLocalLineStatusTracker findTrackerFor(@NotNull T element); - - @NotNull - private Stream> getTrackersStream() { - return getTrackableElementsStream().>map(element -> { - PartialLocalLineStatusTracker tracker = findTrackerFor(element); - if (tracker != null) { - return Pair.create(element, tracker); - } - else { - return null; - } - }).filter(Objects::nonNull); - } - - - public void setChangelistId(@NotNull String changelistId) { - myChangelistId = changelistId; - updateExclusionStates(); + fun setChangelistId(changelistId: String) { + myChangelistId = changelistId + updateExclusionStates() } @CalledInAwt - public void updateExclusionStates() { - myTrackerExclusionStates.clear(); + open fun updateExclusionStates() { + myTrackerExclusionStates.clear() - getTrackersStream().forEach(pair -> { - T element = pair.first; - PartialLocalLineStatusTracker tracker = pair.second; - ExclusionState state = tracker.getExcludedFromCommitState(myChangelistId); - if (state != ExclusionState.NO_CHANGES) myTrackerExclusionStates.put(element, state); - }); - } - - @NotNull - public ExclusionState getExclusionState(@NotNull T element) { - ExclusionState exclusionState = myTrackerExclusionStates.get(element); - if (exclusionState != null) return exclusionState; - return myIncludedElements.contains(element) ? ExclusionState.ALL_INCLUDED - : ExclusionState.ALL_EXCLUDED; - } - - private void scheduleExclusionStatesUpdate() { - myUpdateQueue.queue(new Update("updateExcludedFromCommit") { - @Override - public void run() { - updateExclusionStates(); - } - }); - } - - - private class MyTrackerListener extends PartialLocalLineStatusTracker.ListenerAdapter { - @Override - public void onExcludedFromCommitChange(@NotNull PartialLocalLineStatusTracker tracker) { - scheduleExclusionStatesUpdate(); - } - - @Override - public void onChangeListMarkerChange(@NotNull PartialLocalLineStatusTracker tracker) { - scheduleExclusionStatesUpdate(); + trackers.forEach { (element, tracker) -> + val state = tracker.getExcludedFromCommitState(myChangelistId) + if (state != ExclusionState.NO_CHANGES) myTrackerExclusionStates[element] = state } } - private class MyTrackerManagerListener extends LineStatusTrackerManager.ListenerAdapter { - @NotNull private final PartialLocalLineStatusTracker.Listener myTrackerListener; - @NotNull private final Disposable myDisposable; + fun getExclusionState(element: T): ExclusionState = + myTrackerExclusionStates[element] ?: if (element in myIncludedElements) ExclusionState.ALL_INCLUDED else ExclusionState.ALL_EXCLUDED - MyTrackerManagerListener(@NotNull PartialLocalLineStatusTracker.Listener listener, @NotNull Disposable disposable) { - myTrackerListener = listener; - myDisposable = disposable; - } + private fun scheduleExclusionStatesUpdate() { + myUpdateQueue.queue(Update.create("updateExcludedFromCommit") { updateExclusionStates() }) + } + + private inner class MyTrackerListener : PartialLocalLineStatusTracker.ListenerAdapter() { + override fun onExcludedFromCommitChange(tracker: PartialLocalLineStatusTracker) = scheduleExclusionStatesUpdate() + override fun onChangeListMarkerChange(tracker: PartialLocalLineStatusTracker) = scheduleExclusionStatesUpdate() + } + + private inner class MyTrackerManagerListener : LineStatusTrackerManager.ListenerAdapter() { + private val trackerListener = MyTrackerListener() + private val disposable get() = this@PartiallyExcludedFilesStateHolder @CalledInAwt - public void install(@NotNull Project project) { - LineStatusTrackerManager.getInstanceImpl(project).addTrackerListener(this, myDisposable); - for (LineStatusTracker tracker : LineStatusTrackerManager.getInstanceImpl(project).getTrackers()) { - if (tracker instanceof PartialLocalLineStatusTracker) { - PartialLocalLineStatusTracker partialTracker = (PartialLocalLineStatusTracker)tracker; - - partialTracker.addListener(myTrackerListener, myDisposable); - } + fun install(project: Project) { + with(LineStatusTrackerManager.getInstanceImpl(project)) { + addTrackerListener(this@MyTrackerManagerListener, disposable) + getTrackers().filterIsInstance().forEach { it.addListener(trackerListener, disposable) } } } - @Override - public void onTrackerAdded(@NotNull LineStatusTracker tracker) { - if (tracker instanceof PartialLocalLineStatusTracker) { - PartialLocalLineStatusTracker partialTracker = (PartialLocalLineStatusTracker)tracker; + override fun onTrackerAdded(tracker: LineStatusTracker<*>) { + if (tracker !is PartialLocalLineStatusTracker) return - T element = findElementFor(partialTracker); - if (element != null) { - partialTracker.setExcludedFromCommit(!myIncludedElements.contains(element)); + findElementFor(tracker)?.let { element -> tracker.setExcludedFromCommit(element !in myIncludedElements) } + tracker.addListener(trackerListener, disposable) + } + + override fun onTrackerRemoved(tracker: LineStatusTracker<*>) { + if (tracker !is PartialLocalLineStatusTracker) return + + findElementFor(tracker)?.let { element -> + myTrackerExclusionStates -= element + + val exclusionState = tracker.getExcludedFromCommitState(myChangelistId) + if (exclusionState != ExclusionState.NO_CHANGES) { + if (exclusionState != ExclusionState.ALL_EXCLUDED) myIncludedElements += element else myIncludedElements -= element } - partialTracker.addListener(myTrackerListener, myDisposable); - } - } - - @Override - public void onTrackerRemoved(@NotNull LineStatusTracker tracker) { - if (tracker instanceof PartialLocalLineStatusTracker) { - PartialLocalLineStatusTracker partialTracker = (PartialLocalLineStatusTracker)tracker; - - T element = findElementFor(partialTracker); - if (element != null) { - myTrackerExclusionStates.remove(element); - - ExclusionState exclusionState = partialTracker.getExcludedFromCommitState(myChangelistId); - if (exclusionState != ExclusionState.NO_CHANGES) { - if (exclusionState != ExclusionState.ALL_EXCLUDED) { - myIncludedElements.add(element); - } - else { - myIncludedElements.remove(element); - } - } - - scheduleExclusionStatesUpdate(); - } + scheduleExclusionStatesUpdate() } } } - @NotNull - public Set getIncludedSet() { - HashSet set = new HashSet<>(myIncludedElements); - - for (Map.Entry entry : myTrackerExclusionStates.entrySet()) { - T element = entry.getKey(); - ExclusionState trackerState = entry.getValue(); - - if (trackerState == ExclusionState.ALL_EXCLUDED) { - set.remove(element); - } - else { - set.add(element); - } + fun getIncludedSet(): Set { + val set = HashSet(myIncludedElements) + myTrackerExclusionStates.forEach { (element, state) -> + if (state == ExclusionState.ALL_EXCLUDED) set -= element else set += element } - - return set; + return set } - public void setIncludedElements(@NotNull Collection elements) { - HashSet set = new HashSet<>(elements); - getTrackersStream().forEach(pair -> { - T element = pair.first; - PartialLocalLineStatusTracker tracker = pair.second; - tracker.setExcludedFromCommit(!set.contains(element)); - }); - - myIncludedElements.clear(); - myIncludedElements.addAll(elements); - - updateExclusionStates(); - } - - public void includeElements(@NotNull Collection elements) { - for (T element : elements) { - PartialLocalLineStatusTracker tracker = findTrackerFor(element); - if (tracker != null) { - tracker.setExcludedFromCommit(false); - } + fun setIncludedElements(elements: Collection) { + val set = HashSet(elements) + trackers.forEach { (element, tracker) -> + tracker.setExcludedFromCommit(element !in set) } - myIncludedElements.addAll(elements); + myIncludedElements.clear() + myIncludedElements += elements - updateExclusionStates(); + updateExclusionStates() } - public void excludeElements(@NotNull Collection elements) { - for (T element : elements) { - PartialLocalLineStatusTracker tracker = findTrackerFor(element); - if (tracker != null) { - tracker.setExcludedFromCommit(true); - } - } + fun includeElements(elements: Collection) { + elements.forEach { findTrackerFor(it)?.setExcludedFromCommit(false) } + myIncludedElements += elements - myIncludedElements.removeAll(elements); + updateExclusionStates() + } - updateExclusionStates(); + fun excludeElements(elements: Collection) { + elements.forEach { findTrackerFor(it)?.setExcludedFromCommit(true) } + myIncludedElements -= elements + + updateExclusionStates() } } diff --git a/platform/vcs-impl/src/com/intellij/vcs/commit/PartialCommitInclusionModel.kt b/platform/vcs-impl/src/com/intellij/vcs/commit/PartialCommitInclusionModel.kt index f91808c176b1..6035965a9a30 100644 --- a/platform/vcs-impl/src/com/intellij/vcs/commit/PartialCommitInclusionModel.kt +++ b/platform/vcs-impl/src/com/intellij/vcs/commit/PartialCommitInclusionModel.kt @@ -13,7 +13,6 @@ import com.intellij.openapi.vcs.impl.PartialChangesUtil import com.intellij.openapi.vcs.impl.PartialChangesUtil.convertExclusionState import com.intellij.openapi.vcs.impl.PartialChangesUtil.getPartialTracker import com.intellij.util.ui.ThreeStateCheckBox -import java.util.stream.Stream class PartialCommitInclusionModel( private val project: Project, @@ -32,7 +31,7 @@ class PartialCommitInclusionModel( Disposer.register(this, stateHolder) } - override fun getInclusion(): Set = stateHolder.includedSet + override fun getInclusion(): Set = stateHolder.getIncludedSet() override fun getInclusionState(item: Any): ThreeStateCheckBox.State = convertExclusionState(stateHolder.getExclusionState(item)) override fun isInclusionEmpty(): Boolean = getInclusion().isEmpty() @@ -51,7 +50,7 @@ class PartialCommitInclusionModel( override fun dispose() = Unit private inner class StateHolder : PartiallyExcludedFilesStateHolder(project, changeList.id) { - override fun getTrackableElementsStream(): Stream = changeList.changes.stream() + override val trackableElements: Sequence get() = changeList.changes.asSequence() override fun findElementFor(tracker: PartialLocalLineStatusTracker): Any? = changeList.changes.find { tracker.virtualFile == PartialChangesUtil.getVirtualFile(it) } diff --git a/platform/vcs-tests/testSrc/com/intellij/openapi/vcs/BasePartiallyExcludedChangesTest.kt b/platform/vcs-tests/testSrc/com/intellij/openapi/vcs/BasePartiallyExcludedChangesTest.kt index e3a638861f2a..e03ca104984f 100644 --- a/platform/vcs-tests/testSrc/com/intellij/openapi/vcs/BasePartiallyExcludedChangesTest.kt +++ b/platform/vcs-tests/testSrc/com/intellij/openapi/vcs/BasePartiallyExcludedChangesTest.kt @@ -6,7 +6,6 @@ import com.intellij.openapi.vcs.changes.ui.PartiallyExcludedFilesStateHolder import com.intellij.openapi.vcs.ex.ExclusionState import com.intellij.openapi.vcs.ex.PartialLocalLineStatusTracker import com.intellij.openapi.vcs.impl.PartialChangesUtil -import java.util.stream.Stream abstract class BasePartiallyExcludedChangesTest : BaseLineStatusTrackerManagerTest() { protected lateinit var stateHolder: MyStateHolder @@ -25,7 +24,7 @@ abstract class BasePartiallyExcludedChangesTest : BaseLineStatusTrackerManagerTe Disposer.register(testRootDisposable, this) } - override fun getTrackableElementsStream(): Stream = paths.stream() + override val trackableElements: Sequence get() = paths.asSequence() override fun findElementFor(tracker: PartialLocalLineStatusTracker): FilePath? { return paths.find { it.virtualFile == tracker.virtualFile } @@ -73,7 +72,7 @@ abstract class BasePartiallyExcludedChangesTest : BaseLineStatusTrackerManagerTe protected fun assertIncluded(vararg paths: String) { val expected = paths.toFilePaths().toSet() - val actual = stateHolder.includedSet + val actual = stateHolder.getIncludedSet() assertSameElements(actual.map { it.name }, expected.map { it.name }) assertSameElements(actual, expected) }