diff --git a/platform/vcs-log/graph-api/src/com/intellij/vcs/log/graph/PermanentGraph.java b/platform/vcs-log/graph-api/src/com/intellij/vcs/log/graph/PermanentGraph.java index f0687a59a1aa..7dca4161d1d3 100644 --- a/platform/vcs-log/graph-api/src/com/intellij/vcs/log/graph/PermanentGraph.java +++ b/platform/vcs-log/graph-api/src/com/intellij/vcs/log/graph/PermanentGraph.java @@ -19,6 +19,7 @@ import com.intellij.openapi.util.Condition; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.Collection; import java.util.List; import java.util.Set; @@ -46,7 +47,7 @@ public interface PermanentGraph { Set getContainingBranches(@NotNull CommitId commit); @NotNull - Condition getContainedInBranchCondition(@NotNull CommitId currentBranchHead); + Condition getContainedInBranchCondition(@NotNull Collection currentBranchHead); enum SortType { Normal("Off", "Sort commits topologically and by date"), diff --git a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/BranchFilterController.java b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/BranchFilterController.java index 66c2091ae905..87b51534e47e 100644 --- a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/BranchFilterController.java +++ b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/BranchFilterController.java @@ -19,6 +19,7 @@ import com.intellij.vcs.log.graph.api.LinearGraph; import com.intellij.vcs.log.graph.api.elements.GraphElement; import com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo; import com.intellij.vcs.log.graph.impl.facade.CascadeController; +import com.intellij.vcs.log.graph.impl.facade.ReachableNodes; import com.intellij.vcs.log.graph.utils.UnsignedBitSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -39,7 +40,7 @@ public class BranchFilterController extends CascadeController { private void updateCollapsedGraph() { UnsignedBitSet initVisibility = - BranchMatchedNodesGenerator.generateVisibleNodes(myPermanentGraphInfo.getPermanentLinearGraph(), myIdsOfVisibleBranches); + ReachableNodes.getReachableNodes(myPermanentGraphInfo.getPermanentLinearGraph(), myIdsOfVisibleBranches); myCollapsedGraph = CollapsedGraph.newInstance(getDelegateController().getCompiledGraph(), initVisibility); } diff --git a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/BranchMatchedNodesGenerator.java b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/BranchMatchedNodesGenerator.java deleted file mode 100644 index ddda184ff7b7..000000000000 --- a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/BranchMatchedNodesGenerator.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * 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.vcs.log.graph.collapsing; - -import com.intellij.vcs.log.graph.api.LiteLinearGraph; -import com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphImpl; -import com.intellij.vcs.log.graph.utils.DfsUtil; -import com.intellij.vcs.log.graph.utils.LinearGraphUtils; -import com.intellij.vcs.log.graph.utils.UnsignedBitSet; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.util.Set; - -public class BranchMatchedNodesGenerator { - - @NotNull - public static UnsignedBitSet generateVisibleNodes(@NotNull PermanentLinearGraphImpl permanentGraph, - @Nullable Set headNodeIndexes) { - if (headNodeIndexes == null) { - UnsignedBitSet nodesVisibility = new UnsignedBitSet(); - nodesVisibility.set(0, permanentGraph.nodesCount() - 1, true); - return nodesVisibility; - } - - assert !headNodeIndexes.isEmpty(); - BranchMatchedNodesGenerator generator = new BranchMatchedNodesGenerator(LinearGraphUtils.asLiteLinearGraph(permanentGraph)); - generator.generate(headNodeIndexes); - return generator.myNodesVisibility; - } - - @NotNull private final LiteLinearGraph myGraph; - - @NotNull private final UnsignedBitSet myNodesVisibility; - - @NotNull private final DfsUtil myDfsUtil = new DfsUtil(); - - BranchMatchedNodesGenerator(@NotNull LiteLinearGraph graph) { - myGraph = graph; - myNodesVisibility = new UnsignedBitSet(); - } - - private void generate(@NotNull Set startedNodes) { - for (int startNode : startedNodes) { - myNodesVisibility.set(startNode, true); - if (startNode < 0) continue; - myDfsUtil.nodeDfsIterator(startNode, new DfsUtil.NextNode() { - @Override - public int fun(int currentNode) { - for (int downNode : myGraph.getNodes(currentNode, LiteLinearGraph.NodeFilter.DOWN)) { - if (!myNodesVisibility.get(downNode)) { - myNodesVisibility.set(downNode, true); - return downNode; - } - } - return NODE_NOT_FOUND; - } - }); - } - } -} diff --git a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/CollapsedController.java b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/CollapsedController.java index a966b6805313..cbc01ba0e0cc 100644 --- a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/CollapsedController.java +++ b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/CollapsedController.java @@ -23,6 +23,7 @@ import com.intellij.vcs.log.graph.api.elements.GraphNode; import com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo; import com.intellij.vcs.log.graph.impl.facade.CascadeController; import com.intellij.vcs.log.graph.impl.facade.GraphChanges; +import com.intellij.vcs.log.graph.impl.facade.ReachableNodes; import com.intellij.vcs.log.graph.utils.UnsignedBitSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -37,7 +38,7 @@ public class CollapsedController extends CascadeController { @Nullable Set IdsOfVisibleBranches) { super(delegateLinearGraphController, permanentGraphInfo); UnsignedBitSet initVisibility = - BranchMatchedNodesGenerator.generateVisibleNodes(permanentGraphInfo.getPermanentLinearGraph(), IdsOfVisibleBranches); + ReachableNodes.getReachableNodes(permanentGraphInfo.getPermanentLinearGraph(), IdsOfVisibleBranches); myCollapsedGraph = CollapsedGraph.newInstance(getDelegateController().getCompiledGraph(), initVisibility); } diff --git a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/ContainingBranchesGetter.java b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/ContainingBranchesGetter.java deleted file mode 100644 index 5f5a1f0d78f4..000000000000 --- a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/ContainingBranchesGetter.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright 2000-2014 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.vcs.log.graph.impl.facade; - -import com.intellij.util.Consumer; -import com.intellij.vcs.log.graph.api.LiteLinearGraph; -import com.intellij.vcs.log.graph.utils.DfsUtil; -import com.intellij.vcs.log.graph.utils.Flags; -import com.intellij.vcs.log.graph.utils.impl.BitSetFlags; -import org.jetbrains.annotations.NotNull; - -import java.util.HashSet; -import java.util.Set; - -public class ContainingBranchesGetter { - @NotNull private final LiteLinearGraph myGraph; - - @NotNull private final Set myBranchNodeIndexes; - - @NotNull private final DfsUtil myDfsUtil = new DfsUtil(); - - @NotNull private final Flags myTempFlags; - - public ContainingBranchesGetter(@NotNull LiteLinearGraph graph, @NotNull Set branchNodeIndexes) { - myGraph = graph; - myBranchNodeIndexes = branchNodeIndexes; - myTempFlags = new BitSetFlags(graph.nodesCount()); - } - - public Set getBranchNodeIndexes(int nodeIndex) { - final Set result = new HashSet(); - - myTempFlags.setAll(false); - myTempFlags.set(nodeIndex, true); - checkAndAdd(nodeIndex, result); - myDfsUtil.nodeDfsIterator(nodeIndex, new DfsUtil.NextNode() { - @Override - public int fun(int currentNode) { - for (int upNode : myGraph.getNodes(currentNode, LiteLinearGraph.NodeFilter.UP)) { - if (!myTempFlags.get(upNode)) { - myTempFlags.set(upNode, true); - checkAndAdd(upNode, result); - return upNode; - } - } - - return NODE_NOT_FOUND; - } - }); - - return result; - } - - private void checkAndAdd(int nodeIndex, Set result) { - if (myBranchNodeIndexes.contains(nodeIndex)) result.add(nodeIndex); - } - - public void walkBranch(int branchHead, @NotNull final Consumer consumer) { - myTempFlags.setAll(false); - myTempFlags.set(branchHead, true); - consumer.consume(branchHead); - - myDfsUtil.nodeDfsIterator(branchHead, new DfsUtil.NextNode() { - @Override - public int fun(int currentNode) { - for (int downNode : myGraph.getNodes(currentNode, LiteLinearGraph.NodeFilter.DOWN)) { - if (!myTempFlags.get(downNode)) { - myTempFlags.set(downNode, true); - consumer.consume(downNode); - return downNode; - } - } - - return NODE_NOT_FOUND; - } - }); - } -} diff --git a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/PermanentGraphImpl.java b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/PermanentGraphImpl.java index ad92f65a797b..2175c2029187 100644 --- a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/PermanentGraphImpl.java +++ b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/PermanentGraphImpl.java @@ -19,6 +19,7 @@ package com.intellij.vcs.log.graph.impl.facade; import com.intellij.openapi.util.Condition; import com.intellij.util.Consumer; +import com.intellij.util.Function; import com.intellij.util.NotNullFunction; import com.intellij.util.containers.ContainerUtil; import com.intellij.vcs.log.graph.*; @@ -34,10 +35,7 @@ import gnu.trove.TIntHashSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.Comparator; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; public class PermanentGraphImpl implements PermanentGraph, PermanentGraphInfo { @@ -79,7 +77,7 @@ public class PermanentGraphImpl implements PermanentGraph, P @NotNull private final GraphColorManager myGraphColorManager; @NotNull private final Set myBranchesCommitId; @NotNull private final Set myBranchNodeIds; - @NotNull private final ContainingBranchesGetter myBranchesGetter; + @NotNull private final ReachableNodes myReachableNodes; @NotNull private final BekIntMap myBekIntMap; public PermanentGraphImpl(@NotNull PermanentLinearGraphImpl permanentLinearGraph, @@ -93,7 +91,7 @@ public class PermanentGraphImpl implements PermanentGraph, P myGraphColorManager = graphColorManager; myBranchesCommitId = branchesCommitId; myBranchNodeIds = permanentCommitsInfo.convertToNodeIds(branchesCommitId); - myBranchesGetter = new ContainingBranchesGetter(LinearGraphUtils.asLiteLinearGraph(permanentLinearGraph), myBranchNodeIds); + myReachableNodes = new ReachableNodes(LinearGraphUtils.asLiteLinearGraph(permanentLinearGraph)); myBekIntMap = BekSorter.createBekMap(myPermanentLinearGraph, myPermanentGraphLayout, myPermanentCommitsInfo.getTimestampGetter()); } @@ -163,15 +161,21 @@ public class PermanentGraphImpl implements PermanentGraph, P @Override public Set getContainingBranches(@NotNull CommitId commit) { int commitIndex = myPermanentCommitsInfo.getNodeId(commit); - return myPermanentCommitsInfo.convertToCommitIdSet(myBranchesGetter.getBranchNodeIndexes(commitIndex)); + return myPermanentCommitsInfo.convertToCommitIdSet(myReachableNodes.getContainingBranches(commitIndex, myBranchNodeIds)); } @NotNull @Override - public Condition getContainedInBranchCondition(@NotNull final CommitId head) { - if (head instanceof Integer) { + public Condition getContainedInBranchCondition(@NotNull final Collection heads) { + List headIds = ContainerUtil.map(heads, new Function() { + @Override + public Integer fun(CommitId head) { + return myPermanentCommitsInfo.getNodeId(head); + } + }); + if (!heads.isEmpty() && ContainerUtil.getFirstItem(heads) instanceof Integer) { final TIntHashSet branchNodes = new TIntHashSet(); - myBranchesGetter.walkBranch(myPermanentCommitsInfo.getNodeId(head), new Consumer() { + myReachableNodes.walk(headIds, new Consumer() { @Override public void consume(Integer node) { branchNodes.add((Integer)myPermanentCommitsInfo.getCommitId(node)); @@ -186,7 +190,7 @@ public class PermanentGraphImpl implements PermanentGraph, P } else { final Set branchNodes = ContainerUtil.newHashSet(); - myBranchesGetter.walkBranch(myPermanentCommitsInfo.getNodeId(head), new Consumer() { + myReachableNodes.walk(headIds, new Consumer() { @Override public void consume(Integer node) { branchNodes.add(myPermanentCommitsInfo.getCommitId(node)); diff --git a/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/ReachableNodes.java b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/ReachableNodes.java new file mode 100644 index 000000000000..5fa3548ba8b9 --- /dev/null +++ b/platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/ReachableNodes.java @@ -0,0 +1,111 @@ +/* + * Copyright 2000-2014 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.vcs.log.graph.impl.facade; + +import com.intellij.util.Consumer; +import com.intellij.vcs.log.graph.api.LiteLinearGraph; +import com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphImpl; +import com.intellij.vcs.log.graph.utils.DfsUtil; +import com.intellij.vcs.log.graph.utils.Flags; +import com.intellij.vcs.log.graph.utils.LinearGraphUtils; +import com.intellij.vcs.log.graph.utils.UnsignedBitSet; +import com.intellij.vcs.log.graph.utils.impl.BitSetFlags; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +public class ReachableNodes { + @NotNull private final LiteLinearGraph myGraph; + @NotNull private final DfsUtil myDfsUtil = new DfsUtil(); + @NotNull private final Flags myTempFlags; + + public ReachableNodes(@NotNull LiteLinearGraph graph) { + myGraph = graph; + myTempFlags = new BitSetFlags(graph.nodesCount()); + } + + @NotNull + public static UnsignedBitSet getReachableNodes(@NotNull PermanentLinearGraphImpl permanentGraph, @Nullable Set headNodeIndexes) { + if (headNodeIndexes == null) { + UnsignedBitSet nodesVisibility = new UnsignedBitSet(); + nodesVisibility.set(0, permanentGraph.nodesCount() - 1, true); + return nodesVisibility; + } + + assert !headNodeIndexes.isEmpty(); + + final UnsignedBitSet result = new UnsignedBitSet(); + ReachableNodes getter = new ReachableNodes(LinearGraphUtils.asLiteLinearGraph(permanentGraph)); + getter.walk(headNodeIndexes, new Consumer() { + @Override + public void consume(Integer node) { + result.set(node, true); + } + }); + + return result; + } + + public Set getContainingBranches(int nodeIndex, @NotNull final Collection branchNodeIndexes) { + final Set result = new HashSet(); + + walk(Collections.singletonList(nodeIndex), false, new Consumer() { + @Override + public void consume(Integer integer) { + if (branchNodeIndexes.contains(integer)) result.add(integer); + } + }); + + return result; + } + + public void walk(@NotNull Collection headIds, @NotNull final Consumer consumer) { + walk(headIds, true, consumer); + } + + public void walk(@NotNull Collection startNodes, final boolean goDown, @NotNull final Consumer consumer) { + synchronized (myTempFlags) { + + myTempFlags.setAll(false); + for (int start : startNodes) { + if (myTempFlags.get(start)) continue; + myTempFlags.set(start, true); + consumer.consume(start); + + myDfsUtil.nodeDfsIterator(start, new DfsUtil.NextNode() { + @Override + public int fun(int currentNode) { + for (int downNode : myGraph.getNodes(currentNode, goDown ? LiteLinearGraph.NodeFilter.DOWN : LiteLinearGraph.NodeFilter.UP)) { + if (!myTempFlags.get(downNode)) { + myTempFlags.set(downNode, true); + consumer.consume(downNode); + return downNode; + } + } + + return NODE_NOT_FOUND; + } + }); + } + + } + } +} diff --git a/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/GraphStrUtils.java b/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/GraphStrUtils.java index 60cbf6e53d06..652a28f4de2b 100644 --- a/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/GraphStrUtils.java +++ b/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/GraphStrUtils.java @@ -23,7 +23,7 @@ import com.intellij.vcs.log.graph.api.GraphLayout; import com.intellij.vcs.log.graph.api.elements.GraphEdge; import com.intellij.vcs.log.graph.api.elements.GraphElement; import com.intellij.vcs.log.graph.api.permanent.PermanentCommitsInfo; -import com.intellij.vcs.log.graph.impl.facade.ContainingBranchesGetter; +import com.intellij.vcs.log.graph.impl.facade.ReachableNodes; import com.intellij.vcs.log.graph.impl.print.EdgesInRowGenerator; import com.intellij.vcs.log.graph.impl.print.GraphElementComparatorByLayoutIndex; import com.intellij.vcs.log.graph.parser.CommitParser; @@ -70,12 +70,12 @@ public class GraphStrUtils { return s.toString(); } - public static String containingBranchesGetterToStr(ContainingBranchesGetter containingBranchesGetter, int nodesCount) { + public static String containingBranchesGetterToStr(ReachableNodes reachableNodes, Set branches, int nodesCount) { StringBuilder s = new StringBuilder(); for (int nodeIndex = 0; nodeIndex < nodesCount; nodeIndex++) { if (nodeIndex != 0) s.append("\n"); - List branchNodeIndexes = new ArrayList(containingBranchesGetter.getBranchNodeIndexes(nodeIndex)); + List branchNodeIndexes = new ArrayList(reachableNodes.getContainingBranches(nodeIndex, branches)); if (branchNodeIndexes.isEmpty()) { s.append("none"); continue; diff --git a/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/impl/permanent/ContainingBranchesTest.java b/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/impl/permanent/ContainingBranchesTest.java index c8999515b315..21d34f2427bf 100644 --- a/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/impl/permanent/ContainingBranchesTest.java +++ b/platform/vcs-log/graph/test/com/intellij/vcs/log/graph/impl/permanent/ContainingBranchesTest.java @@ -20,7 +20,7 @@ import com.intellij.vcs.log.graph.AbstractTestWithTwoTextFile; import com.intellij.vcs.log.graph.GraphCommit; import com.intellij.vcs.log.graph.api.LinearGraph; import com.intellij.vcs.log.graph.impl.CommitIdManager; -import com.intellij.vcs.log.graph.impl.facade.ContainingBranchesGetter; +import com.intellij.vcs.log.graph.impl.facade.ReachableNodes; import com.intellij.vcs.log.graph.utils.LinearGraphUtils; import org.junit.Test; @@ -53,10 +53,11 @@ public abstract class ContainingBranchesTest extends AbstractTestWithT List> commits = getCommitIdManager().parseCommitList(in.substring(0, i)); LinearGraph graph = PermanentLinearGraphBuilder.newInstance(commits).build(); - ContainingBranchesGetter containingBranchesGetter = - new ContainingBranchesGetter(LinearGraphUtils.asLiteLinearGraph(graph), parseBranchNodeIndex(in.substring(i + SEPARATOR.length()))); + Set branches = parseBranchNodeIndex(in.substring(i + SEPARATOR.length())); + ReachableNodes reachableNodes = + new ReachableNodes(LinearGraphUtils.asLiteLinearGraph(graph)); - assertEquals(out, containingBranchesGetterToStr(containingBranchesGetter, graph.nodesCount())); + assertEquals(out, containingBranchesGetterToStr(reachableNodes, branches, graph.nodesCount())); } protected abstract CommitIdManager getCommitIdManager(); diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/data/ContainingBranchesGetter.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/data/ContainingBranchesGetter.java index dcf38cab09eb..d088191e5c97 100644 --- a/platform/vcs-log/impl/src/com/intellij/vcs/log/data/ContainingBranchesGetter.java +++ b/platform/vcs-log/impl/src/com/intellij/vcs/log/data/ContainingBranchesGetter.java @@ -147,7 +147,8 @@ public class ContainingBranchesGetter implements VcsLogListener { if (branchRef == null) return Conditions.alwaysFalse(); ContainedInBranchCondition condition = myConditions.get(Pair.create(root, branchName)); if (condition == null) { - condition = new ContainedInBranchCondition(myGraph.getContainedInBranchCondition(myDataHolder.getCommitIndex(branchRef.getCommitHash()))); + condition = new ContainedInBranchCondition(myGraph.getContainedInBranchCondition( + Collections.singleton(myDataHolder.getCommitIndex(branchRef.getCommitHash())))); myConditions.put(Pair.create(root, branchName), condition); } return condition; @@ -212,17 +213,17 @@ public class ContainingBranchesGetter implements VcsLogListener { } private class ContainedInBranchCondition implements Condition { - @NotNull private final Condition myChecker; + @NotNull private final Condition myCondition; private volatile boolean isDisposed = false; - public ContainedInBranchCondition(@NotNull Condition checker) { - myChecker = checker; + public ContainedInBranchCondition(@NotNull Condition condition) { + myCondition = condition; } @Override public boolean value(Hash hash) { if (isDisposed) return false; - return myChecker.value(myDataHolder.getCommitIndex(hash)); + return myCondition.value(myDataHolder.getCommitIndex(hash)); } public void dispose() { diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/data/EmptyPermanentGraph.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/data/EmptyPermanentGraph.java index 953e6f9d6835..170dcda0025c 100644 --- a/platform/vcs-log/impl/src/com/intellij/vcs/log/data/EmptyPermanentGraph.java +++ b/platform/vcs-log/impl/src/com/intellij/vcs/log/data/EmptyPermanentGraph.java @@ -23,6 +23,7 @@ import com.intellij.vcs.log.graph.VisibleGraph; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Set; @@ -63,7 +64,7 @@ public class EmptyPermanentGraph implements PermanentGraph { @NotNull @Override - public Condition getContainedInBranchCondition(@NotNull Integer currentBranchHead) { + public Condition getContainedInBranchCondition(@NotNull Collection currentBranchHead) { return Conditions.alwaysFalse(); }