Make ScalableIntArray public as ResizableIntArray
Change-Id: Ibbbc117214912ffa192c694bde5b7d55154f40c4
This commit is contained in:
Tadashi G. Takaoka
parent
4fe0a8e620
commit
9370ab9ada
3 changed files with 236 additions and 78 deletions
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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]);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue