Adding common object pool class.
(From: frameworks/base/core/java/android/util/Pools.java)
Change-Id: Ie9b8e4a92bb3cdc8884531b1599884ad17e1fe83
diff --git a/common/src/com/example/android/common/Pools.java b/common/src/com/example/android/common/Pools.java
new file mode 100644
index 0000000..b31749a
--- /dev/null
+++ b/common/src/com/example/android/common/Pools.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2009 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.example.android.common;
+
+/**
+ * Helper class for creating pools of objects. Creating new objects is an
+ * expensive operation, which can lead to significant performance overhead if
+ * new objects of the same type are allocated and destroyed during run time.
+ * These performance issues can be mitigated by reusing unused objects and
+ * reinitializing them, rather than destroying and removing them from memory.
+ * <p>
+ * The object pool pattern provided by the {@link Pool} interface facilitates
+ * the reuse of objects by keeping unused ('released') objects in memory and
+ * making them available for use. This can provide a significant performance
+ * improvement, as objects are only created once and returned to the Pool when
+ * no longer required, rather than destroyed and reallocated. Object
+ * {@link Pools} keep track of these unused objects. An object pool provides two
+ * basic methods for access:
+ * <ul>
+ * <li><b>{@link Pool#acquire()}:</b> Returns an used object if one is
+ * available.</li>
+ * <li><b> {@link Pool#release(Object)}:</b> Adds the given object to the pool,
+ * ready to be reallocated in acquire().</li>
+ * </ul>
+ * <p>
+ * This class contains the interface defining a {@link Pool}, an implementation
+ * based on a fixed length array ({@link SimplePool}) and a synchronized pool
+ * for use with concurrency ({@link SynchronizedPool}).
+ * <p>
+ * A {@link SimplePool} can be used like this:
+ *
+ * <pre>
+ * public class MyPooledClass {
+ *
+ * private static final SynchronizedPool<MyPooledClass> sPool =
+ * new SynchronizedPool<MyPooledClass>(10);
+ *
+ * public static MyPooledClass obtain() {
+ * MyPooledClass instance = sPool.acquire();
+ * return (instance != null) ? instance : new MyPooledClass();
+ * }
+ *
+ * public void recycle() {
+ * // Clear state if needed.
+ * sPool.release(this);
+ * }
+ *
+ * . . .
+ * }
+ * </pre>
+ */
+public final class Pools {
+
+ /**
+ * Interface for managing a pool of objects.
+ *
+ * @param T The pooled type.
+ */
+ public static interface Pool<T> {
+
+ /**
+ * Retrieves an object from the pool. Returns null if the pool is empty
+ * and no object is available.
+ *
+ * @return An instance from the pool if available, null otherwise.
+ */
+ public T acquire();
+
+ /**
+ * Releases an instance to the pool. This marks the object as reusable
+ * and makes it available through a call to {@link #acquire()}. An
+ * object should not be modified or accessed once it has been released.
+ *
+ * @param instance The instance to release.
+ * @return True if the instance was put in the pool.
+ * @throws IllegalStateException If the instance is already in the pool.
+ */
+ public boolean release(T instance);
+ }
+
+ private Pools() {
+ /* do nothing - hiding constructor */
+ }
+
+ /**
+ * Simple (non-synchronized) pool of objects. This class provides a simple,
+ * fixed sized pool of objects.
+ *
+ * @param T The pooled type.
+ */
+ public static class SimplePool<T> implements Pool<T> {
+ private final Object[] mPool;
+
+ private int mPoolSize;
+
+ /**
+ * Creates a new instance. The parameter defines the maximum number of
+ * objects that can be held in this pool.
+ *
+ * @param maxPoolSize The max pool size.
+ * @throws IllegalArgumentException If the max pool size is less than
+ * zero.
+ */
+ public SimplePool(int maxPoolSize) {
+ if (maxPoolSize <= 0) {
+ throw new IllegalArgumentException("The max pool size must be > 0");
+ }
+ mPool = new Object[maxPoolSize];
+ }
+
+ /**
+ * Returns an object from the pool or null if the pool is empty.
+ *
+ * @return An object from the pool or null if no object is available.
+ */
+ @Override
+ @SuppressWarnings("unchecked")
+ public T acquire() {
+ if (mPoolSize > 0) {
+ final int lastPooledIndex = mPoolSize - 1;
+ T instance = (T) mPool[lastPooledIndex];
+ mPool[lastPooledIndex] = null;
+ mPoolSize--;
+ return instance;
+ }
+ return null;
+ }
+
+ /**
+ * Adds an object to the pool. If the pool is already full (its
+ * allocated size has been exceeded), the object is not added and false
+ * is returned. A linear check is performed to ensure that the object is
+ * not already held in the pool.
+ *
+ * @param instance The element to release.
+ * @return True if the object was added to the pool.
+ * @throws IllegalStateException If the object already exists in the
+ * pool.
+ */
+ @Override
+ public boolean release(T instance) {
+ if (isInPool(instance)) {
+ throw new IllegalStateException("Already in the pool!");
+ }
+ if (mPoolSize < mPool.length) {
+ mPool[mPoolSize] = instance;
+ mPoolSize++;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Checks if the object already exists in the pool.
+ * @param instance The element to look for.
+ * @return True if the object exists in the pool.
+ */
+ private boolean isInPool(T instance) {
+ for (int i = 0; i < mPoolSize; i++) {
+ if (mPool[i] == instance) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ /**
+ * Synchronized pool of objects. Based on the implementation of a fixed size
+ * pool in {@link SimplePool}, this class provides synchronized concurrent
+ * access to the pool.
+ *
+ * @param T The pooled type.
+ */
+ public static class SynchronizedPool<T> extends SimplePool<T> {
+ private final Object mLock = new Object();
+
+ /**
+ * Creates a new instance.
+ *
+ * @param maxPoolSize The max pool size.
+ * @throws IllegalArgumentException If the max pool size is less than
+ * zero.
+ */
+ public SynchronizedPool(int maxPoolSize) {
+ super(maxPoolSize);
+ }
+
+ /**
+ * Returns an object from the pool or null if the pool is empty.
+ * <p>
+ * Access to the pool is synchronized.
+ *
+ * @return An object from the pool or null if no object is available.
+ */
+ @Override
+ public T acquire() {
+ synchronized (mLock) {
+ return super.acquire();
+ }
+ }
+
+ /**
+ * Adds an object to the pool. If the pool is already full (its
+ * allocated size has been exceeded), the object is not added and false
+ * is returned. A linear check is performed to ensure that the object is
+ * not already held in the pool.
+ * <p>
+ * Access to the pool is synchronized.
+ *
+ * @param element The element to be released
+ * @return True if the object was added to the pool.
+ * @throws IllegalStateException If the object already exists in the
+ * pool.
+ */
+ @Override
+ public boolean release(T element) {
+ synchronized (mLock) {
+ return super.release(element);
+ }
+ }
+ }
+}