commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From simonetrip...@apache.org
Subject svn commit: r1053553 - in /commons/proper/pool/trunk/src: java/org/apache/commons/pool2/PoolUtils.java test/org/apache/commons/pool2/TestKeyedObjectPoolFactory.java test/org/apache/commons/pool2/TestPoolUtils.java
Date Wed, 29 Dec 2010 07:05:50 GMT
Author: simonetripodi
Date: Wed Dec 29 07:05:49 2010
New Revision: 1053553

URL: http://svn.apache.org/viewvc?rev=1053553&view=rev
Log:
According to what discussed and agreed on ML, pool/factory implementations below (and related
utility methods) can be removed from PoolUtils

 * PoolableObjectFactoryAdaptor
 * KeyedPoolableObjectFactoryAdaptor
 * ObjectPoolAdaptor
 * KeyedObjectPoolAdaptor
 * CheckedObjectPool
 * CheckedKeyedObjectPool

Modified:
    commons/proper/pool/trunk/src/java/org/apache/commons/pool2/PoolUtils.java
    commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestKeyedObjectPoolFactory.java
    commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java

Modified: commons/proper/pool/trunk/src/java/org/apache/commons/pool2/PoolUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/java/org/apache/commons/pool2/PoolUtils.java?rev=1053553&r1=1053552&r2=1053553&view=diff
==============================================================================
--- commons/proper/pool/trunk/src/java/org/apache/commons/pool2/PoolUtils.java (original)
+++ commons/proper/pool/trunk/src/java/org/apache/commons/pool2/PoolUtils.java Wed Dec 29
07:05:49 2010
@@ -70,129 +70,6 @@ public final class PoolUtils {
     }
 
     /**
-     * Adapt a <code>KeyedPoolableObjectFactory</code> instance to work where
a <code>PoolableObjectFactory</code> is
-     * needed. This method is the equivalent of calling
-     * {@link #adapt(KeyedPoolableObjectFactory, Object) PoolUtils.adapt(aKeyedPoolableObjectFactory,
new Object())}.
-     *
-     * @param keyedFactory the {@link KeyedPoolableObjectFactory} to delegate to.
-     * @return a {@link PoolableObjectFactory} that delegates to <code>keyedFactory</code>
with an internal key.
-     * @throws IllegalArgumentException when <code>keyedFactory</code> is <code>null</code>.
-     * @see #adapt(KeyedPoolableObjectFactory, Object)
-     * @since Pool 1.3
-     */
-    public static <V> PoolableObjectFactory<V> adapt(final KeyedPoolableObjectFactory<Object,V>
keyedFactory) throws IllegalArgumentException {
-        return adapt(keyedFactory, new Object());
-    }
-
-    /**
-     * Adapt a <code>KeyedPoolableObjectFactory</code> instance to work where
a <code>PoolableObjectFactory</code> is
-     * needed using the specified <code>key</code> when delegating.
-     *
-     * @param keyedFactory the {@link KeyedPoolableObjectFactory} to delegate to.
-     * @param key the key to use when delegating.
-     * @return a {@link PoolableObjectFactory} that delegates to <code>keyedFactory</code>
with the specified key.
-     * @throws IllegalArgumentException when <code>keyedFactory</code> or <code>key</code>
is <code>null</code>.
-     * @see #adapt(KeyedPoolableObjectFactory)
-     * @since Pool 1.3
-     */
-    public static <K,V> PoolableObjectFactory<V> adapt(final KeyedPoolableObjectFactory<K,V>
 keyedFactory, final K key) throws IllegalArgumentException {
-        return new PoolableObjectFactoryAdaptor<K,V>(keyedFactory, key);
-    }
-
-    /**
-     * Adapt a <code>PoolableObjectFactory</code> instance to work where a <code>KeyedPoolableObjectFactory</code>
is
-     * needed. The key is ignored.
-     *
-     * @param factory the {@link PoolableObjectFactory} to delegate to.
-     * @return a {@link KeyedPoolableObjectFactory} that delegates to <code>factory</code>
ignoring the key.
-     * @throws IllegalArgumentException when <code>factory</code> is <code>null</code>.
-     * @since Pool 1.3
-     */
-    public static <V> KeyedPoolableObjectFactory<Object,V> adapt(final PoolableObjectFactory<V>
factory) throws IllegalArgumentException {
-        return new KeyedPoolableObjectFactoryAdaptor<Object,V>(factory);
-    }
-
-    /**
-     * Adapt a <code>KeyedObjectPool</code> instance to work where an <code>ObjectPool</code>
is needed. This is the
-     * equivalent of calling {@link #adapt(KeyedObjectPool, Object) PoolUtils.adapt(aKeyedObjectPool,
new Object())}.
-     *
-     * @param keyedPool the {@link KeyedObjectPool} to delegate to.
-     * @return an {@link ObjectPool} that delegates to <code>keyedPool</code>
with an internal key.
-     * @throws IllegalArgumentException when <code>keyedPool</code> is <code>null</code>.
-     * @see #adapt(KeyedObjectPool, Object)
-     * @since Pool 1.3
-     */
-    public static <V> ObjectPool<V> adapt(final KeyedObjectPool<Object,V>
keyedPool) throws IllegalArgumentException {
-        return adapt(keyedPool, new Object());
-    }
-
-    /**
-     * Adapt a <code>KeyedObjectPool</code> instance to work where an <code>ObjectPool</code>
is needed using the
-     * specified <code>key</code> when delegating.
-     *
-     * @param keyedPool the {@link KeyedObjectPool} to delegate to.
-     * @param key the key to use when delegating.
-     * @return an {@link ObjectPool} that delegates to <code>keyedPool</code>
with the specified key.
-     * @throws IllegalArgumentException when <code>keyedPool</code> or <code>key</code>
is <code>null</code>.
-     * @see #adapt(KeyedObjectPool)
-     * @since Pool 1.3
-     */
-    public static <K,V> ObjectPool<V> adapt(final KeyedObjectPool<K,V>
keyedPool, final K key) throws IllegalArgumentException {
-        return new ObjectPoolAdaptor<K,V>(keyedPool, key);
-    }
-
-    /**
-     * Adapt an <code>ObjectPool</code> to work where an <code>KeyedObjectPool</code>
is needed.
-     * The key is ignored.
-     *
-     * @param pool the {@link ObjectPool} to delegate to.
-     * @return a {@link KeyedObjectPool} that delegates to <code>pool</code>
ignoring the key.
-     * @throws IllegalArgumentException when <code>pool</code> is <code>null</code>.
-     * @since Pool 1.3
-     */
-    public static <K,V> KeyedObjectPool<K,V> adapt(final ObjectPool<V>
pool) throws IllegalArgumentException {
-        return new KeyedObjectPoolAdaptor<K,V>(pool);
-    }
-
-    /**
-     * Wraps an <code>ObjectPool</code> and dynamically checks the type of objects
borrowed and returned to the pool.
-     * If an object is passed to the pool that isn't of type <code>type</code>
a {@link ClassCastException} will be thrown.
-     *
-     * @param pool the pool to enforce type safety on
-     * @param type the class type to enforce.
-     * @return an <code>ObjectPool</code> that will only allow objects of <code>type</code>
-     * @since Pool 1.3
-     */
-    public static ObjectPool<Object> checkedPool(final ObjectPool<? super Object>
pool, final Class<?> type) {
-        if (pool == null) {
-            throw new IllegalArgumentException("pool must not be null.");
-        }
-        if (type == null) {
-            throw new IllegalArgumentException("type must not be null.");
-        }
-        return new CheckedObjectPool(pool, type);
-    }
-
-    /**
-     * Wraps a <code>KeyedObjectPool</code> and dynamically checks the type of
objects borrowed and returned to the keyedPool.
-     * If an object is passed to the keyedPool that isn't of type <code>type</code>
a {@link ClassCastException} will be thrown.
-     *
-     * @param keyedPool the keyedPool to enforce type safety on
-     * @param type the class type to enforce.
-     * @return a <code>KeyedObjectPool</code> that will only allow objects of
<code>type</code>
-     * @since Pool 1.3
-     */
-    public static KeyedObjectPool<Object,Object> checkedPool(final KeyedObjectPool<?
super Object,? super Object> keyedPool, final Class<?> type) {
-        if (keyedPool == null) {
-            throw new IllegalArgumentException("keyedPool must not be null.");
-        }
-        if (type == null) {
-            throw new IllegalArgumentException("type must not be null.");
-        }
-        return new CheckedKeyedObjectPool(keyedPool, type);
-    }
-
-    /**
      * Periodically check the idle object count for the pool. At most one idle object will
be added per period.
      * If there is an exception when calling {@link ObjectPool#addObject()} then no more
checks will be performed.
      *
@@ -566,737 +443,6 @@ public final class PoolUtils {
     }
 
     /**
-     * Adaptor class that wraps and converts a KeyedPoolableObjectFactory with a fixed
-     * key to a PoolableObjectFactory.
-     */
-    private static class PoolableObjectFactoryAdaptor<K,V> implements PoolableObjectFactory<V>
{
-        /** Fixed key */
-        private final K key;
-
-        /** Wrapped factory */
-        private final KeyedPoolableObjectFactory<K,V> keyedFactory;
-
-        /**
-         * Create a PoolableObjectFactoryAdaptor wrapping the provided KeyedPoolableObjectFactory
with the 
-         * given fixed key.
-         * 
-         * @param keyedFactory KeyedPoolableObjectFactory that will manage objects
-         * @param key fixed key
-         * @throws IllegalArgumentException if either of the parameters is null
-         */
-        PoolableObjectFactoryAdaptor(final KeyedPoolableObjectFactory<K,V> keyedFactory,
final K key)
-        throws IllegalArgumentException {
-            if (keyedFactory == null) {
-                throw new IllegalArgumentException("keyedFactory must not be null.");
-            }
-            if (key == null) {
-                throw new IllegalArgumentException("key must not be null.");
-            }
-            this.keyedFactory = keyedFactory;
-            this.key = key;
-        }
-
-        /**
-         * Create an object instance using the configured factory and key.
-         * 
-         * @return new object instance
-         */
-        public V makeObject() throws Exception {
-            return keyedFactory.makeObject(key);
-        }
-
-        /**
-         * Destroy the object, passing the fixed key to the factory.
-         * 
-         * @param obj object to destroy
-         */
-        public void destroyObject(final V obj) throws Exception {
-            keyedFactory.destroyObject(key, obj);
-        }
-
-        /**
-         * Validate the object, passing the fixed key to the factory.
-         * 
-         * @param obj object to validate
-         * @return true if validation is successful
-         */
-        public boolean validateObject(final V obj) {
-            return keyedFactory.validateObject(key, obj);
-        }
-
-        /**
-         * Activate the object, passing the fixed key to the factory.
-         * 
-         * @param obj object to activate
-         */
-        public void activateObject(final V obj) throws Exception {
-            keyedFactory.activateObject(key, obj);
-        }
-
-        /**
-         * Passivate the object, passing the fixed key to the factory.
-         * 
-         * @param obj object to passivate
-         */
-        public void passivateObject(final V obj) throws Exception {
-            keyedFactory.passivateObject(key, obj);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        @Override
-        public String toString() {
-            final StringBuffer sb = new StringBuffer();
-            sb.append("PoolableObjectFactoryAdaptor");
-            sb.append("{key=").append(key);
-            sb.append(", keyedFactory=").append(keyedFactory);
-            sb.append('}');
-            return sb.toString();
-        }
-    }
-
-    /**
-     * Adaptor class that turns a PoolableObjectFactory into a KeyedPoolableObjectFactory
by
-     * ignoring keys.
-     */
-    private static class KeyedPoolableObjectFactoryAdaptor<K,V> implements KeyedPoolableObjectFactory<K,V>
{
-
-        /** Underlying PoolableObjectFactory */
-        private final PoolableObjectFactory<V> factory;
-
-        /**
-         * Create a new KeyedPoolableObjectFactoryAdaptor using the given PoolableObjectFactory
to
-         * manage objects.
-         * 
-         * @param factory wrapped PoolableObjectFactory 
-         * @throws IllegalArgumentException if the factory is null
-         */
-        KeyedPoolableObjectFactoryAdaptor(final PoolableObjectFactory<V> factory) throws
IllegalArgumentException {
-            if (factory == null) {
-                throw new IllegalArgumentException("factory must not be null.");
-            }
-            this.factory = factory;
-        }
-
-        /**
-         * Create a new object instance, ignoring the key
-         * 
-         * @param key ignored
-         * @return newly created object instance
-         */
-        public V makeObject(final K key) throws Exception {
-            return factory.makeObject();
-        }
-
-        /**
-         * Destroy the object, ignoring the key.
-         * 
-         * @param key ignored
-         * @param obj instance to destroy
-         */
-        public void destroyObject(final K key, final V obj) throws Exception {
-            factory.destroyObject(obj);
-        }
-
-        /**
-         * Validate the object, ignoring the key
-         * 
-         * @param key ignored
-         * @param obj object to validate
-         * @return true if validation is successful
-         */
-        public boolean validateObject(final K key, final V obj) {
-            return factory.validateObject(obj);
-        }
-
-        /**
-         * Activate the object, ignoring the key.
-         * 
-         * @param key ignored
-         * @param obj object to be activated
-         */
-        public void activateObject(final K key, final V obj) throws Exception {
-            factory.activateObject(obj);
-        }
-
-        /**
-         * Passivate the object, ignoring the key.
-         * 
-         * @param key ignored
-         * @param obj object to passivate
-         */
-        public void passivateObject(final K key, final V obj) throws Exception {
-            factory.passivateObject(obj);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        @Override
-        public String toString() {
-            final StringBuffer sb = new StringBuffer();
-            sb.append("KeyedPoolableObjectFactoryAdaptor");
-            sb.append("{factory=").append(factory);
-            sb.append('}');
-            return sb.toString();
-        }
-    }
-
-    /**
-     * Adapts a KeyedObjectPool to make it an ObjectPool by fixing restricting to
-     * a fixed key.
-     */
-    private static class ObjectPoolAdaptor<K,V> implements ObjectPool<V> {
-
-        /** Fixed key */
-        private final K key;
-
-        /** Underlying KeyedObjectPool */
-        private final KeyedObjectPool<K,V> keyedPool;
-
-        /**
-         * Create a new ObjectPoolAdaptor using the provided KeyedObjectPool and fixed key.
-         * 
-         * @param keyedPool underlying KeyedObjectPool
-         * @param key fixed key
-         * @throws IllegalArgumentException if either of the parameters is null
-         */
-        ObjectPoolAdaptor(final KeyedObjectPool<K,V> keyedPool, final K key) throws
IllegalArgumentException {
-            if (keyedPool == null) {
-                throw new IllegalArgumentException("keyedPool must not be null.");
-            }
-            if (key == null) {
-                throw new IllegalArgumentException("key must not be null.");
-            }
-            this.keyedPool = keyedPool;
-            this.key = key;
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public V borrowObject() throws Exception, NoSuchElementException, IllegalStateException
{
-            return keyedPool.borrowObject(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void returnObject(final V obj) {
-            try {
-                keyedPool.returnObject(key, obj);
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void invalidateObject(final V obj) {
-            try {
-                keyedPool.invalidateObject(key, obj);
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void addObject() throws Exception, IllegalStateException {
-            keyedPool.addObject(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumIdle() throws UnsupportedOperationException {
-            return keyedPool.getNumIdle(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumActive() throws UnsupportedOperationException {
-            return keyedPool.getNumActive(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void clear() throws Exception, UnsupportedOperationException {
-            keyedPool.clear();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void close() {
-            try {
-                keyedPool.close();
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        @Override
-        public String toString() {
-            final StringBuffer sb = new StringBuffer();
-            sb.append("ObjectPoolAdaptor");
-            sb.append("{key=").append(key);
-            sb.append(", keyedPool=").append(keyedPool);
-            sb.append('}');
-            return sb.toString();
-        }
-    }
-
-    /**
-     * Adapts an ObjectPool to implement KeyedObjectPool by ignoring key arguments.
-     */
-    private static class KeyedObjectPoolAdaptor<K,V> implements KeyedObjectPool<K,V>
{
-
-        /** Underlying pool */
-        private final ObjectPool<V> pool;
-
-        /**
-         * Create a new KeyedObjectPoolAdaptor wrapping the given ObjectPool
-         * 
-         * @param pool underlying object pool
-         * @throws IllegalArgumentException if pool is null
-         */
-        KeyedObjectPoolAdaptor(final ObjectPool<V> pool) throws IllegalArgumentException
{
-            if (pool == null) {
-                throw new IllegalArgumentException("pool must not be null.");
-            }
-            this.pool = pool;
-        }
-
-        /**
-         * Borrow and object from the pool, ignoring the key
-         * 
-         * @param key ignored
-         * @return newly created object instance
-         */
-        public V borrowObject(final K key) throws Exception, NoSuchElementException, IllegalStateException
{
-            return pool.borrowObject();
-        }
-
-        /**
-         * Return and object to the pool, ignoring the key
-         * 
-         * @param key ignored
-         * @param obj object to return
-         */
-        public void returnObject(final K key, final V obj) {
-            try {
-                pool.returnObject(obj);
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * Invalidate and object, ignoring the key
-         * 
-         * @param obj object to invalidate
-         * @param key ignored
-         */
-        public void invalidateObject(final K key, final V obj) {
-            try {
-                pool.invalidateObject(obj);
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * Add an object to the pool, ignoring the key
-         * 
-         * @param key ignored
-         */
-        public void addObject(final Object key) throws Exception, IllegalStateException {
-            pool.addObject();
-        }
-
-        /**
-         * Return the number of objects idle in the pool, ignoring the key.
-         * 
-         * @param key ignored
-         * @return idle instance count
-         */
-        public int getNumIdle(final Object key) throws UnsupportedOperationException {
-            return pool.getNumIdle();
-        }
-
-        /**
-         * Return the number of objects checked out from the pool, ignoring the key.
-         * 
-         * @param key ignored
-         * @return active instance count
-         */
-        public int getNumActive(final Object key) throws UnsupportedOperationException {
-            return pool.getNumActive();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumIdle() throws UnsupportedOperationException {
-            return pool.getNumIdle();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumActive() throws UnsupportedOperationException {
-            return pool.getNumActive();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void clear() throws Exception, UnsupportedOperationException {
-            pool.clear();
-        }
-
-        /**
-         * Clear the pool, ignoring the key (has same effect as {@link #clear()}.
-         * 
-         * @param key ignored.
-         */
-        public void clear(final K key) throws Exception, UnsupportedOperationException {
-            pool.clear();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void close() {
-            try {
-                pool.close();
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        @Override
-        public String toString() {
-            final StringBuffer sb = new StringBuffer();
-            sb.append("KeyedObjectPoolAdaptor");
-            sb.append("{pool=").append(pool);
-            sb.append('}');
-            return sb.toString();
-        }
-    }
-
-    /**
-     * An object pool that performs type checking on objects passed
-     * to pool methods.
-     *
-     */
-    private static class CheckedObjectPool implements ObjectPool<Object> {
-        /** 
-         * Type of objects allowed in the pool. This should be a subtype of the return type
of
-         * the underlying pool's associated object factory.
-         */
-        private final Class<?> type;
-
-        /** Underlying object pool */
-        private final ObjectPool<? super Object> pool;
-
-        /**
-         * Create a CheckedObjectPool accepting objects of the given type using
-         * the given pool.
-         * 
-         * @param pool underlying object pool
-         * @param type expected pooled object type
-         * @throws IllegalArgumentException if either parameter is null
-         */
-        CheckedObjectPool(final ObjectPool<? super Object> pool, final Class<?>
type) {
-            if (pool == null) {
-                throw new IllegalArgumentException("pool must not be null.");
-            }
-            if (type == null) {
-                throw new IllegalArgumentException("type must not be null.");
-            }
-            this.pool = pool;
-            this.type = type;
-        }
-
-        /**
-         * Borrow an object from the pool, checking its type.
-         * 
-         * @return a type-checked object from the pool
-         * @throws ClassCastException if the object returned by the pool is not of the expected
type
-         */
-        public Object borrowObject() throws Exception, NoSuchElementException, IllegalStateException
{
-            final Object obj = pool.borrowObject();
-            if (type.isInstance(obj)) {
-                return obj;
-            } else {
-                throw new ClassCastException("Borrowed object is not of type: " + type.getName()
+ " was: " + obj);
-            }
-        }
-
-        /**
-         * Return an object to the pool, verifying that it is of the correct type.
-         * 
-         * @param obj object to return
-         * @throws ClassCastException if obj is not of the expected type
-         */
-        public void returnObject(final Object obj) {
-            if (type.isInstance(obj)) {
-                try {
-                    pool.returnObject(obj);
-                } catch (Exception e) {
-                    // swallowed as of Pool 2
-                }
-            } else {
-                throw new ClassCastException("Returned object is not of type: " + type.getName()
+ " was: " + obj);
-            }
-        }
-
-        /**
-         * Invalidates an object from the pool, verifying that it is of the expected type.
-         * 
-         * @param obj object to invalidate
-         * @throws ClassCastException if obj is not of the expected type
-         */
-        public void invalidateObject(final Object obj) {
-            if (type.isInstance(obj)) {
-                try {
-                    pool.invalidateObject(obj);
-                } catch (Exception e) {
-                    // swallowed as of Pool 2
-                }
-            } else {
-                throw new ClassCastException("Invalidated object is not of type: " + type.getName()
+ " was: " + obj);
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void addObject() throws Exception, IllegalStateException, UnsupportedOperationException
{
-            pool.addObject();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumIdle() throws UnsupportedOperationException {
-            return pool.getNumIdle();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumActive() throws UnsupportedOperationException {
-            return pool.getNumActive();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void clear() throws Exception, UnsupportedOperationException {
-            pool.clear();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void close() {
-            try {
-                pool.close();
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        @Override
-        public String toString() {
-            final StringBuffer sb = new StringBuffer();
-            sb.append("CheckedObjectPool");
-            sb.append("{type=").append(type);
-            sb.append(", pool=").append(pool);
-            sb.append('}');
-            return sb.toString();
-        }
-    }
-
-    /**
-     * A keyed object pool that performs type checking on objects passed
-     * to pool methods.
-     *
-     */
-    private static class CheckedKeyedObjectPool implements KeyedObjectPool<Object,Object>
{
-        /** 
-         * Expected type of objects managed by the pool.  This should be
-         * a subtype of the return type of the object factory used by the pool.
-         */
-        private final Class<?> type;
-
-        /** Underlying pool */
-        private final KeyedObjectPool<? super Object,? super Object> keyedPool;
-
-        /**
-         * Create a new CheckedKeyedObjectPool from the given pool with given expected object
type.
-         * 
-         * @param keyedPool underlying pool
-         * @param type expected object type
-         * @throws IllegalArgumentException if either parameter is null
-         */
-        CheckedKeyedObjectPool(final KeyedObjectPool<? super Object,? super Object>
keyedPool, final Class<?> type) {
-            if (keyedPool == null) {
-                throw new IllegalArgumentException("keyedPool must not be null.");
-            }
-            if (type == null) {
-                throw new IllegalArgumentException("type must not be null.");
-            }
-            this.keyedPool = keyedPool;
-            this.type = type;
-        }
-
-        /**
-         * Borrow an object from the pool, verifying correct return type.
-         * 
-         * @param key pool key
-         * @return type-checked object from the pool under the given key
-         * @throws ClassCastException if the object returned by the pool is not of the expected
type
-         */
-        public Object borrowObject(final Object key) throws Exception, NoSuchElementException,
IllegalStateException {
-            Object obj = keyedPool.borrowObject(key);
-            if (type.isInstance(obj)) {
-                return obj;
-            } else {
-                throw new ClassCastException("Borrowed object for key: " + key + " is not
of type: " + type.getName() + " was: " + obj);
-            }
-        }
-
-        /**
-         * Return an object to the pool, checking its type.
-         * 
-         * @param key the associated key (not type-checked)
-         * @param obj the object to return (type-checked)
-         * @throws ClassCastException if obj is not of the expected type
-         */
-        public void returnObject(final Object key, final Object obj) {
-            if (type.isInstance(obj)) {
-                try {
-                    keyedPool.returnObject(key, obj);
-                } catch (Exception e) {
-                    // swallowed as of Pool 2
-                }
-            } else {
-                throw new ClassCastException("Returned object for key: " + key + " is not
of type: " + type.getName() + " was: " + obj);
-            }
-        }
-
-        /**
-         * Invalidate an object to the pool, checking its type.
-         * 
-         * @param key the associated key (not type-checked)
-         * @param obj the object to return (type-checked)
-         * @throws ClassCastException if obj is not of the expected type
-         */
-        public void invalidateObject(final Object key, final Object obj) {
-            if (type.isInstance(obj)) {
-                try {
-                    keyedPool.invalidateObject(key, obj);
-                } catch (Exception e) {
-                    // swallowed as of Pool 2
-                }
-            } else {
-                throw new ClassCastException("Invalidated object for key: " + key + " is
not of type: " + type.getName() + " was: " + obj);
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void addObject(final Object key) throws Exception, IllegalStateException,
UnsupportedOperationException {
-            keyedPool.addObject(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumIdle(final Object key) throws UnsupportedOperationException {
-            return keyedPool.getNumIdle(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumActive(final Object key) throws UnsupportedOperationException {
-            return keyedPool.getNumActive(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumIdle() throws UnsupportedOperationException {
-            return keyedPool.getNumIdle();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public int getNumActive() throws UnsupportedOperationException {
-            return keyedPool.getNumActive();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void clear() throws Exception, UnsupportedOperationException {
-            keyedPool.clear();
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void clear(final Object key) throws Exception, UnsupportedOperationException
{
-            keyedPool.clear(key);
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        public void close() {
-            try {
-                keyedPool.close();
-            } catch (Exception e) {
-                // swallowed as of Pool 2
-            }
-        }
-
-        /**
-         * {@inheritDoc}
-         */
-        @Override
-        public String toString() {
-            final StringBuffer sb = new StringBuffer();
-            sb.append("CheckedKeyedObjectPool");
-            sb.append("{type=").append(type);
-            sb.append(", keyedPool=").append(keyedPool);
-            sb.append('}');
-            return sb.toString();
-        }
-    }
-
-    /**
      * Timer task that adds objects to the pool until the number of idle
      * instances reaches the configured minIdle.  Note that this is not the
      * same as the pool's minIdle setting.

Modified: commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestKeyedObjectPoolFactory.java
URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestKeyedObjectPoolFactory.java?rev=1053553&r1=1053552&r2=1053553&view=diff
==============================================================================
--- commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestKeyedObjectPoolFactory.java
(original)
+++ commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestKeyedObjectPoolFactory.java
Wed Dec 29 07:05:49 2010
@@ -17,10 +17,6 @@
 
 package org.apache.commons.pool2;
 
-import org.apache.commons.pool2.KeyedObjectPool;
-import org.apache.commons.pool2.KeyedObjectPoolFactory;
-import org.apache.commons.pool2.KeyedPoolableObjectFactory;
-import org.apache.commons.pool2.PoolUtils;
 import org.junit.Test;
 
 /**
@@ -43,7 +39,31 @@ public abstract class TestKeyedObjectPoo
     protected abstract KeyedObjectPoolFactory<Object,Object> makeFactory(KeyedPoolableObjectFactory<Object,Object>
objectFactory) throws UnsupportedOperationException;
 
     protected static KeyedPoolableObjectFactory<Object,Object> createObjectFactory()
{
-        return PoolUtils.adapt(new MethodCallPoolableObjectFactory());
+        return new KeyedPoolableObjectFactory<Object, Object>() {
+
+            private final MethodCallPoolableObjectFactory wrapped = new MethodCallPoolableObjectFactory();
+
+            public Object makeObject(Object key) throws Exception {
+                return this.wrapped.makeObject();
+            }
+
+            public void destroyObject(Object key, Object obj) throws Exception {
+                this.wrapped.destroyObject(obj);
+            }
+
+            public boolean validateObject(Object key, Object obj) {
+                return this.wrapped.validateObject(obj);
+            }
+
+            public void activateObject(Object key, Object obj) throws Exception {
+                this.wrapped.activateObject(obj);
+            }
+
+            public void passivateObject(Object key, Object obj) throws Exception {
+                this.wrapped.passivateObject(obj);
+            }
+
+        };
     }
 
     @Test

Modified: commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java?rev=1053553&r1=1053552&r2=1053553&view=diff
==============================================================================
--- commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java (original)
+++ commons/proper/pool/trunk/src/test/org/apache/commons/pool2/TestPoolUtils.java Wed Dec
29 07:05:49 2010
@@ -34,13 +34,6 @@ import java.util.TimerTask;
 
 import junit.framework.AssertionFailedError;
 
-import org.apache.commons.pool2.BaseKeyedObjectPool;
-import org.apache.commons.pool2.BaseObjectPool;
-import org.apache.commons.pool2.KeyedObjectPool;
-import org.apache.commons.pool2.KeyedPoolableObjectFactory;
-import org.apache.commons.pool2.ObjectPool;
-import org.apache.commons.pool2.PoolUtils;
-import org.apache.commons.pool2.PoolableObjectFactory;
 import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
 import org.apache.commons.pool2.impl.GenericObjectPool;
 import org.junit.Test;
@@ -67,219 +60,6 @@ public class TestPoolUtils {
     }
 
     @Test
-    public void testAdaptKeyedPoolableObjectFactory() throws Exception {
-        try {
-            PoolUtils.adapt((KeyedPoolableObjectFactory<Object,Object>)null);
-            fail("PoolUtils.adapt(KeyedPoolableObjectFactory) must not allow null factory.");
-        } catch (IllegalArgumentException iae) {
-            // expected
-        }
-    }
-
-    @Test
-    public void testAdaptKeyedPoolableObjectFactoryKey() throws Exception {
-        try {
-            PoolUtils.adapt((KeyedPoolableObjectFactory<Object,Object>)null, new Object());
-            fail("PoolUtils.adapt(KeyedPoolableObjectFactory, key) must not allow null factory.");
-        } catch (IllegalArgumentException iae) {
-            // expected
-        }
-        try {
-            PoolUtils.adapt((KeyedPoolableObjectFactory<Object,Object>)createProxy(KeyedPoolableObjectFactory.class,
(List<String>)null), null);
-            fail("PoolUtils.adapt(KeyedPoolableObjectFactory, key) must not allow null key.");
-        } catch (IllegalArgumentException iae) {
-            // expected
-        }
-
-        final List<String> calledMethods = new ArrayList<String>();
-        final KeyedPoolableObjectFactory<Object,Object> kpof =
-                (KeyedPoolableObjectFactory<Object,Object>)createProxy(KeyedPoolableObjectFactory.class,
calledMethods);
-
-        final PoolableObjectFactory<Object> pof = PoolUtils.adapt(kpof);
-        final List<String> expectedMethods = invokeEveryMethod(pof);
-        assertEquals(expectedMethods, calledMethods);
-    }
-
-    @Test
-    public void testAdaptPoolableObjectFactory() throws Exception {
-        try {
-            PoolUtils.adapt((PoolableObjectFactory<Object>)null);
-            fail("PoolUtils.adapt(PoolableObjectFactory) must not allow null factory.");
-        } catch (IllegalArgumentException iae) {
-            // expected
-        }
-
-        final List<String> calledMethods = new ArrayList<String>();
-        final PoolableObjectFactory<Object> pof =
-                (PoolableObjectFactory<Object>)createProxy(PoolableObjectFactory.class,
calledMethods);
-
-        final KeyedPoolableObjectFactory<Object,Object> kpof = PoolUtils.adapt(pof);
-        final List<String> expectedMethods = invokeEveryMethod(kpof);
-        assertEquals(expectedMethods, calledMethods);
-    }
-
-    @Test
-    public void testAdaptKeyedObjectPool() throws Exception {
-        try {
-            PoolUtils.adapt((KeyedObjectPool<Object,Object>)null);
-            fail("PoolUtils.adapt(KeyedObjectPool) must not allow a null pool.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-    }
-
-    @Test
-    public void testAdaptKeyedObjectPoolKey() throws Exception {
-        try {
-            PoolUtils.adapt((KeyedObjectPool<Object,Object>)null, new Object());
-            fail("PoolUtils.adapt(KeyedObjectPool, key) must not allow a null pool.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-        try {
-            PoolUtils.adapt((KeyedObjectPool<Object,Object>)createProxy(KeyedObjectPool.class,
(List<String>)null), null);
-            fail("PoolUtils.adapt(KeyedObjectPool, key) must not allow a null key.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-
-        final List<String> calledMethods = new ArrayList<String>();
-        final KeyedObjectPool<Object,Object> kop = (KeyedObjectPool<Object,Object>)createProxy(KeyedObjectPool.class,
calledMethods);
-
-        final ObjectPool<Object> op = PoolUtils.adapt(kop, new Object());
-        final List<String> expectedMethods = invokeEveryMethod(op);
-        assertEquals(expectedMethods, calledMethods);
-    }
-
-    @Test
-    public void testAdaptObjectPool() throws Exception {
-        try {
-            PoolUtils.adapt((ObjectPool<Object>)null);
-            fail("PoolUtils.adapt(ObjectPool) must not allow a null pool.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-
-        final List<String> calledMethods = new ArrayList<String>();
-        final ObjectPool<Object> op = (ObjectPool<Object>)createProxy(ObjectPool.class,
calledMethods);
-
-        final KeyedObjectPool<Object,Object> kop = PoolUtils.adapt(op);
-        final List<String> expectedMethods = invokeEveryMethod(kop);
-        assertEquals(expectedMethods, calledMethods);
-    }
-
-    @Test
-    public void testCheckedPoolObjectPool() throws Exception {
-        try {
-            PoolUtils.checkedPool((ObjectPool<Object>)null, Object.class);
-            fail("PoolUtils.checkedPool(ObjectPool, Class) must not allow a null pool.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-        try {
-            PoolUtils.checkedPool((ObjectPool<Object>)createProxy(ObjectPool.class,
(List<String>)null), null);
-            fail("PoolUtils.checkedPool(ObjectPool, Class) must not allow a null type.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-
-        final List<String> calledMethods = new ArrayList<String>();
-        ObjectPool<Object> op = (ObjectPool<Object>)createProxy(ObjectPool.class,
calledMethods);
-
-        ObjectPool<Object> cop = PoolUtils.checkedPool(op, Object.class);
-        final List<String> expectedMethods = invokeEveryMethod(cop);
-        assertEquals(expectedMethods, calledMethods);
-
-        op = new BaseObjectPool<Object>() {
-            @Override
-            public Object borrowObject() throws Exception {
-                return new Integer(0);
-            }
-            @Override
-            public void returnObject(Object obj) {}
-            @Override
-            public void invalidateObject(Object obj) {}
-        };
-        cop = PoolUtils.checkedPool(op, String.class);
-
-        try {
-            cop.borrowObject();
-            fail("borrowObject should have failed as Integer !instanceof String.");
-        } catch (ClassCastException cce) {
-            // expected
-        }
-        try {
-            cop.returnObject(new Integer(1));
-            fail("returnObject should have failed as Integer !instanceof String.");
-        } catch (ClassCastException cce) {
-            // expected
-        }
-        try {
-            cop.invalidateObject(new Integer(2));
-            fail("invalidateObject should have failed as Integer !instanceof String.");
-        } catch (ClassCastException cce) {
-            // expected
-        }
-    }
-
-    @Test
-    public void testCheckedPoolKeyedObjectPool() throws Exception {
-        try {
-            PoolUtils.checkedPool((KeyedObjectPool<Object,Object>)null, Object.class);
-            fail("PoolUtils.checkedPool(KeyedObjectPool, Class) must not allow a null pool.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-        try {
-            PoolUtils.checkedPool((KeyedObjectPool<Object,Object>)createProxy(KeyedObjectPool.class,
(List<String>)null), null);
-            fail("PoolUtils.checkedPool(KeyedObjectPool, Class) must not allow a null type.");
-        } catch(IllegalArgumentException iae) {
-            // expected
-        }
-
-        final List<String> calledMethods = new ArrayList<String>();
-        KeyedObjectPool<Object,Object> op = (KeyedObjectPool<Object,Object>)createProxy(KeyedObjectPool.class,
calledMethods);
-
-        KeyedObjectPool<Object,Object> cop = PoolUtils.checkedPool(op, Object.class);
-        final List<String> expectedMethods = invokeEveryMethod(cop);
-        assertEquals(expectedMethods, calledMethods);
-
-
-        op = new BaseKeyedObjectPool<Object,Object>() {
-            @Override
-            public Object borrowObject(Object key) {
-                return new Integer(0);
-            }
-
-            @Override
-            public void returnObject(Object key, Object obj) {}
-
-            @Override
-            public void invalidateObject(Object key, Object obj) {}
-        };
-        cop = PoolUtils.checkedPool(op, String.class);
-
-        try {
-            cop.borrowObject(null);
-            fail("borrowObject should have failed as Integer !instanceof String.");
-        } catch (ClassCastException cce) {
-            // expected
-        }
-        try {
-            cop.returnObject(null, new Integer(1));
-            fail("returnObject should have failed as Integer !instanceof String.");
-        } catch (ClassCastException cce) {
-            // expected
-        }
-        try {
-            cop.invalidateObject(null, new Integer(2));
-            fail("invalidateObject should have failed as Integer !instanceof String.");
-        } catch (ClassCastException cce) {
-            // expected
-        }
-    }
-
-    @Test
     public void testCheckMinIdleObjectPool() throws Exception {
         try {
             PoolUtils.checkMinIdle(null, 1, 1);



Mime
View raw message