From ca2c6a2ed43cd7702f6c8a86e316351c4e6c0a50 Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Thu, 15 Dec 2016 20:00:09 +0300 Subject: [PATCH] cleanup --- .../ex/PrioritizedDocumentListener.java | 6 +++- .../impl/ConsoleViewRunningState.java | 2 +- .../com/intellij/util/containers/Queue.java | 32 ++++++++++++------- .../intellij/util/containers/SortedList.java | 30 +++++++++-------- 4 files changed, 44 insertions(+), 26 deletions(-) diff --git a/platform/core-impl/src/com/intellij/openapi/editor/ex/PrioritizedDocumentListener.java b/platform/core-impl/src/com/intellij/openapi/editor/ex/PrioritizedDocumentListener.java index 20614b9f9aba..74216cd14397 100644 --- a/platform/core-impl/src/com/intellij/openapi/editor/ex/PrioritizedDocumentListener.java +++ b/platform/core-impl/src/com/intellij/openapi/editor/ex/PrioritizedDocumentListener.java @@ -38,7 +38,11 @@ public interface PrioritizedDocumentListener extends DocumentListener { Comparator COMPARATOR = new Comparator() { @Override public int compare(Object o1, Object o2) { - return getPriority(o1) - getPriority(o2); + return integerCompare(getPriority(o1), getPriority(o2)); + } + + private int integerCompare(int x, int y) { + return x < y ? -1 : x == y ? 0 : 1; } private int getPriority(@NotNull Object o) { diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewRunningState.java b/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewRunningState.java index 85069452feb2..9ade61f9655b 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewRunningState.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewRunningState.java @@ -61,7 +61,7 @@ public class ConsoleViewRunningState extends ConsoleState { // attach to process stdin if (attachToStdIn) { final OutputStream processInput = myProcessHandler.getProcessInput(); - myUserInputWriter = processInput != null ? createOutputStreamWriter(processInput, processHandler) : null; + myUserInputWriter = processInput == null ? null : createOutputStreamWriter(processInput, processHandler); } else { myUserInputWriter = null; diff --git a/platform/util/src/com/intellij/util/containers/Queue.java b/platform/util/src/com/intellij/util/containers/Queue.java index 96630491fbf5..34f131a5b0c9 100644 --- a/platform/util/src/com/intellij/util/containers/Queue.java +++ b/platform/util/src/com/intellij/util/containers/Queue.java @@ -19,6 +19,7 @@ import com.intellij.util.ArrayUtil; import com.intellij.util.Processor; import org.jetbrains.annotations.NotNull; +import java.lang.reflect.Array; import java.util.Arrays; import java.util.List; @@ -70,14 +71,26 @@ public class Queue { return isWrapped ? myArray.length - myFirst + myLast : myLast - myFirst; } + @NotNull public List toList() { return Arrays.asList(normalize(size())); } + @NotNull public Object[] toArray() { return normalize(size()); } + @NotNull + public T[] toArray(T[] array) { + if (array.length < size()) { + //noinspection unchecked + array = (T[])Array.newInstance(array.getClass().getComponentType(), size()); + } + + return normalize(array); + } + public T pullFirst() { T result = peekFirst(); myArray[myFirst] = null; @@ -103,8 +116,13 @@ public class Queue { return length; } + @NotNull private T[] normalize(int capacity) { @SuppressWarnings("unchecked") T[] result = (T[])new Object[capacity]; + return normalize(result); + } + + private T[] normalize(T[] result) { if (isWrapped) { int tailLength = copyFromTo(myFirst, myArray.length, result, 0); copyFromTo(0, myLast, result, tailLength); @@ -122,17 +140,9 @@ public class Queue { } public T set(int index, T value) { - int arrayIndex; - if (isWrapped) { - if (myFirst + index >= myArray.length) { - arrayIndex = index - myArray.length + myFirst; - } - else { - arrayIndex = myFirst + index; - } - } - else { - arrayIndex = myFirst + index; + int arrayIndex = myFirst + index; + if (isWrapped && arrayIndex >= myArray.length) { + arrayIndex -= myArray.length; } final Object old = myArray[arrayIndex]; myArray[arrayIndex] = value; diff --git a/platform/util/src/com/intellij/util/containers/SortedList.java b/platform/util/src/com/intellij/util/containers/SortedList.java index d09e0de3bbd7..b8550ff83b55 100644 --- a/platform/util/src/com/intellij/util/containers/SortedList.java +++ b/platform/util/src/com/intellij/util/containers/SortedList.java @@ -15,6 +15,9 @@ */ package com.intellij.util.containers; +import com.intellij.util.SmartList; +import org.jetbrains.annotations.NotNull; + import java.util.*; /** @@ -23,26 +26,27 @@ import java.util.*; public class SortedList extends AbstractList{ private final SortedMap> myMap; private final Comparator myComparator; - private List myDelegate = null; + private List myDelegate; - public SortedList(final Comparator comparator) { + public SortedList(@NotNull Comparator comparator) { myComparator = comparator; myMap = new TreeMap>(comparator); } + @NotNull public Comparator getComparator() { return myComparator; } @Override public void add(final int index, final T element) { - _addToMap(element); + addToMap(element); } - private void _addToMap(T element) { + private void addToMap(T element) { List group = myMap.get(element); if (group == null) { - myMap.put(element, group = new ArrayList()); + myMap.put(element, group = new SmartList()); } group.add(element); myDelegate = null; @@ -50,7 +54,7 @@ public class SortedList extends AbstractList{ @Override public boolean add(T t) { - _addToMap(t); + addToMap(t); return true; } @@ -76,15 +80,16 @@ public class SortedList extends AbstractList{ @Override public T get(final int index) { - ensureLinearized(); - return myDelegate.get(index); + return ensureLinearized().get(index); } + @NotNull private List ensureLinearized() { - if (myDelegate == null) { - myDelegate = ContainerUtil.concat(myMap.values()); + List delegate = myDelegate; + if (delegate == null) { + myDelegate = delegate = ContainerUtil.concat(myMap.values()); } - return myDelegate; + return delegate; } @Override @@ -100,7 +105,6 @@ public class SortedList extends AbstractList{ @Override public int size() { - ensureLinearized(); - return myDelegate.size(); + return ensureLinearized().size(); } }