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

[vcs-log] code issues: rename isEdgeDown/isEdgeUp and a bunch of toUp and toDown variables

Browse Source
This commit is contained in:
Julia Beliaeva
2015-02-02 16:45:53 +03:00
parent 88e5aef639
commit dc5cdd12ee
8 changed files with 31 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
platform/vcs-log/graph/src/com/intellij/vcs/log/graph/api/LiteLinearGraph.java
+2 -2
View File
@@ -45,8 +45,8 @@ public interface LiteLinearGraph {
this.edgeFilter = edgeFilter;
}
public static NodeFilter filter(boolean toUp) {
return toUp ? UP : DOWN;
public static NodeFilter filter(boolean isUp) {
return isUp ? UP : DOWN;
}
}
}
platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/DottedFilterEdgesGenerator.java
+8 -8
View File
@@ -57,8 +57,8 @@ public class DottedFilterEdgesGenerator {
myModification.createEdge(new GraphEdge(nodeIndex1, nodeIndex2, null, DOTTED));
}
private void addDottedArrow(int nodeIndex, boolean toUp) {
myModification.createEdge(new GraphEdge(nodeIndex, null, null, toUp ? DOTTED_ARROW_UP : DOTTED_ARROW_DOWN));
private void addDottedArrow(int nodeIndex, boolean isUp) {
myModification.createEdge(new GraphEdge(nodeIndex, null, null, isUp ? DOTTED_ARROW_UP : DOTTED_ARROW_DOWN));
}
// update specified range
@@ -67,23 +67,23 @@ public class DottedFilterEdgesGenerator {
upWalk();
}
private boolean hasDottedEdges(int nodeIndex, boolean toUp) {
private boolean hasDottedEdges(int nodeIndex, boolean isUp) {
for (GraphEdge edge : myModification.getEdgesToAdd().getAdjacentEdges(nodeIndex, EdgeFilter.NORMAL_ALL)) {
if (edge.getType() == DOTTED) {
if (toUp && LinearGraphUtils.isEdgeToUp(edge, nodeIndex)) return true;
if (!toUp && LinearGraphUtils.isEdgeToDown(edge, nodeIndex)) return false;
if (isUp && LinearGraphUtils.isEdgeUp(edge, nodeIndex)) return true;
if (!isUp && LinearGraphUtils.isEdgeDown(edge, nodeIndex)) return false;
}
}
return false;
}
private void addEdgeOrArrow(int currentNodeIndex, int anotherNodeIndex, boolean toUp) {
if (hasDottedEdges(currentNodeIndex, toUp)) {
private void addEdgeOrArrow(int currentNodeIndex, int anotherNodeIndex, boolean isUp) {
if (hasDottedEdges(currentNodeIndex, isUp)) {
if (nodeIsVisible(anotherNodeIndex)) {
addDottedEdge(currentNodeIndex, anotherNodeIndex);
}
else {
addDottedArrow(currentNodeIndex, toUp);
addDottedArrow(currentNodeIndex, isUp);
}
}
}
platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/FragmentGenerator.java
+8 -8
View File
@@ -86,10 +86,10 @@ public class FragmentGenerator {
}
@Nullable
public Integer getNearRedNode(int startNode, int maxWalkSize, boolean toUp) {
public Integer getNearRedNode(int startNode, int maxWalkSize, boolean isUp) {
if (myRedNodes.value(startNode)) return startNode;
TreeSetNodeIterator walker = new TreeSetNodeIterator(startNode, toUp);
TreeSetNodeIterator walker = new TreeSetNodeIterator(startNode, isUp);
while (walker.notEmpty()) {
Integer next = walker.pop();
@@ -98,7 +98,7 @@ public class FragmentGenerator {
if (maxWalkSize < 0) return null;
maxWalkSize--;
walker.addAll(getNodes(next, toUp));
walker.addAll(getNodes(next, isUp));
}
return null;
@@ -126,15 +126,15 @@ public class FragmentGenerator {
}
@NotNull
private Set<Integer> getWalkNodes(int startNode, boolean toUp, Condition<Integer> stopFunction) {
private Set<Integer> getWalkNodes(int startNode, boolean isUp, Condition<Integer> stopFunction) {
Set<Integer> walkNodes = new HashSet<Integer>();
TreeSetNodeIterator walker = new TreeSetNodeIterator(startNode, toUp);
TreeSetNodeIterator walker = new TreeSetNodeIterator(startNode, isUp);
while (walker.notEmpty()) {
Integer next = walker.pop();
if (!stopFunction.value(next)) {
walkNodes.add(next);
walker.addAll(getNodes(next, toUp));
walker.addAll(getNodes(next, isUp));
}
}
@@ -142,8 +142,8 @@ public class FragmentGenerator {
}
@NotNull
private List<Integer> getNodes(int nodeIndex, boolean toUp) {
return myGraph.getNodes(nodeIndex, LiteLinearGraph.NodeFilter.filter(toUp));
private List<Integer> getNodes(int nodeIndex, boolean isUp) {
return myGraph.getNodes(nodeIndex, LiteLinearGraph.NodeFilter.filter(isUp));
}
@NotNull
platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/TreeSetNodeIterator.java
+2 -2
View File
@@ -25,11 +25,11 @@ import java.util.TreeSet;
class TreeSetNodeIterator {
private final SortedSet<Integer> myWalkNodes;
TreeSetNodeIterator(int startNode, final boolean toUp) {
TreeSetNodeIterator(int startNode, final boolean isUp) {
myWalkNodes = new TreeSet<Integer>(new Comparator<Integer>() {
@Override
public int compare(@NotNull Integer o1, @NotNull Integer o2) {
if (toUp)
if (isUp)
return o2 - o1;
return o1 - o2;
}
platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/print/PrintElementGeneratorImpl.java
+3 -3
View File
@@ -104,7 +104,7 @@ public class PrintElementGeneratorImpl extends AbstractPrintElementGenerator {
if (element instanceof GraphNode) {
int nodeIndex = ((GraphNode)element).getNodeIndex();
for (GraphEdge edge : myLinearGraph.getAdjacentEdges(nodeIndex, EdgeFilter.ALL)) {
if (isEdgeToDown(edge, nodeIndex)) {
if (isEdgeDown(edge, nodeIndex)) {
Integer endPos = endPosition.fun(edge);
if (endPos != null) result.add(new ShortEdge(edge, startPosition, endPos));
}
@@ -224,13 +224,13 @@ public class PrintElementGeneratorImpl extends AbstractPrintElementGenerator {
if (rowIndex > 0) {
for (GraphEdge edge : myLinearGraph.getAdjacentEdges(rowIndex - 1, EdgeFilter.SPECIAL)) {
assert !edge.getType().isNormalEdge();
if (isEdgeToDown(edge, rowIndex - 1)) result.add(edge);
if (isEdgeDown(edge, rowIndex - 1)) result.add(edge);
}
}
if (rowIndex < myLinearGraph.nodesCount() - 1) {
for (GraphEdge edge : myLinearGraph.getAdjacentEdges(rowIndex + 1, EdgeFilter.SPECIAL)) {
assert !edge.getType().isNormalEdge();
if (isEdgeToUp(edge, rowIndex + 1)) result.add(edge);
if (isEdgeUp(edge, rowIndex + 1)) result.add(edge);
}
}
}
platform/vcs-log/graph/src/com/intellij/vcs/log/graph/linearBek/LinearBekGraph.java
+1 -1
View File
@@ -103,7 +103,7 @@ public class LinearBekGraph implements LinearGraph {
List<GraphEdge> downDottedEdges = ContainerUtil.filter(hiddenDotted, new Condition<GraphEdge>() {
@Override
public boolean value(GraphEdge graphEdge) {
return LinearGraphUtils.isEdgeToDown(graphEdge, tail);
return LinearGraphUtils.isEdgeDown(graphEdge, tail);
}
});
platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/LinearGraphUtils.java
+5 -5
View File
@@ -40,11 +40,11 @@ public class LinearGraphUtils {
return value != null && value == number;
}
public static boolean isEdgeToUp(@NotNull GraphEdge edge, int nodeIndex) {
public static boolean isEdgeUp(@NotNull GraphEdge edge, int nodeIndex) {
return intEqual(edge.getDownNodeIndex(), nodeIndex);
}
public static boolean isEdgeToDown(@NotNull GraphEdge edge, int nodeIndex) {
public static boolean isEdgeDown(@NotNull GraphEdge edge, int nodeIndex) {
return intEqual(edge.getUpNodeIndex(), nodeIndex);
}
@@ -100,7 +100,7 @@ public class LinearGraphUtils {
@Nullable
@Override
public Integer fun(GraphEdge graphEdge) {
if (isEdgeToDown(graphEdge, nodeIndex)) {
if (isEdgeDown(graphEdge, nodeIndex)) {
if (graphEdge.getType() == GraphEdgeType.NOT_LOAD_COMMIT)
return graphEdge.getTargetId();
return graphEdge.getDownNodeIndex();
@@ -124,8 +124,8 @@ public class LinearGraphUtils {
return ContainerUtil.mapNotNull(graph.getAdjacentEdges(nodeIndex, filter.edgeFilter), new Function<GraphEdge, Integer>() {
@Override
public Integer fun(GraphEdge edge) {
if (isEdgeToUp(edge, nodeIndex)) return edge.getUpNodeIndex();
if (isEdgeToDown(edge, nodeIndex)) return edge.getDownNodeIndex();
if (isEdgeUp(edge, nodeIndex)) return edge.getUpNodeIndex();
if (isEdgeDown(edge, nodeIndex)) return edge.getDownNodeIndex();
return null;
}
platform/vcs-log/graph/test/com/intellij/vcs/log/graph/TestGraphBuilder.kt
+2 -2
View File
@@ -130,8 +130,8 @@ class TestGraphBuilder: BaseTestGraphBuilder {
override fun getAdjacentEdges(nodeIndex: Int, filter: EdgeFilter)
= edges[nodeIndex].filter {
if (it.getType().isNormalEdge()) {
(LinearGraphUtils.isEdgeToUp(it, nodeIndex) && filter.upNormal)
|| (LinearGraphUtils.isEdgeToDown(it, nodeIndex) && filter.downNormal)
(LinearGraphUtils.isEdgeUp(it, nodeIndex) && filter.upNormal)
|| (LinearGraphUtils.isEdgeDown(it, nodeIndex) && filter.downNormal)
} else {
filter.special
}