diff --git a/java/src/com/android/inputmethod/latin/InputPointers.java b/java/src/com/android/inputmethod/latin/InputPointers.java index febabadf7..2bccdee48 100644 --- a/java/src/com/android/inputmethod/latin/InputPointers.java +++ b/java/src/com/android/inputmethod/latin/InputPointers.java @@ -16,22 +16,20 @@ package com.android.inputmethod.latin; -import java.util.Arrays; - // TODO: This class is not thread-safe. public class InputPointers { private final int mDefaultCapacity; - private final ScalableIntArray mXCoordinates; - private final ScalableIntArray mYCoordinates; - private final ScalableIntArray mPointerIds; - private final ScalableIntArray mTimes; + private final ResizableIntArray mXCoordinates; + private final ResizableIntArray mYCoordinates; + private final ResizableIntArray mPointerIds; + private final ResizableIntArray mTimes; public InputPointers(int defaultCapacity) { mDefaultCapacity = defaultCapacity; - mXCoordinates = new ScalableIntArray(defaultCapacity); - mYCoordinates = new ScalableIntArray(defaultCapacity); - mPointerIds = new ScalableIntArray(defaultCapacity); - mTimes = new ScalableIntArray(defaultCapacity); + mXCoordinates = new ResizableIntArray(defaultCapacity); + mYCoordinates = new ResizableIntArray(defaultCapacity); + mPointerIds = new ResizableIntArray(defaultCapacity); + mTimes = new ResizableIntArray(defaultCapacity); } public void addPointer(int index, int x, int y, int pointerId, int time) { @@ -105,72 +103,4 @@ public class InputPointers { public int[] getTimes() { return mTimes.getPrimitiveArray(); } - - private static class ScalableIntArray { - private int[] mArray; - private int mLength; - - public ScalableIntArray(int capacity) { - reset(capacity); - } - - public void add(int index, int val) { - if (mLength < index + 1) { - mLength = index; - add(val); - } else { - mArray[index] = val; - } - } - - public void add(int val) { - final int nextLength = mLength + 1; - ensureCapacity(nextLength); - mArray[mLength] = val; - mLength = nextLength; - } - - private void ensureCapacity(int minimumCapacity) { - if (mArray.length < minimumCapacity) { - final int nextCapacity = mArray.length * 2; - // The following is the same as newLength = Math.max(minimumCapacity, nextCapacity); - final int newLength = minimumCapacity > nextCapacity - ? minimumCapacity - : nextCapacity; - mArray = Arrays.copyOf(mArray, newLength); - } - } - - public int getLength() { - return mLength; - } - - public void reset(int capacity) { - mArray = new int[capacity]; - mLength = 0; - } - - public int[] getPrimitiveArray() { - return mArray; - } - - public void set(ScalableIntArray ip) { - mArray = ip.mArray; - mLength = ip.mLength; - } - - public void copy(ScalableIntArray ip) { - ensureCapacity(ip.mLength); - System.arraycopy(ip.mArray, 0, mArray, 0, ip.mLength); - mLength = ip.mLength; - } - - public void append(ScalableIntArray src, int startPos, int length) { - final int currentLength = mLength; - final int newLength = currentLength + length; - ensureCapacity(newLength); - System.arraycopy(src.mArray, startPos, mArray, currentLength, length); - mLength = newLength; - } - } } diff --git a/java/src/com/android/inputmethod/latin/ResizableIntArray.java b/java/src/com/android/inputmethod/latin/ResizableIntArray.java new file mode 100644 index 000000000..2079c0e99 --- /dev/null +++ b/java/src/com/android/inputmethod/latin/ResizableIntArray.java @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2012 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.latin; + +import java.util.Arrays; + +// TODO: This class is not thread-safe. +public class ResizableIntArray { + private int[] mArray; + private int mLength; + + public ResizableIntArray(int capacity) { + reset(capacity); + } + + public void add(int index, int val) { + if (mLength < index + 1) { + mLength = index; + add(val); + } else { + mArray[index] = val; + } + } + + public void add(int val) { + final int nextLength = mLength + 1; + ensureCapacity(nextLength); + mArray[mLength] = val; + mLength = nextLength; + } + + private void ensureCapacity(int minimumCapacity) { + if (mArray.length < minimumCapacity) { + final int nextCapacity = mArray.length * 2; + // The following is the same as newLength = + // Math.max(minimumCapacity, nextCapacity); + final int newLength = minimumCapacity > nextCapacity + ? minimumCapacity + : nextCapacity; + // TODO: Implement primitive array pool. + mArray = Arrays.copyOf(mArray, newLength); + } + } + + public int getLength() { + return mLength; + } + + // TODO: Implement setLength(int). + + public void reset(int capacity) { + // TODO: Implement primitive array pool. + mArray = new int[capacity]; + mLength = 0; + } + + public int[] getPrimitiveArray() { + return mArray; + } + + public void set(ResizableIntArray ip) { + // TODO: Implement primitive array pool. + mArray = ip.mArray; + mLength = ip.mLength; + } + + public void copy(ResizableIntArray ip) { + // TODO: Avoid useless coping of values. + ensureCapacity(ip.mLength); + System.arraycopy(ip.mArray, 0, mArray, 0, ip.mLength); + mLength = ip.mLength; + } + + public void append(ResizableIntArray src, int startPos, int length) { + final int currentLength = mLength; + final int newLength = currentLength + length; + ensureCapacity(newLength); + System.arraycopy(src.mArray, startPos, mArray, currentLength, length); + mLength = newLength; + } +} diff --git a/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java new file mode 100644 index 000000000..8b869b6ca --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2012 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.latin; + +import android.test.AndroidTestCase; + +public class ResizableIntArrayTests extends AndroidTestCase { + private static final int DEFAULT_CAPACITY = 48; + + public void testNewInstance() { + final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY); + assertEquals("new instance length", 0, src.getLength()); + assertNotNull("new instance array", src.getPrimitiveArray()); + } + + public void testReset() { + final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY); + final int[] array = src.getPrimitiveArray(); + + src.reset(DEFAULT_CAPACITY); + assertEquals("length after reset", 0, src.getLength()); + assertNotSame("array after reset", array, src.getPrimitiveArray()); + } + + public void testAdd() { + final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY); + final int limit = src.getPrimitiveArray().length * 2 + 10; + for (int i = 0; i < limit; i++) { + src.add(i); + assertEquals("length after add " + i, i + 1, src.getLength()); + } + for (int i = 0; i < limit; i++) { + assertEquals("value at " + i, i, src.getPrimitiveArray()[i]); + } + } + + public void testAddAt() { + final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY); + final int limit = 1000, step = 100; + for (int i = 0; i < limit; i += step) { + src.add(i, i); + assertEquals("length after add at " + i, i + 1, src.getLength()); + } + for (int i = 0; i < limit; i += step) { + assertEquals("value at " + i, i, src.getPrimitiveArray()[i]); + } + } + + public void testSet() { + final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY); + final int limit = src.getPrimitiveArray().length * 2 + 10; + for (int i = 0; i < limit; i++) { + src.add(i); + } + final ResizableIntArray dst = new ResizableIntArray(DEFAULT_CAPACITY); + dst.set(src); + assertEquals("length after set", dst.getLength(), src.getLength()); + assertSame("array after set", dst.getPrimitiveArray(), src.getPrimitiveArray()); + } + + public void testCopy() { + final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY); + final int limit = 100; + for (int i = 0; i < limit; i++) { + src.add(i); + } + final ResizableIntArray dst = new ResizableIntArray(DEFAULT_CAPACITY); + dst.copy(src); + assertEquals("length after copy", dst.getLength(), src.getLength()); + assertNotSame("array after copy", dst.getPrimitiveArray(), src.getPrimitiveArray()); + final int length = dst.getLength(); + assertArrayEquals("values after copy", + dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, length); + } + + public void testAppend() { + final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY); + final int srcLen = 100; + for (int i = 0; i < srcLen; i++) { + src.add(i); + } + final int dstLen = 50; + final ResizableIntArray dst = new ResizableIntArray(DEFAULT_CAPACITY); + for (int i = 0; i < dstLen; i++) { + final int value = -i - 1; + dst.add(value); + } + final ResizableIntArray dstCopy = new ResizableIntArray(dst.getLength()); + dstCopy.copy(dst); + + dst.append(src, 0, 0); + assertEquals("length after append zero", dstLen, dst.getLength()); + assertArrayEquals("values after append zero", + dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen); + + dst.append(src, 0, srcLen); + assertEquals("length after append", dstLen + srcLen, dst.getLength()); + assertTrue("primitive length after append", + dst.getPrimitiveArray().length >= dstLen + srcLen); + assertArrayEquals("original values after append", + dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen); + assertArrayEquals("appended values after append", + src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen, srcLen); + } + + private static void assertArrayEquals(String message, int[] expecteds, int expectedPos, + int[] actuals, int actualPos, int length) { + if (expecteds == null && actuals == null) { + return; + } + if (expecteds == null || actuals == null) { + fail(message + ": expecteds=" + expecteds + " actuals=" + actuals); + } + for (int i = 0; i < length; i++) { + assertEquals(message + ": element at " + i, + expecteds[i + expectedPos], actuals[i + actualPos]); + } + } +}