From acd1a1c7a82e8d5ad2cd62bd84dc9e99b24aa17a Mon Sep 17 00:00:00 2001 From: "Tadashi G. Takaoka" Date: Mon, 20 Jun 2011 23:42:45 +0900 Subject: [PATCH] Add ArraysCompatUtils.binarySearch Until API version 9, java.util.Arrays.binarySearch(int[], int, int, int) doesn't exist. Change-Id: Ife0ed4fbac642eda069e7b6f6b8dd30e0cd5fdee --- .../inputmethod/compat/ArraysCompatUtils.java | 50 +++++++++ .../latin/spellcheck/SpellChecker.java | 5 +- .../compat/ArraysCompatUtilsTests.java | 103 ++++++++++++++++++ 3 files changed, 156 insertions(+), 2 deletions(-) create mode 100644 java/src/com/android/inputmethod/compat/ArraysCompatUtils.java create mode 100644 tests/src/com/android/inputmethod/compat/ArraysCompatUtilsTests.java diff --git a/java/src/com/android/inputmethod/compat/ArraysCompatUtils.java b/java/src/com/android/inputmethod/compat/ArraysCompatUtils.java new file mode 100644 index 000000000..f6afbcfe2 --- /dev/null +++ b/java/src/com/android/inputmethod/compat/ArraysCompatUtils.java @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * 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.android.inputmethod.compat; + +import java.lang.reflect.Method; +import java.util.Arrays; + +public class ArraysCompatUtils { + private static final Method METHOD_Arrays_binarySearch = CompatUtils + .getMethod(Arrays.class, "binarySearch", int[].class, int.class, int.class, int.class); + + public static int binarySearch(int[] array, int startIndex, int endIndex, int value) { + if (METHOD_Arrays_binarySearch != null) { + final Object index = CompatUtils.invoke(null, 0, METHOD_Arrays_binarySearch, + array, startIndex, endIndex, value); + return (Integer)index; + } else { + return compatBinarySearch(array, startIndex, endIndex, value); + } + } + + /* package */ static int compatBinarySearch(int[] array, int startIndex, int endIndex, + int value) { + if (startIndex > endIndex) throw new IllegalArgumentException(); + if (startIndex < 0 || endIndex > array.length) throw new ArrayIndexOutOfBoundsException(); + + final int work[] = new int[endIndex - startIndex]; + System.arraycopy(array, startIndex, work, 0, work.length); + final int index = Arrays.binarySearch(work, value); + if (index >= 0) { + return index + startIndex; + } else { + return ~(~index + startIndex); + } + } +} diff --git a/java/src/com/android/inputmethod/latin/spellcheck/SpellChecker.java b/java/src/com/android/inputmethod/latin/spellcheck/SpellChecker.java index e3407a269..63c6d69d7 100644 --- a/java/src/com/android/inputmethod/latin/spellcheck/SpellChecker.java +++ b/java/src/com/android/inputmethod/latin/spellcheck/SpellChecker.java @@ -19,6 +19,7 @@ package com.android.inputmethod.latin.spellcheck; import android.content.Context; import android.content.res.Resources; +import com.android.inputmethod.compat.ArraysCompatUtils; import com.android.inputmethod.latin.Dictionary; import com.android.inputmethod.latin.Dictionary.DataType; import com.android.inputmethod.latin.Dictionary.WordCallback; @@ -26,7 +27,6 @@ import com.android.inputmethod.latin.DictionaryFactory; import com.android.inputmethod.latin.Utils; import com.android.inputmethod.latin.WordComposer; -import java.util.Arrays; import java.util.LinkedList; import java.util.List; import java.util.Locale; @@ -64,13 +64,14 @@ public class SpellChecker { private int[] mScores = new int[DEFAULT_SUGGESTION_LENGTH]; private int mLength = 0; + @Override synchronized public boolean addWord(char[] word, int wordOffset, int wordLength, int score, int dicTypeId, DataType dataType) { if (mLength >= mScores.length) { final int newLength = mScores.length * 2; mScores = new int[newLength]; } - final int positionIndex = Arrays.binarySearch(mScores, 0, mLength, score); + final int positionIndex = ArraysCompatUtils.binarySearch(mScores, 0, mLength, score); // binarySearch returns the index if the element exists, and - - 1 // if it doesn't. See documentation for binarySearch. final int insertionIndex = positionIndex >= 0 ? positionIndex : -positionIndex - 1; diff --git a/tests/src/com/android/inputmethod/compat/ArraysCompatUtilsTests.java b/tests/src/com/android/inputmethod/compat/ArraysCompatUtilsTests.java new file mode 100644 index 000000000..93681b616 --- /dev/null +++ b/tests/src/com/android/inputmethod/compat/ArraysCompatUtilsTests.java @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * 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.android.inputmethod.compat; + +import android.test.AndroidTestCase; + +public class ArraysCompatUtilsTests extends AndroidTestCase { + // See {@link tests.api.java.util.ArraysTest}. + private static final int ARRAY_SIZE = 100; + private final int[] mIntArray = new int[ARRAY_SIZE]; + + @Override + protected void setUp() throws Exception { + super.setUp(); + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + mIntArray[counter] = counter; + } + } + + public void testEmptyArray() { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, 0, 0); + assertEquals("empty", ~0, index); + final int compat = ArraysCompatUtils.compatBinarySearch(mIntArray, 0, 0, 0); + assertEquals("empty compat", ~0, compat); + } + + public void testEmptyRangeArray() { + final int mid = ARRAY_SIZE / 3; + final int index = ArraysCompatUtils.binarySearch(mIntArray, mid, mid, 1); + assertEquals("empty", ~mid, index); + final int compat = ArraysCompatUtils.compatBinarySearch(mIntArray, mid, mid, 1); + assertEquals("empty compat", ~mid, compat); + } + + public void testFind() { + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, counter); + assertEquals("found", counter, index); + } + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, counter); + assertEquals("found compat", counter, compat); + } + } + + public void testFindNegative() { + final int offset = ARRAY_SIZE / 2; + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + mIntArray[counter] -= offset; + } + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int index = ArraysCompatUtils.binarySearch( + mIntArray, 0, ARRAY_SIZE, counter - offset); + assertEquals("found", counter, index); + } + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, counter - offset); + assertEquals("found compat", counter, compat); + } + } + + public void testNotFountAtTop() { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, -1); + assertEquals("not found top", ~0, index); + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, -1); + assertEquals("not found top compat", ~0, compat); + } + + public void testNotFountAtEnd() { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, ARRAY_SIZE); + assertEquals("not found end", ~ARRAY_SIZE, index); + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, ARRAY_SIZE); + assertEquals("not found end compat", ~ARRAY_SIZE, compat); + } + + public void testNotFountAtMid() { + final int mid = ARRAY_SIZE / 3; + mIntArray[mid] = mIntArray[mid + 1]; + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, mid); + assertEquals("not found mid", ~mid, index); + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, mid); + assertEquals("not found mid compat", ~mid, compat); + } +}