001: /*
002: License $Id: Pool.java,v 1.6 2005/03/15 20:08:13 hendriks73 Exp $
003:
004: Copyright (c) 2001-2005 tagtraum industries.
005:
006: LGPL
007: ====
008:
009: jo! is free software; you can redistribute it and/or
010: modify it under the terms of the GNU Lesser General Public
011: License as published by the Free Software Foundation; either
012: version 2.1 of the License, or (at your option) any later version.
013:
014: jo! is distributed in the hope that it will be useful,
015: but WITHOUT ANY WARRANTY; without even the implied warranty of
016: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
017: Lesser General Public License for more details.
018:
019: You should have received a copy of the GNU Lesser General Public
020: License along with this library; if not, write to the Free Software
021: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
022:
023: For LGPL see <http://www.fsf.org/copyleft/lesser.txt>
024:
025:
026: Sun license
027: ===========
028:
029: This release contains software by Sun Microsystems. Therefore
030: the following conditions have to be met, too. They apply to the
031: files
032:
033: - lib/mail.jar
034: - lib/activation.jar
035: - lib/jsse.jar
036: - lib/jcert.jar
037: - lib/jaxp.jar
038: - lib/crimson.jar
039: - lib/servlet.jar
040: - lib/jnet.jar
041: - lib/jaas.jar
042: - lib/jaasmod.jar
043:
044: contained in this release.
045:
046: a. Licensee may not modify the Java Platform
047: Interface (JPI, identified as classes contained within the javax
048: package or any subpackages of the javax package), by creating additional
049: classes within the JPI or otherwise causing the addition to or modification
050: of the classes in the JPI. In the event that Licensee creates any
051: Java-related API and distribute such API to others for applet or
052: application development, you must promptly publish broadly, an accurate
053: specification for such API for free use by all developers of Java-based
054: software.
055:
056: b. Software is confidential copyrighted information of Sun and
057: title to all copies is retained by Sun and/or its licensors. Licensee
058: shall not modify, decompile, disassemble, decrypt, extract, or otherwise
059: reverse engineer Software. Software may not be leased, assigned, or
060: sublicensed, in whole or in part. Software is not designed or intended
061: for use in on-line control of aircraft, air traffic, aircraft navigation
062: or aircraft communications; or in the design, construction, operation or
063: maintenance of any nuclear facility. Licensee warrants that it will not
064: use or redistribute the Software for such purposes.
065:
066: c. Software is provided "AS IS," without a warranty
067: of any kind. ALL EXPRESS OR IMPLIED REPRESENTATIONS AND WARRANTIES,
068: INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
069: PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
070:
071: d. This License is effective until terminated. Licensee may
072: terminate this License at any time by destroying all copies of Software.
073: This License will terminate immediately without notice from Sun if Licensee
074: fails to comply with any provision of this License. Upon such termination,
075: Licensee must destroy all copies of Software.
076:
077: e. Software, including technical data, is subject to U.S.
078: export control laws, including the U.S. Export Administration Act and its
079: associated regulations, and may be subject to export or import regulations
080: in other countries. Licensee agrees to comply strictly with all such
081: regulations and acknowledges that it has the responsibility to obtain
082: licenses to export, re-export, or import Software. Software may not be
083: downloaded, or otherwise exported or re-exported (i) into, or to a national
084: or resident of, Cuba, Iraq, Iran, North Korea, Libya, Sudan, Syria or any
085: country to which the U.S. has embargoed goods; or (ii) to anyone on the
086: U.S. Treasury Department's list of Specially Designated Nations or the U.S.
087: Commerce Department's Table of Denial Orders.
088:
089:
090: Feedback
091: ========
092:
093: We encourage your feedback and suggestions and want to use your feedback to
094: improve the Software. Send all such feedback to:
095: <feedback@tagtraum.com>
096:
097: For more information on tagtraum industries and jo!
098: please see <http://www.tagtraum.com/>.
099:
100:
101: */
102: package com.tagtraum.framework.util;
103:
104: import java.util.Collection;
105: import java.util.Iterator;
106: import java.util.LinkedList;
107:
108: /**
109: * Universal-Pool. Initial capacity: 100 elements.
110: *
111: * @author <a href="mailto:hs@tagtraum.com">Hendrik Schreiber</a>
112: * @version 1.1beta1 $Id: Pool.java,v 1.6 2005/03/15 20:08:13 hendriks73 Exp $
113: * @see com.tagtraum.framework.recycler
114: */
115: public class Pool implements I_Pool {
116:
117: /**
118: * Source-Version
119: */
120: public static String vcid = "$Id: Pool.java,v 1.6 2005/03/15 20:08:13 hendriks73 Exp $";
121:
122: /**
123: * Cached objects.
124: */
125: protected LinkedList myObjects = new LinkedList();
126:
127: /**
128: * Capacity.
129: */
130: protected int myCapacity = 100;
131:
132: /**
133: * No-arg-constructor.
134: */
135: public Pool() {
136: }
137:
138: /**
139: * Standard constructor.
140: *
141: * @param aCapacity initial capacity
142: */
143: public Pool(int aCapacity) {
144: setCapacity(aCapacity);
145: }
146:
147: /**
148: * Sets the capacity of this pool.
149: *
150: * @param aCapacity new capacity
151: */
152: public void setCapacity(int aCapacity)
153: throws IllegalArgumentException {
154: if (aCapacity < 0) {
155: throw new IllegalArgumentException(
156: "Capacity can't be less than zero.");
157: }
158:
159: myCapacity = aCapacity;
160:
161: trim();
162: }
163:
164: /**
165: * Returns the capacity of this pool.
166: *
167: * @return the capacity
168: */
169: public int getCapacity() {
170: return myCapacity;
171: }
172:
173: /**
174: * Reduces the pool to it's capacity.
175: */
176: protected synchronized void trim() {
177: while (myObjects.size() > myCapacity) {
178: myObjects.removeLast();
179: }
180: }
181:
182: /**
183: * Returns a pooled instance or <code>null</code> if the
184: * pool is empty.
185: *
186: * @return an instance of the object
187: * @see #isEmpty()
188: */
189: public synchronized Object get() {
190: if (!myObjects.isEmpty()) {
191: return myObjects.removeFirst();
192: }
193:
194: return null;
195: }
196:
197: /**
198: * Returns a pooled instance or <code>null</code> if the
199: * pool is empty.
200: *
201: * @param waittime wait at most x ms to get an instance
202: * @return eine Instanz des Objekts
203: * @see #isEmpty()
204: */
205: public synchronized Object get(long waittime)
206: throws InterruptedException {
207: if (!myObjects.isEmpty()) {
208: return myObjects.removeFirst();
209: } else {
210: wait(waittime);
211:
212: if (!myObjects.isEmpty()) {
213: return myObjects.removeFirst();
214: }
215: }
216:
217: return null;
218: }
219:
220: /**
221: * Adds an object to this pool if it isn't full.
222: *
223: * @param aObject object to add
224: * @return <code>true</code> if the object was added to the pool
225: */
226: public synchronized boolean add(Object aObject) {
227: if (myObjects.size() < myCapacity
228: && !myObjects.contains(aObject)) {
229: myObjects.add(aObject);
230: notify();
231: return true;
232: }
233: return false;
234: }
235:
236: /**
237: * Adds as much elements from the <code>Collection</code>
238: * as possible.
239: *
240: * @return false as the adding of this instance to itself is not allowed
241: */
242: public synchronized boolean addAll(Collection aCollection) {
243: if (aCollection == this ) {
244: throw new IllegalArgumentException(
245: "Can't add a pool to itself.");
246: }
247:
248: Iterator it = aCollection.iterator();
249:
250: while (it.hasNext() && !isFull()) {
251: add(it.next());
252: }
253:
254: return false;
255: }
256:
257: /**
258: * Clears the pool.
259: */
260: public synchronized void clear() {
261: myObjects.clear();
262: }
263:
264: /**
265: * Indicates whether this pool is empty.
266: *
267: * @return <code>true</code> or <code>false</code>.
268: * @see #isFull()
269: */
270: public boolean isEmpty() {
271: return myObjects.isEmpty();
272: }
273:
274: /**
275: * Indicates whether this pool is full.
276: *
277: * @return <code>true</code> or <code>false</code>.
278: * @see #isEmpty()
279: */
280: public boolean isFull() {
281: return size() >= myCapacity;
282: }
283:
284: /**
285: * Returns the current size of the pool.
286: *
287: * @return pool size
288: */
289: public int size() {
290: return myObjects.size();
291: }
292:
293: /**
294: * Returns an <code>Iterator</code>.
295: *
296: * @return Iterator
297: */
298: public Iterator iterator() {
299: return myObjects.iterator();
300: }
301:
302: /**
303: * Returns an <code>Array</code> of the pooled objects.
304: *
305: * @return Array
306: */
307: public Object[] toArray() {
308: return myObjects.toArray();
309: }
310:
311: /**
312: * Returns an <code>Array</code> of the pooled objects.
313: *
314: * @return Array
315: */
316: public Object[] toArray(Object[] anArray) {
317: return myObjects.toArray(anArray);
318: }
319:
320: // synchronize the following methods?? (rik)
321:
322: /**
323: * Removes all Elements that are also contained
324: * in the specified Collection.
325: *
326: * @param aCollection a Collection
327: * @return <code>true</code> if this collection changed as a result of the call
328: */
329: public boolean removeAll(Collection aCollection) {
330: return myObjects.removeAll(aCollection);
331: }
332:
333: /**
334: * Removes an element from the Collection.
335: *
336: * @param anObject an element
337: * @return <code>true</code> if this collection changed as a result of the call
338: */
339: public boolean remove(Object anObject) {
340: return myObjects.remove(anObject);
341: }
342:
343: /**
344: *
345: *
346: * @param aCollection a Collection
347: * @return <code>true</code> if this collection contains all of the elements in the specified collection
348: */
349: public boolean containsAll(Collection aCollection) {
350: return myObjects.containsAll(aCollection);
351: }
352:
353: /**
354: *
355: * @param aCollection a Collection
356: * @return <code>true</code> if this collection changed as a result of the call
357: */
358: public boolean retainAll(Collection aCollection) {
359: return myObjects.retainAll(aCollection);
360: }
361:
362: /**
363: *
364: * @param anObject an Object
365: * @return <code>true</code> if this collection contains the specified Object
366: */
367: public boolean contains(Object anObject) {
368: return myObjects.contains(anObject);
369: }
370:
371: }
|