Make ScalableIntArray public as ResizableIntArray (9370ab9a) · Commits · e / os / android_packages_inputmethods_LatinIME

java/src/com/android/inputmethod/latin/InputPointers.java

+8 −78

Original line number	Diff line number	Diff line
		@@ -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;
		}
		}
		}

java/src/com/android/inputmethod/latin/ResizableIntArray.java

0 → 100644

+95 −0

Original line number	Diff line number	Diff line
		/*
		* 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;
		}
		}

tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java

0 → 100644

+133 −0

Original line number	Diff line number	Diff line
		/*
		* 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]);
		}
		}
		}