Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2008 Google Inc.
*
* 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 java.util;
import static com.google.gwt.core.client.impl.Coercions.ensureInt;
import static com.google.gwt.core.shared.impl.InternalPreconditions.checkArgument;
import static com.google.gwt.core.shared.impl.InternalPreconditions.checkArraySize;
import static com.google.gwt.core.shared.impl.InternalPreconditions.checkElementIndex;
import static com.google.gwt.core.shared.impl.InternalPreconditions.checkPositionIndexes;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.UnsafeNativeLong;
import com.google.gwt.lang.Array;
import java.io.Serializable;
/**
* Utility methods related to native arrays. [Sun
* docs]
*/
public class Arrays {
private static final class ArrayList extends AbstractList implements
RandomAccess, Serializable {
/**
* The only reason this is non-final is so that E[] (and E) will be exposed
* for serialization.
*/
private E[] array;
ArrayList(E[] array) {
assert (array != null);
this.array = array;
}
@Override
public boolean contains(Object o) {
return (indexOf(o) != -1);
}
@Override
public E get(int index) {
checkElementIndex(index, size());
return array[index];
}
@Override
public E set(int index, E value) {
E was = get(index);
array[index] = value;
return was;
}
@Override
public int size() {
return array.length;
}
/*
* Semantics are to return an array of identical type.
*/
@Override
public Object[] toArray() {
return Array.clone(array);
}
/*
* Faster than the iterator-based implementation in AbstractCollection.
*/
@SuppressWarnings("unchecked")
@Override
public T[] toArray(T[] out) {
int size = size();
if (out.length < size) {
out = Array.createFrom(out, size);
}
for (int i = 0; i < size; ++i) {
out[i] = (T) array[i];
}
if (out.length > size) {
out[size] = null;
}
return out;
}
}
public static List asList(T... array) {
return new ArrayList(array);
}
/**
* Perform a binary search on a sorted byte array.
*
* @param sortedArray byte array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
*/
public static int binarySearch(final byte[] sortedArray, final byte key) {
int low = 0;
int high = sortedArray.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final byte midVal = sortedArray[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
/**
* Perform a binary search on a sorted char array.
*
* @param a char array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
*/
public static int binarySearch(final char[] a, final char key) {
int low = 0;
int high = a.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final char midVal = a[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
/**
* Perform a binary search on a sorted double array.
*
* @param sortedArray double array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
*/
public static int binarySearch(final double[] sortedArray, final double key) {
int low = 0;
int high = sortedArray.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final double midVal = sortedArray[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
/**
* Perform a binary search on a sorted float array.
*
* Note that some underlying JavaScript interpreters do not actually implement
* floats (using double instead), so you may get slightly different behavior
* regarding values that are very close (or equal) since conversion errors
* to/from double may change the values slightly.
*
* @param sortedArray float array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
*/
public static int binarySearch(final float[] sortedArray, final float key) {
int low = 0;
int high = sortedArray.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final float midVal = sortedArray[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
/**
* Perform a binary search on a sorted int array.
*
* @param sortedArray int array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
*/
public static int binarySearch(final int[] sortedArray, final int key) {
int low = 0;
int high = sortedArray.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final int midVal = sortedArray[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
/**
* Perform a binary search on a sorted long array.
*
* Note that most underlying JavaScript interpreters do not actually implement
* longs, so the values must be stored in doubles instead. This means that
* certain legal values cannot be represented, and comparison of two unequal
* long values may result in unexpected results if they are not also
* representable as doubles.
*
* @param sortedArray long array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
*/
public static int binarySearch(final long[] sortedArray, final long key) {
int low = 0;
int high = sortedArray.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final long midVal = sortedArray[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
/**
* Perform a binary search on a sorted object array, using natural ordering.
*
* @param sortedArray object array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
* @throws ClassCastException if key is not comparable to
* sortedArray's elements.
*/
public static int binarySearch(final Object[] sortedArray, final Object key) {
return binarySearch(sortedArray, key, Comparators.natural());
}
/**
* Perform a binary search on a sorted short array.
*
* @param sortedArray short array to search
* @param key value to search for
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
*/
public static int binarySearch(final short[] sortedArray, final short key) {
int low = 0;
int high = sortedArray.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final short midVal = sortedArray[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
/**
* Perform a binary search on a sorted object array, using a user-specified
* comparison function.
*
* @param sortedArray object array to search
* @param key value to search for
* @param comparator comparision function, null indicates
* natural ordering should be used.
* @return the index of an element with a matching value, or a negative number
* which is the index of the next larger value (or just past the end
* of the array if the searched value is larger than all elements in
* the array) minus 1 (to ensure error returns are negative)
* @throws ClassCastException if key and
* sortedArray's elements cannot be compared by
* comparator.
*/
public static int binarySearch(final T[] sortedArray, final T key,
Comparator comparator) {
if (comparator == null) {
comparator = Comparators.natural();
}
int low = 0;
int high = sortedArray.length - 1;
while (low <= high) {
final int mid = low + ((high - low) >> 1);
final T midVal = sortedArray[mid];
final int compareResult = comparator.compare(midVal, key);
if (compareResult < 0) {
low = mid + 1;
} else if (compareResult > 0) {
high = mid - 1;
} else {
// key found
return mid;
}
}
// key not found.
return -low - 1;
}
public static boolean[] copyOf(boolean[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static byte[] copyOf(byte[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static char[] copyOf(char[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static double[] copyOf(double[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static float[] copyOf(float[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static int[] copyOf(int[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static long[] copyOf(long[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static short[] copyOf(short[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static T[] copyOf(T[] original, int newLength) {
checkArraySize(newLength);
return copyOfRange(original, 0, newLength);
}
public static boolean[] copyOfRange(boolean[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
boolean[] copy = new boolean[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
byte[] copy = new byte[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static char[] copyOfRange(char[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
char[] copy = new char[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static double[] copyOfRange(double[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
double[] copy = new double[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static float[] copyOfRange(float[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
float[] copy = new float[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static int[] copyOfRange(int[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
int[] copy = new int[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static long[] copyOfRange(long[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
long[] copy = new long[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static short[] copyOfRange(short[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
short[] copy = new short[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static T[] copyOfRange(T[] original, int from, int to) {
int newLength = getLengthFromRange(from, to);
T[] copy = Array.createFrom(original, newLength);
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public static boolean deepEquals(Object[] a1, Object[] a2) {
if (a1 == a2) {
return true;
}
if (a1 == null || a2 == null) {
return false;
}
if (a1.length != a2.length) {
return false;
}
for (int i = 0, n = a1.length; i < n; ++i) {
if (!Objects.deepEquals(a1[i], a2[i])) {
return false;
}
}
return true;
}
public static int deepHashCode(Object[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (Object obj : a) {
int hash;
if (obj instanceof Object[]) {
hash = deepHashCode((Object[]) obj);
} else if (obj instanceof boolean[]) {
hash = hashCode((boolean[]) obj);
} else if (obj instanceof byte[]) {
hash = hashCode((byte[]) obj);
} else if (obj instanceof char[]) {
hash = hashCode((char[]) obj);
} else if (obj instanceof short[]) {
hash = hashCode((short[]) obj);
} else if (obj instanceof int[]) {
hash = hashCode((int[]) obj);
} else if (obj instanceof long[]) {
hash = hashCode((long[]) obj);
} else if (obj instanceof float[]) {
hash = hashCode((float[]) obj);
} else if (obj instanceof double[]) {
hash = hashCode((double[]) obj);
} else {
hash = Objects.hashCode(obj);
}
hashCode = 31 * hashCode + hash;
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static String deepToString(Object[] a) {
return deepToString(a, new HashSet());
}
public static boolean equals(boolean[] array1, boolean[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static boolean equals(byte[] array1, byte[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static boolean equals(char[] array1, char[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static boolean equals(double[] array1, double[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static boolean equals(float[] array1, float[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static boolean equals(int[] array1, int[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static boolean equals(long[] array1, long[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static boolean equals(Object[] array1, Object[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
Object val1 = array1[i];
Object val2 = array2[i];
if (!Objects.equals(val1, val2)) {
return false;
}
}
return true;
}
public static boolean equals(short[] array1, short[] array2) {
if (array1 == array2) {
return true;
}
if (array1 == null || array2 == null) {
return false;
}
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; ++i) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
public static void fill(boolean[] a, boolean val) {
fill(a, 0, a.length, val);
}
public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(byte[] a, byte val) {
fill(a, 0, a.length, val);
}
public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(char[] a, char val) {
fill(a, 0, a.length, val);
}
public static void fill(char[] a, int fromIndex, int toIndex, char val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(double[] a, double val) {
fill(a, 0, a.length, val);
}
public static void fill(double[] a, int fromIndex, int toIndex, double val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(float[] a, float val) {
fill(a, 0, a.length, val);
}
public static void fill(float[] a, int fromIndex, int toIndex, float val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(int[] a, int val) {
fill(a, 0, a.length, val);
}
public static void fill(int[] a, int fromIndex, int toIndex, int val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(long[] a, int fromIndex, int toIndex, long val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(long[] a, long val) {
fill(a, 0, a.length, val);
}
public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(Object[] a, Object val) {
fill(a, 0, a.length, val);
}
public static void fill(short[] a, int fromIndex, int toIndex, short val) {
for (int i = fromIndex; i < toIndex; ++i) {
a[i] = val;
}
}
public static void fill(short[] a, short val) {
fill(a, 0, a.length, val);
}
public static int hashCode(boolean[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (boolean e : a) {
hashCode = 31 * hashCode + (Boolean.valueOf(e).hashCode());
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(byte[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (byte e : a) {
hashCode = 31 * hashCode + Byte.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(char[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (char e : a) {
hashCode = 31 * hashCode + Character.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(double[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (double e : a) {
hashCode = 31 * hashCode + Double.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(float[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (float e : a) {
hashCode = 31 * hashCode + Float.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(int[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (int e : a) {
hashCode = 31 * hashCode + Integer.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(long[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (long e : a) {
hashCode = 31 * hashCode + Long.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(Object[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (Object e : a) {
hashCode = 31 * hashCode + Objects.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static int hashCode(short[] a) {
if (a == null) {
return 0;
}
int hashCode = 1;
for (short e : a) {
hashCode = 31 * hashCode + Short.hashCode(e);
hashCode = ensureInt(hashCode); // make sure we don't overflow
}
return hashCode;
}
public static void sort(byte[] array) {
nativeNumberSort(array);
}
public static void sort(byte[] array, int fromIndex, int toIndex) {
checkPositionIndexes(fromIndex, toIndex, array.length);
nativeNumberSort(array, fromIndex, toIndex);
}
public static void sort(char[] array) {
nativeNumberSort(array);
}
public static void sort(char[] array, int fromIndex, int toIndex) {
checkPositionIndexes(fromIndex, toIndex, array.length);
nativeNumberSort(array, fromIndex, toIndex);
}
public static void sort(double[] array) {
nativeNumberSort(array);
}
public static void sort(double[] array, int fromIndex, int toIndex) {
checkPositionIndexes(fromIndex, toIndex, array.length);
nativeNumberSort(array, fromIndex, toIndex);
}
public static void sort(float[] array) {
nativeNumberSort(array);
}
public static void sort(float[] array, int fromIndex, int toIndex) {
checkPositionIndexes(fromIndex, toIndex, array.length);
nativeNumberSort(array, fromIndex, toIndex);
}
public static void sort(int[] array) {
nativeNumberSort(array);
}
public static void sort(int[] array, int fromIndex, int toIndex) {
checkPositionIndexes(fromIndex, toIndex, array.length);
nativeNumberSort(array, fromIndex, toIndex);
}
public static void sort(long[] array) {
nativeLongSort(array);
}
public static void sort(long[] array, int fromIndex, int toIndex) {
checkPositionIndexes(fromIndex, toIndex, array.length);
nativeLongSort(array, fromIndex, toIndex);
}
public static void sort(Object[] array) {
// Can't use native JS sort because it isn't stable.
// -- Commented out implementation that uses the native sort with a fixup.
// nativeObjSort(array, 0, array.length, getNativeComparator(array,
// Comparators.natural()));
mergeSort(array, 0, array.length, Comparators.natural());
}
public static void sort(Object[] x, int fromIndex, int toIndex) {
// Can't use native JS sort because it isn't stable.
// -- Commented out implementation that uses the native sort with a fixup.
// nativeObjSort(x, fromIndex, toIndex, getNativeComparator(x,
// Comparators.natural()));
mergeSort(x, fromIndex, toIndex, Comparators.natural());
}
public static void sort(short[] array) {
nativeNumberSort(array);
}
public static void sort(short[] array, int fromIndex, int toIndex) {
checkPositionIndexes(fromIndex, toIndex, array.length);
nativeNumberSort(array, fromIndex, toIndex);
}
public static void sort(T[] x, Comparator c) {
// Commented out implementation that uses the native sort with a fixup.
// nativeObjSort(x, 0, x.length, getNativeComparator(x, c != null ? c :
// Comparators.natural()));
mergeSort(x, 0, x.length, c);
}
public static void sort(T[] x, int fromIndex, int toIndex,
Comparator c) {
// Commented out implementation that uses the native sort with a fixup.
checkPositionIndexes(fromIndex, toIndex, x.length);
// nativeObjSort(x, fromIndex, toIndex, getNativeComparator(x, c != null ? c
// : Comparators.natural()));
mergeSort(x, fromIndex, toIndex, c);
}
public static String toString(boolean[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
public static String toString(byte[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
public static String toString(char[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
public static String toString(double[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
public static String toString(float[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
public static String toString(int[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
public static String toString(long[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
public static String toString(Object[] x) {
if (x == null) {
return "null";
}
return Arrays.asList(x).toString();
}
public static String toString(short[] a) {
if (a == null) {
return "null";
}
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
b.append(String.valueOf(a[i]));
}
b.append("]");
return b.toString();
}
/**
* Recursive helper function for {@link Arrays#deepToString(Object[])}.
*/
private static String deepToString(Object[] a, Set arraysIveSeen) {
if (a == null) {
return "null";
}
if (arraysIveSeen.contains(a)) {
return "[...]";
}
arraysIveSeen.add(a);
StringBuilder b = new StringBuilder("[");
for (int i = 0; i < a.length; i++) {
if (i != 0) {
b.append(", ");
}
Object obj = a[i];
if (obj == null) {
b.append("null");
} else if (obj.getClass().isArray()) {
if (obj instanceof Object[]) {
if (arraysIveSeen.contains(obj)) {
b.append("[...]");
} else {
Object[] objArray = (Object[]) obj;
HashSet tempSet = new HashSet(arraysIveSeen);
b.append(deepToString(objArray, tempSet));
}
} else if (obj instanceof boolean[]) {
b.append(toString((boolean[]) obj));
} else if (obj instanceof byte[]) {
b.append(toString((byte[]) obj));
} else if (obj instanceof char[]) {
b.append(toString((char[]) obj));
} else if (obj instanceof short[]) {
b.append(toString((short[]) obj));
} else if (obj instanceof int[]) {
b.append(toString((int[]) obj));
} else if (obj instanceof long[]) {
b.append(toString((long[]) obj));
} else if (obj instanceof float[]) {
b.append(toString((float[]) obj));
} else if (obj instanceof double[]) {
b.append(toString((double[]) obj));
}
assert false : "Unexpected array type: " + obj.getClass().getName();
} else {
b.append(String.valueOf(obj));
}
}
b.append("]");
return b.toString();
}
private static int getLengthFromRange(int from, int to) {
int length = to - from;
checkArgument(length >= 0, "%s > %s", from, to);
return length;
}
/**
* Return a JavaScript function object which will compare elements of the
* specified object array.
*
* Note that this function isn't currently used but is kept because the native
* sort/fixup approach is faster everywhere but IE. In the future, we may
* choose to use deferred binding in the JRE to make those platforms faster.
*
* @param array the array of objects to compare
* @param comp the Comparator to use to compare individual objects.
* @return a JavaScript function object taking indices into the array to
* compare. Returns the result of the comparator, or the comparison of
* the indices if the comparator indicates equality so the sort is
* stable. The comparator has a property swap which is
* true if any elements were discovered to be out of order.
*/
@SuppressWarnings("unused")
// see above
private static native JavaScriptObject getNativeComparator(Object array,
Comparator comp) /*-{
function compare(a, b) {
var elementCompare = [email protected]::compare(Ljava/lang/Object;Ljava/lang/Object;)(array[a], array[b]);
var indexCompare = a - b;
// If elements compare equal, use the index comparison.
elementCompare = elementCompare || indexCompare;
// Keep track of having seen out-of-order elements. Note that we don't
// have to worry about the sort algorithm comparing an element to itself
// since it can't be swapped anyway, so we can just check for less-than.
compare.swap = compare.swap || (elementCompare < 0 != indexCompare < 0);
return elementCompare;
}
compare.swap = false;
return compare;
}-*/;
/**
* Sort a small subsection of an array by insertion sort.
*
* @param array array to sort
* @param low lower bound of range to sort
* @param high upper bound of range to sort
* @param comp comparator to use
*/
private static void insertionSort(Object[] array, int low, int high,
Comparator
