Clover coverage report - JGAP 3.1
Coverage timestamp: Mo Dez 11 2006 21:16:18 CET
file stats: LOC: 128   Methods: 6
NCLOC: 31   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
Pool.java 100% 100% 100% 100%
coverage
 1    /*
 2    * This file is part of JGAP.
 3    *
 4    * JGAP offers a dual license model containing the LGPL as well as the MPL.
 5    *
 6    * For licencing information please see the file license.txt included with JGAP
 7    * or have a look at the top of class org.jgap.Chromosome which representatively
 8    * includes the JGAP license policy applicable for any file delivered with JGAP.
 9    */
 10    package org.jgap.impl;
 11   
 12    import java.util.*;
 13   
 14    /**
 15    * A simple, generic pool class that can be used to pool any kind of object.
 16    * Objects can be released to this pool, either individually or as a
 17    * Collection, and then later acquired again. It is not necessary for an
 18    * object to have been originally acquired from the pool in order for it to
 19    * be released to the pool. If there are no objects present in the pool,
 20    * an attempt to acquire one will return null. The number of objects
 21    * available in the pool can be determined with the size() method. Finally,
 22    * it should be noted that the pool does not attempt to perform any kind
 23    * of cleanup or re-initialization on the objects to restore them to some
 24    * clean state when they are released to the pool; it's up to the user to
 25    * reset any necessary state in the object prior to the release call (or
 26    * just after the acquire call).
 27    *
 28    * @author Neil Rotstan
 29    * @author Klaus Meffert
 30    * @since 1.0
 31    */
 32    public class Pool {
 33   
 34    /** String containing the CVS revision. Read out via reflection!*/
 35    private final static String CVS_REVISION = "$Revision: 1.7 $";
 36   
 37    /**
 38    * The List of Objects currently in the pool.
 39    */
 40    private List m_pooledObjects;
 41   
 42    /**
 43    * Constructor.
 44    *
 45    * @author Neil Rotstan
 46    * @since 1.0
 47    */
 48  2446 public Pool() {
 49  2446 m_pooledObjects = Collections.synchronizedList(new ArrayList());
 50    }
 51   
 52    /**
 53    * Attempts to acquire an Object instance from the pool. It should
 54    * be noted that no cleanup or re-initialization occurs on these
 55    * objects, so it's up to the caller to reset the state of the
 56    * returned Object if that's desirable.
 57    *
 58    * @return an Object instance from the pool or null if no Object instances
 59    * are available in the pool
 60    *
 61    * @author Neil Rotstan
 62    * @since 1.0
 63    */
 64  19634 public synchronized Object acquirePooledObject() {
 65  19634 if (m_pooledObjects.isEmpty()) {
 66  19629 return null;
 67    }
 68    else {
 69    // Remove the last Object in the pool and return it.
 70    // Note that removing the last Object (as opposed to the first
 71    // one) is an optimization because it prevents the ArrayList
 72    // from resizing itself.
 73    // -----------------------------------------------------------
 74  5 return m_pooledObjects.remove(m_pooledObjects.size() - 1);
 75    }
 76    }
 77   
 78    /**
 79    * Releases an Object to the pool. It's not required that the Object
 80    * originated from the pool--any Object can be released to it.
 81    *
 82    * @param a_objectToPool the Object instance to be released into the pool
 83    *
 84    * @author Neil Rotstan
 85    * @since 1.0
 86    */
 87  9 public synchronized void releaseObject(final Object a_objectToPool) {
 88  9 m_pooledObjects.add(a_objectToPool);
 89    }
 90   
 91    /**
 92    * Releases a Collection of objects to the pool. It's not required that
 93    * the objects in the Collection originated from the pool--any objects
 94    * can be released to it.
 95    *
 96    * @param a_objectsToPool the Collection of objects to release into the pool
 97    *
 98    * @author Neil Rotstan
 99    * @since 1.0
 100    */
 101  7 public synchronized void releaseAllObjects(final Collection a_objectsToPool) {
 102  7 if (a_objectsToPool != null) {
 103  6 m_pooledObjects.addAll(a_objectsToPool);
 104    }
 105    }
 106   
 107    /**
 108    * Retrieves the number of objects currently available in this pool.
 109    *
 110    * @return the number of objects in this pool
 111    *
 112    * @author Neil Rotstan
 113    * @since 1.0
 114    */
 115  11 public synchronized int size() {
 116  11 return m_pooledObjects.size();
 117    }
 118   
 119    /**
 120    * Empties out this pool of all objects.
 121    *
 122    * @author Neil Rotstan
 123    * @since 1.0
 124    */
 125  2 public synchronized void clear() {
 126  2 m_pooledObjects.clear();
 127    }
 128    }