Links
Android Sites
Language
Results
Loading...
1
/*
2
* Copyright (C) 2009 The Android Open Source Project
3
*
4
* Licensed under the Apache License, Version 2.0 (the "License");
5
* you may not use this file except in compliance with the License.
6
* You may obtain a copy of the License at
7
*
8
* http://www.apache.org/licenses/LICENSE-2.0
9
*
10
* Unless required by applicable law or agreed to in writing, software
11
* distributed under the License is distributed on an "AS IS" BASIS,
12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*/
16
17
package com.example.android.basicmultitouch;
18
19
/**
20
* Helper class for crating pools of objects. An example use looks like this:
21
* <pre>
22
* public class MyPooledClass {
23
*
24
* private static final SynchronizedPool<MyPooledClass> sPool =
25
* new SynchronizedPool<MyPooledClass>(10);
26
*
27
* public static MyPooledClass obtain() {
28
* MyPooledClass instance = sPool.acquire();
29
* return (instance != null) ? instance : new MyPooledClass();
30
* }
31
*
32
* public void recycle() {
33
* // Clear state if needed.
34
* sPool.release(this);
35
* }
36
*
37
* . . .
38
* }
39
* </pre>
40
*
41
* @hide
42
*/
43
public final class Pools {
44
45
/**
46
* Interface for managing a pool of objects.
47
*
48
* @param <T> The pooled type.
49
*/
50
public static interface Pool<T> {
51
52
/**
53
* @return An instance from the pool if such, null otherwise.
54
*/
55
public T acquire();
56
57
/**
58
* Release an instance to the pool.
59
*
60
* @param instance The instance to release.
61
* @return Whether the instance was put in the pool.
62
*
63
* @throws IllegalStateException If the instance is already in the pool.
64
*/
65
public boolean release(T instance);
66
}
67
68
private Pools() {
69
/* do nothing - hiding constructor */
70
}
71
72
/**
73
* Simple (non-synchronized) pool of objects.
74
*
75
* @param <T> The pooled type.
76
*/
77
public static class SimplePool<T> implements Pool<T> {
78
private final Object[] mPool;
79
80
private int mPoolSize;
81
82
/**
83
* Creates a new instance.
84
*
85
* @param maxPoolSize The max pool size.
86
*
87
* @throws IllegalArgumentException If the max pool size is less than zero.
88
*/
89
public SimplePool(int maxPoolSize) {
90
if (maxPoolSize <= 0) {
91
throw new IllegalArgumentException("The max pool size must be > 0");
92
}
93
mPool = new Object[maxPoolSize];
94
}
95
96
@Override
97
@SuppressWarnings("unchecked")
98
public T acquire() {
99
if (mPoolSize > 0) {
100
final int lastPooledIndex = mPoolSize - 1;
101
T instance = (T) mPool[lastPooledIndex];
102
mPool[lastPooledIndex] = null;
103
mPoolSize--;
104
return instance;
105
}
106
return null;
107
}
108
109
@Override
110
public boolean release(T instance) {
111
if (isInPool(instance)) {
112
throw new IllegalStateException("Already in the pool!");
113
}
114
if (mPoolSize < mPool.length) {
115
mPool[mPoolSize] = instance;
116
mPoolSize++;
117
return true;
118
}
119
return false;
120
}
121
122
private boolean isInPool(T instance) {
123
for (int i = 0; i < mPoolSize; i++) {
124
if (mPool[i] == instance) {
125
return true;
126
}
127
}
128
return false;
129
}
130
}
131
132
/**
133
* Synchronized) pool of objects.
134
*
135
* @param <T> The pooled type.
136
*/
137
public static class SynchronizedPool<T> extends SimplePool<T> {
138
private final Object mLock = new Object();
139
140
/**
141
* Creates a new instance.
142
*
143
* @param maxPoolSize The max pool size.
144
*
145
* @throws IllegalArgumentException If the max pool size is less than zero.
146
*/
147
public SynchronizedPool(int maxPoolSize) {
148
super(maxPoolSize);
149
}
150
151
@Override
152
public T acquire() {
153
synchronized (mLock) {
154
return super.acquire();
155
}
156
}
157
158
@Override
159
public boolean release(T element) {
160
synchronized (mLock) {
161
return super.release(element);
162
}
163
}
164
}
165
}