text:
package com.frameworkset.commons.pool;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Collections;

/**
 * This class consists exclusively of static methods that operate on or return ObjectPool
 * or KeyedObjectPool related interfaces.
 *
 * @author Sandy McArthur
 * @version $Revision: 777748 $ $Date: 2009-05-22 20:00:44 -0400 (Fri, 22 May 2009) $
 * @since Pool 1.3
 */
public final class PoolUtils {

    /**
     * Timer used to periodically check pools idle object count.
     * Because a {@link Timer} creates a {@link Thread} this is lazily instantiated.
     */
    private static Timer MIN_IDLE_TIMER;

    /**
     * PoolUtils instances should NOT be constructed in standard programming.
     * Instead, the class should be used procedurally: PoolUtils.adapt(aPool);.
     * This constructor is public to permit tools that require a JavaBean instance to operate.
     */
    public PoolUtils() {
    }

    /**
     * Adapt a KeyedPoolableObjectFactory instance to work where a PoolableObjectFactory 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 keyedFactory with an internal key.
     * @throws IllegalArgumentException when keyedFactory is null.
     * @see #adapt(KeyedPoolableObjectFactory, Object)
     * @since Pool 1.3
     */
    public static PoolableObjectFactory adapt(final KeyedPoolableObjectFactory keyedFactory) throws IllegalArgumentException {
        return adapt(keyedFactory, new Object());
    }

    /**
     * Adapt a KeyedPoolableObjectFactory instance to work where a PoolableObjectFactory is
     * needed using the specified key 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 keyedFactory with the specified key.
     * @throws IllegalArgumentException when keyedFactory or key is null.
     * @see #adapt(KeyedPoolableObjectFactory)
     * @since Pool 1.3
     */
    public static PoolableObjectFactory adapt(final KeyedPoolableObjectFactory keyedFactory, final Object key) throws IllegalArgumentException {
        return new PoolableObjectFactoryAdaptor(keyedFactory, key);
    }

    /**
     * Adapt a PoolableObjectFactory instance to work where a KeyedPoolableObjectFactory is
     * needed. The key is ignored.
     *
     * @param factory the {@link PoolableObjectFactory} to delegate to.
     * @return a {@link KeyedPoolableObjectFactory} that delegates to factory ignoring the key.
     * @throws IllegalArgumentException when factory is null.
     * @since Pool 1.3
     */
    public static KeyedPoolableObjectFactory adapt(final PoolableObjectFactory factory) throws IllegalArgumentException {
        return new KeyedPoolableObjectFactoryAdaptor(factory);
    }

    /**
     * Adapt a KeyedObjectPool instance to work where an ObjectPool 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 keyedPool with an internal key.
     * @throws IllegalArgumentException when keyedPool is null.
     * @see #adapt(KeyedObjectPool, Object)
     * @since Pool 1.3
     */
    public static ObjectPool adapt(final KeyedObjectPool keyedPool) throws IllegalArgumentException {
        return adapt(keyedPool, new Object());
    }

    /**
     * Adapt a KeyedObjectPool instance to work where an ObjectPool is needed using the
     * specified key 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 keyedPool with the specified key.
     * @throws IllegalArgumentException when keyedPool or key is null.
     * @see #adapt(KeyedObjectPool)
     * @since Pool 1.3
     */
    public static ObjectPool adapt(final KeyedObjectPool keyedPool, final Object key) throws IllegalArgumentException {
        return new ObjectPoolAdaptor(keyedPool, key);
    }

    /**
     * Adapt an ObjectPool to work where an KeyedObjectPool is needed.
     * The key is ignored.
     *
     * @param pool the {@link ObjectPool} to delegate to.
     * @return a {@link KeyedObjectPool} that delegates to pool ignoring the key.
     * @throws IllegalArgumentException when pool is null.
     * @since Pool 1.3
     */
    public static KeyedObjectPool adapt(final ObjectPool pool) throws IllegalArgumentException {
        return new KeyedObjectPoolAdaptor(pool);
    }

    /**
     * Wraps an ObjectPool 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 type a {@link ClassCastException} will be thrown.
     *
     * @param pool the pool to enforce type safety on
     * @param type the class type to enforce.
     * @return an ObjectPool that will only allow objects of type
     * @since Pool 1.3
     */
    public static ObjectPool checkedPool(final ObjectPool 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 KeyedObjectPool 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 type a {@link ClassCastException} will be thrown.
     *
     * @param keyedPool the keyedPool to enforce type safety on
     * @param type the class type to enforce.
     * @return a KeyedObjectPool that will only allow objects of type
     * @since Pool 1.3
     */
    public static KeyedObjectPool checkedPool(final KeyedObjectPool 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.
     *
     * @param pool the pool to check periodically.
     * @param minIdle if the {@link ObjectPool#getNumIdle()} is less than this then add an idle object.
     * @param period the frequency to check the number of idle objects in a pool, see
     *      {@link Timer#schedule(TimerTask, long, long)}.
     * @return the {@link TimerTask} that will periodically check the pools idle object count.
     * @throws IllegalArgumentException when pool is null or
     *      when minIdle is negative or when period isn't
     *      valid for {@link Timer#schedule(TimerTask, long, long)}.
     * @since Pool 1.3
     */
    public static TimerTask checkMinIdle(final ObjectPool pool, final int minIdle, final long period) throws IllegalArgumentException {
        if (pool == null) {
            throw new IllegalArgumentException("keyedPool must not be null.");
        }
        if (minIdle < 0) {
            throw new IllegalArgumentException("minIdle must be non-negative.");
        }
        final TimerTask task = new ObjectPoolMinIdleTimerTask(pool, minIdle);
        getMinIdleTimer().schedule(task, 0L, period);
        return task;
    }

    /**
     * Periodically check the idle object count for the key in the keyedPool. At most one idle object will be added per period.
     * If there is an exception when calling {@link KeyedObjectPool#addObject(Object)} then no more checks for that key
     * will be performed.
     *
     * @param keyedPool the keyedPool to check periodically.
     * @param key the key to check the idle count of.
     * @param minIdle if the {@link KeyedObjectPool#getNumIdle(Object)} is less than this then add an idle object.
     * @param period the frequency to check the number of idle objects in a keyedPool, see
     *      {@link Timer#schedule(TimerTask, long, long)}.
     * @return the {@link TimerTask} that will periodically check the pools idle object count.
     * @throws IllegalArgumentException when keyedPool, key is null or
     *      when minIdle is negative or when period isn't
     *      valid for {@link Timer#schedule(TimerTask, long, long)}.
     * @since Pool 1.3
     */
    public static TimerTask checkMinIdle(final KeyedObjectPool keyedPool, final Object key, final int minIdle, final long period) throws IllegalArgumentException {
        if (keyedPool == null) {
            throw new IllegalArgumentException("keyedPool must not be null.");
        }
        if (key == null) {
            throw new IllegalArgumentException("key must not be null.");
        }
        if (minIdle < 0) {
            throw new IllegalArgumentException("minIdle must be non-negative.");
        }
        final TimerTask task = new KeyedObjectPoolMinIdleTimerTask(keyedPool, key, minIdle);
        getMinIdleTimer().schedule(task, 0L, period);
        return task;
    }

    /**
     * Periodically check the idle object count for each key in the Collection keys in the keyedPool.
     * At most one idle object will be added per period.
     *
     * @param keyedPool the keyedPool to check periodically.
     * @param keys a collection of keys to check the idle object count.
     * @param minIdle if the {@link KeyedObjectPool#getNumIdle(Object)} is less than this then add an idle object.
     * @param period the frequency to check the number of idle objects in a keyedPool, see
     *      {@link Timer#schedule(TimerTask, long, long)}.
     * @return a {@link Map} of key and {@link TimerTask} pairs that will periodically check the pools idle object count.
     * @throws IllegalArgumentException when keyedPool, keys, or any of the values in the
     *      collection is null or when minIdle is negative or when period isn't
     *      valid for {@link Timer#schedule(TimerTask, long, long)}.
     * @see #checkMinIdle(KeyedObjectPool, Object, int, long)
     * @since Pool 1.3
     */
    public static Map checkMinIdle(final KeyedObjectPool keyedPool, final Collection keys, final int minIdle, final long period) throws IllegalArgumentException {
        if (keys == null) {
            throw new IllegalArgumentException("keys must not be null.");
        }
        final Map tasks = new HashMap(keys.size());
        final Iterator iter = keys.iterator();
        while (iter.hasNext()) {
            final Object key = iter.next();
            final TimerTask task = checkMinIdle(keyedPool, key, minIdle, period);
            tasks.put(key, task);
        }
        return tasks;
    }

    /**
     * Call addObject() on pool count number of times.
     *
     * @param pool the pool to prefill.
     * @param count the number of idle objects to add.
     * @throws Exception when {@link ObjectPool#addObject()} fails.
     * @throws IllegalArgumentException when pool is null.
     * @since Pool 1.3
     */
    public static void prefill(final ObjectPool pool, final int count) throws Exception, IllegalArgumentException {
        if (pool == null) {
            throw new IllegalArgumentException("pool must not be null.");
        }
        for (int i = 0; i < count; i++) {
            pool.addObject();
        }
    }

    /**
     * Call addObject(Object) on keyedPool with key count
     * number of times.
     *
     * @param keyedPool the keyedPool to prefill.
     * @param key the key to add objects for.
     * @param count the number of idle objects to add for key.
     * @throws Exception when {@link KeyedObjectPool#addObject(Object)} fails.
     * @throws IllegalArgumentException when keyedPool or key is null.
     * @since Pool 1.3
     */
    public static void prefill(final KeyedObjectPool keyedPool, final Object key, final int count) throws Exception, IllegalArgumentException {
        if (keyedPool == null) {
            throw new IllegalArgumentException("keyedPool must not be null.");
        }
        if (key == null) {
            throw new IllegalArgumentException("key must not be null.");
        }
        for (int i = 0; i < count; i++) {
            keyedPool.addObject(key);
        }
    }

    /**
     * Call addObject(Object) on keyedPool with each key in keys for
     * count number of times. This has the same effect as calling
     * {@link #prefill(KeyedObjectPool, Object, int)} for each key in the keys collection.
     *
     * @param keyedPool the keyedPool to prefill.
     * @param keys {@link Collection} of keys to add objects for.
     * @param count the number of idle objects to add for each key.
     * @throws Exception when {@link KeyedObjectPool#addObject(Object)} fails.
     * @throws IllegalArgumentException when keyedPool, keys, or
     *      any value in keys is null.
     * @see #prefill(KeyedObjectPool, Object, int)
     * @since Pool 1.3
     */
    public static void prefill(final KeyedObjectPool keyedPool, final Collection keys, final int count) throws Exception, IllegalArgumentException {
        if (keys == null) {
            throw new IllegalArgumentException("keys must not be null.");
        }
        final Iterator iter = keys.iterator();
        while (iter.hasNext()) {
            prefill(keyedPool, iter.next(), count);
        }
    }

    /**
     * Returns a synchronized (thread-safe) ObjectPool backed by the specified ObjectPool.
     *
     *
Note:
     * This should not be used on pool implementations that already provide proper synchronization
     * such as the pools provided in the Commons Pool library. Wrapping a pool that
     * {@link #wait() waits} for poolable objects to be returned before allowing another one to be
     * borrowed with another layer of synchronization will cause liveliness issues or a deadlock.
     *

     *
     * @param pool the ObjectPool to be "wrapped" in a synchronized ObjectPool.
     * @return a synchronized view of the specified ObjectPool.
     * @since Pool 1.3
     */
    public static ObjectPool synchronizedPool(final ObjectPool pool) {
        if (pool == null) {
            throw new IllegalArgumentException("pool must not be null.");
        }
        /*
        assert !(pool instanceof GenericObjectPool)
                : "GenericObjectPool is already thread-safe";
        assert !(pool instanceof SoftReferenceObjectPool)
                : "SoftReferenceObjectPool is already thread-safe";
        assert !(pool instanceof StackObjectPool)
                : "StackObjectPool is already thread-safe";
        assert !"com.frameworkset.commons.pool.composite.CompositeObjectPool".equals(pool.getClass().getName())
                : "CompositeObjectPools are already thread-safe";
        */
        return new SynchronizedObjectPool(pool);
    }

    /**
     * Returns a synchronized (thread-safe) KeyedObjectPool backed by the specified KeyedObjectPool.
     *
     *
Note:
     * This should not be used on pool implementations that already provide proper synchronization
     * such as the pools provided in the Commons Pool library. Wrapping a pool that
     * {@link #wait() waits} for poolable objects to be returned before allowing another one to be
     * borrowed with another layer of synchronization will cause liveliness issues or a deadlock.
     *

     *
     * @param keyedPool the KeyedObjectPool to be "wrapped" in a synchronized KeyedObjectPool.
     * @return a synchronized view of the specified KeyedObjectPool.
     * @since Pool 1.3
     */
    public static KeyedObjectPool synchronizedPool(final KeyedObjectPool keyedPool) {
        if (keyedPool == null) {
            throw new IllegalArgumentException("keyedPool must not be null.");
        }
        /*
        assert !(keyedPool instanceof GenericKeyedObjectPool)
                : "GenericKeyedObjectPool is already thread-safe";
        assert !(keyedPool instanceof StackKeyedObjectPool)
                : "StackKeyedObjectPool is already thread-safe";
        assert !"com.frameworkset.commons.pool.composite.CompositeKeyedObjectPool".equals(keyedPool.getClass().getName())
                : "CompositeKeyedObjectPools are already thread-safe";
        */
        return new SynchronizedKeyedObjectPool(keyedPool);
    }

    /**
     * Returns a synchronized (thread-safe) PoolableObjectFactory backed by the specified PoolableObjectFactory.
     *
     * @param factory the PoolableObjectFactory to be "wrapped" in a synchronized PoolableObjectFactory.
     * @return a synchronized view of the specified PoolableObjectFactory.
     * @since Pool 1.3
     */
    public static PoolableObjectFactory synchronizedPoolableFactory(final PoolableObjectFactory factory) {
        return new SynchronizedPoolableObjectFactory(factory);
    }

    /**
     * Returns a synchronized (thread-safe) KeyedPoolableObjectFactory backed by the specified KeyedPoolableObjectFactory.
     *
     * @param keyedFactory the KeyedPoolableObjectFactory to be "wrapped" in a synchronized KeyedPoolableObjectFactory.
     * @return a synchronized view of the specified KeyedPoolableObjectFactory.
     * @since Pool 1.3
     */
    public static KeyedPoolableObjectFactory synchronizedPoolableFactory(final KeyedPoolableObjectFactory keyedFactory) {
        return new SynchronizedKeyedPoolableObjectFactory(keyedFactory);
    }

    /**
     * Returns a pool that adaptively decreases it's size when idle objects are no longer needed.
     * This is intended as an always thread-safe alternative to using an idle object evictor
     * provided by many pool implementations. This is also an effective way to shrink FIFO ordered
     * pools that experience load spikes.
     *
     * @param pool the ObjectPool to be decorated so it shrinks it's idle count when possible.
     * @return a pool that adaptively decreases it's size when idle objects are no longer needed.
     * @see #erodingPool(ObjectPool, float)
     * @since Pool 1.4
     */
    public static ObjectPool erodingPool(final ObjectPool pool) {
        return erodingPool(pool, 1f);
    }

    /**
     * Returns a pool that adaptively decreases it's size when idle objects are no longer needed.
     * This is intended as an always thread-safe alternative to using an idle object evictor
     * provided by many pool implementations. This is also an effective way to shrink FIFO ordered
     * pools that experience load spikes.
     *
     *

     * The factor parameter provides a mechanism to tweak the rate at which the pool tries to shrink
     * it's size. Values between 0 and 1 cause the pool to try to shrink it's size more often.
     * Values greater than 1 cause the pool to less frequently try to shrink it's size.
     *

     *
     * @param pool the ObjectPool to be decorated so it shrinks it's idle count when possible.
     * @param factor a positive value to scale the rate at which the pool tries to reduce it's size.
     * If 0 < factor < 1 then the pool shrinks more aggressively.
     * If 1 < factor then the pool shrinks less aggressively.
     * @return a pool that adaptively decreases it's size when idle objects are no longer needed.
     * @see #erodingPool(ObjectPool)
     * @since Pool 1.4
     */
    public static ObjectPool erodingPool(final ObjectPool pool, final float factor) {
        if (pool == null) {
            throw new IllegalArgumentException("pool must not be null.");
        }
        if (factor <= 0f) {
            throw new IllegalArgumentException("factor must be positive.");
        }
        return new ErodingObjectPool(pool, factor);
    }

    /**
     * Returns a pool that adaptively decreases it's size when idle objects are no longer needed.
     * This is intended as an always thread-safe alternative to using an idle object evictor
     * provided by many pool implementations. This is also an effective way to shrink FIFO ordered
     * pools that experience load spikes.
     *
     * @param keyedPool the KeyedObjectPool to be decorated so it shrinks it's idle count when
     * possible.
     * @return a pool that adaptively decreases it's size when idle objects are no longer needed.
     * @see #erodingPool(KeyedObjectPool, float)
     * @see #erodingPool(KeyedObjectPool, float, boolean)
     * @since Pool 1.4
     */
    public static KeyedObjectPool erodingPool(final KeyedObjectPool keyedPool) {
        return erodingPool(keyedPool, 1f);
    }

    /**
     * Returns a pool that adaptively decreases it's size when idle objects are no longer needed.
     * This is intended as an always thread-safe alternative to using an idle object evictor
     * provided by many pool implementations. This is also an effective way to shrink FIFO ordered
     * pools that experience load spikes.
     *
     *

     * The factor parameter provides a mechanism to tweak the rate at which the pool tries to shrink
     * it's size. Values between 0 and 1 cause the pool to try to shrink it's size more often.
     * Values greater than 1 cause the pool to less frequently try to shrink it's size.
     *

     *
     * @param keyedPool the KeyedObjectPool to be decorated so it shrinks it's idle count when
     * possible.
     * @param factor a positive value to scale the rate at which the pool tries to reduce it's size.
     * If 0 < factor < 1 then the pool shrinks more aggressively.
     * If 1 < factor then the pool shrinks less aggressively.
     * @return a pool that adaptively decreases it's size when idle objects are no longer needed.
     * @see #erodingPool(KeyedObjectPool, float, boolean)
     * @since Pool 1.4
     */
    public static KeyedObjectPool erodingPool(final KeyedObjectPool keyedPool, final float factor) {
        return erodingPool(keyedPool, factor, false);
    }

    /**
     * Returns a pool that adaptively decreases it's size when idle objects are no longer needed.
     * This is intended as an always thread-safe alternative to using an idle object evictor
     * provided by many pool implementations. This is also an effective way to shrink FIFO ordered
     * pools that experience load spikes.
     *
     *

     * The factor parameter provides a mechanism to tweak the rate at which the pool tries to shrink
     * it's size. Values between 0 and 1 cause the pool to try to shrink it's size more often.
     * Values greater than 1 cause the pool to less frequently try to shrink it's size.
     *

     *
     *

     * The perKey parameter determines if the pool shrinks on a whole pool basis or a per key basis.
     * When perKey is false, the keys do not have an effect on the rate at which the pool tries to
     * shrink it's size. When perKey is true, each key is shrunk independently.
     *

     *
     * @param keyedPool the KeyedObjectPool to be decorated so it shrinks it's idle count when
     * possible.
     * @param factor a positive value to scale the rate at which the pool tries to reduce it's size.
     * If 0 < factor < 1 then the pool shrinks more aggressively.
     * If 1 < factor then the pool shrinks less aggressively.
     * @param perKey when true, each key is treated independently.
     * @return a pool that adaptively decreases it's size when idle objects are no longer needed.
     * @see #erodingPool(KeyedObjectPool)
     * @see #erodingPool(KeyedObjectPool, float)
     * @since Pool 1.4
     */
    public static KeyedObjectPool erodingPool(final KeyedObjectPool keyedPool, final float factor, final boolean perKey) {
        if (keyedPool == null) {
            throw new IllegalArgumentException("keyedPool must not be null.");
        }
        if (factor <= 0f) {
            throw new IllegalArgumentException("factor must be positive.");
        }
        if (perKey) {
            return new ErodingPerKeyKeyedObjectPool(keyedPool, factor);
        } else {
            return new ErodingKeyedObjectPool(keyedPool, factor);
        }
    }

    /**
     * Get the Timer for checking keyedPool's idle count. Lazily create the {@link Timer} as needed.
     *
     * @return the {@link Timer} for checking keyedPool's idle count.
     * @since Pool 1.3
     */
    private static synchronized Timer getMinIdleTimer() {
        if (MIN_IDLE_TIMER == null) {
            MIN_IDLE_TIMER = new Timer(true);
        }
        return MIN_IDLE_TIMER;
    }

    private static class PoolableObjectFactoryAdaptor implements PoolableObjectFactory {
        private final Object key;
        private final KeyedPoolableObjectFactory keyedFactory;

        PoolableObjectFactoryAdaptor(final KeyedPoolableObjectFactory keyedFactory, final Object 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;
        }

        public Object makeObject() throws Exception {
            return keyedFactory.makeObject(key);
        }

        public void destroyObject(final Object obj) throws Exception {
            keyedFactory.destroyObject(key, obj);
        }

        public boolean validateObject(final Object obj) {
            return keyedFactory.validateObject(key, obj);
        }

        public void activateObject(final Object obj) throws Exception {
            keyedFactory.activateObject(key, obj);
        }

        public void passivateObject(final Object obj) throws Exception {
            keyedFactory.passivateObject(key, obj);
        }

        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();
        }
    }

    private static class KeyedPoolableObjectFactoryAdaptor implements KeyedPoolableObjectFactory {
        private final PoolableObjectFactory factory;

        KeyedPoolableObjectFactoryAdaptor(final PoolableObjectFactory factory) throws IllegalArgumentException {
            if (factory == null) {
                throw new IllegalArgumentException("factory must not be null.");
            }
            this.factory = factory;
        }

        public Object makeObject(final Object key) throws Exception {
            return factory.makeObject();
        }

        public void destroyObject(final Object key, final Object obj) throws Exception {
            factory.destroyObject(obj);
        }

        public boolean validateObject(final Object key, final Object obj) {
            return factory.validateObject(obj);
        }

        public void activateObject(final Object key, final Object obj) throws Exception {
            factory.activateObject(obj);
        }

        public void passivateObject(final Object key, final Object obj) throws Exception {
            factory.passivateObject(obj);
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("KeyedPoolableObjectFactoryAdaptor");
            sb.append("{factory=").append(factory);
            sb.append('}');
            return sb.toString();
        }
    }

    private static class ObjectPoolAdaptor implements ObjectPool {
        private final Object key;
        private final KeyedObjectPool keyedPool;

        ObjectPoolAdaptor(final KeyedObjectPool keyedPool, final Object 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;
        }

        public Object borrowObject() throws Exception, NoSuchElementException, IllegalStateException {
            return keyedPool.borrowObject(key);
        }

        public void returnObject(final Object obj) {
            try {
                keyedPool.returnObject(key, obj);
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void invalidateObject(final Object obj) {
            try {
                keyedPool.invalidateObject(key, obj);
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void addObject() throws Exception, IllegalStateException {
            keyedPool.addObject(key);
        }

        public int getNumIdle() throws UnsupportedOperationException {
            return keyedPool.getNumIdle(key);
        }

        public int getNumActive() throws UnsupportedOperationException {
            return keyedPool.getNumActive(key);
        }

        public void clear() throws Exception, UnsupportedOperationException {
            keyedPool.clear();
        }

        public void close() {
            try {
                keyedPool.close();
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void setFactory(final PoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            keyedPool.setFactory(adapt(factory));
        }

        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();
        }
    }

    private static class KeyedObjectPoolAdaptor implements KeyedObjectPool {
        private final ObjectPool pool;

        KeyedObjectPoolAdaptor(final ObjectPool pool) throws IllegalArgumentException {
            if (pool == null) {
                throw new IllegalArgumentException("pool must not be null.");
            }
            this.pool = pool;
        }

        public Object borrowObject(final Object key) throws Exception, NoSuchElementException, IllegalStateException {
            return pool.borrowObject();
        }

        public void returnObject(final Object key, final Object obj) {
            try {
                pool.returnObject(obj);
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void invalidateObject(final Object key, final Object obj) {
            try {
                pool.invalidateObject(obj);
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void addObject(final Object key) throws Exception, IllegalStateException {
            pool.addObject();
        }

        public int getNumIdle(final Object key) throws UnsupportedOperationException {
            return pool.getNumIdle();
        }

        public int getNumActive(final Object key) throws UnsupportedOperationException {
            return pool.getNumActive();
        }

        public int getNumIdle() throws UnsupportedOperationException {
            return pool.getNumIdle();
        }

        public int getNumActive() throws UnsupportedOperationException {
            return pool.getNumActive();
        }

        public void clear() throws Exception, UnsupportedOperationException {
            pool.clear();
        }

        public void clear(final Object key) throws Exception, UnsupportedOperationException {
            pool.clear();
        }

        public void close() {
            try {
                pool.close();
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void setFactory(final KeyedPoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            pool.setFactory(adapt(factory));
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("KeyedObjectPoolAdaptor");
            sb.append("{pool=").append(pool);
            sb.append('}');
            return sb.toString();
        }
    }

    private static class CheckedObjectPool implements ObjectPool {
        private final Class type;
        private final ObjectPool pool;

        CheckedObjectPool(final ObjectPool 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;
        }

        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);
            }
        }

        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);
            }
        }

        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);
            }
        }

        public void addObject() throws Exception, IllegalStateException, UnsupportedOperationException {
            pool.addObject();
        }

        public int getNumIdle() throws UnsupportedOperationException {
            return pool.getNumIdle();
        }

        public int getNumActive() throws UnsupportedOperationException {
            return pool.getNumActive();
        }

        public void clear() throws Exception, UnsupportedOperationException {
            pool.clear();
        }

        public void close() {
            try {
                pool.close();
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void setFactory(final PoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            pool.setFactory(factory);
        }

        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();
        }
    }

    private static class CheckedKeyedObjectPool implements KeyedObjectPool {
        private final Class type;
        private final KeyedObjectPool keyedPool;

        CheckedKeyedObjectPool(final KeyedObjectPool 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;
        }

        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);
            }
        }

        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);
            }
        }

        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);
            }
        }

        public void addObject(final Object key) throws Exception, IllegalStateException, UnsupportedOperationException {
            keyedPool.addObject(key);
        }

        public int getNumIdle(final Object key) throws UnsupportedOperationException {
            return keyedPool.getNumIdle(key);
        }

        public int getNumActive(final Object key) throws UnsupportedOperationException {
            return keyedPool.getNumActive(key);
        }

        public int getNumIdle() throws UnsupportedOperationException {
            return keyedPool.getNumIdle();
        }

        public int getNumActive() throws UnsupportedOperationException {
            return keyedPool.getNumActive();
        }

        public void clear() throws Exception, UnsupportedOperationException {
            keyedPool.clear();
        }

        public void clear(final Object key) throws Exception, UnsupportedOperationException {
            keyedPool.clear(key);
        }

        public void close() {
            try {
                keyedPool.close();
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void setFactory(final KeyedPoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            keyedPool.setFactory(factory);
        }

        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();
        }
    }

    private static class ObjectPoolMinIdleTimerTask extends TimerTask {
        private final int minIdle;
        private final ObjectPool pool;

        ObjectPoolMinIdleTimerTask(final ObjectPool pool, final int minIdle) throws IllegalArgumentException {
            if (pool == null) {
                throw new IllegalArgumentException("pool must not be null.");
            }
            this.pool = pool;
            this.minIdle = minIdle;
        }

        public void run() {
            boolean success = false;
            try {
                if (pool.getNumIdle() < minIdle) {
                    pool.addObject();
                }
                success = true;

            } catch (Exception e) {
                cancel();

            } finally {
                // detect other types of Throwable and cancel this Timer
                if (!success) {
                    cancel();
                }
            }
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("ObjectPoolMinIdleTimerTask");
            sb.append("{minIdle=").append(minIdle);
            sb.append(", pool=").append(pool);
            sb.append('}');
            return sb.toString();
        }
    }

    private static class KeyedObjectPoolMinIdleTimerTask extends TimerTask {
        private final int minIdle;
        private final Object key;
        private final KeyedObjectPool keyedPool;

        KeyedObjectPoolMinIdleTimerTask(final KeyedObjectPool keyedPool, final Object key, final int minIdle) throws IllegalArgumentException {
            if (keyedPool == null) {
                throw new IllegalArgumentException("keyedPool must not be null.");
            }
            this.keyedPool = keyedPool;
            this.key = key;
            this.minIdle = minIdle;
        }

        public void run() {
            boolean success = false;
            try {
                if (keyedPool.getNumIdle(key) < minIdle) {
                    keyedPool.addObject(key);
                }
                success = true;

            } catch (Exception e) {
                cancel();

            } finally {
                // detect other types of Throwable and cancel this Timer
                if (!success) {
                    cancel();
                }
            }
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("KeyedObjectPoolMinIdleTimerTask");
            sb.append("{minIdle=").append(minIdle);
            sb.append(", key=").append(key);
            sb.append(", keyedPool=").append(keyedPool);
            sb.append('}');
            return sb.toString();
        }
    }

    private static class SynchronizedObjectPool implements ObjectPool {
        private final Object lock;
        private final ObjectPool pool;

        SynchronizedObjectPool(final ObjectPool pool) throws IllegalArgumentException {
            if (pool == null) {
                throw new IllegalArgumentException("pool must not be null.");
            }
            this.pool = pool;
            lock = new Object();
        }

        public Object borrowObject() throws Exception, NoSuchElementException, IllegalStateException {
            synchronized (lock) {
                return pool.borrowObject();
            }
        }

        public void returnObject(final Object obj) {
            synchronized (lock) {
                try {
                    pool.returnObject(obj);
                } catch (Exception e) {
                    // swallowed as of Pool 2
                }
            }
        }

        public void invalidateObject(final Object obj) {
            synchronized (lock) {
                try {
                    pool.invalidateObject(obj);
                } catch (Exception e) {
                    // swallowed as of Pool 2
                }
            }
        }

        public void addObject() throws Exception, IllegalStateException, UnsupportedOperationException {
            synchronized (lock) {
                pool.addObject();
            }
        }

        public int getNumIdle() throws UnsupportedOperationException {
            synchronized (lock) {
                return pool.getNumIdle();
            }
        }

        public int getNumActive() throws UnsupportedOperationException {
            synchronized (lock) {
                return pool.getNumActive();
            }
        }

        public void clear() throws Exception, UnsupportedOperationException {
            synchronized (lock) {
                pool.clear();
            }
        }

        public void close() {
            try {
                synchronized (lock) {
                    pool.close();
                }
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void setFactory(final PoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            synchronized (lock) {
                pool.setFactory(factory);
            }
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("SynchronizedObjectPool");
            sb.append("{pool=").append(pool);
            sb.append('}');
            return sb.toString();
        }
    }

    private static class SynchronizedKeyedObjectPool implements KeyedObjectPool {
        private final Object lock;
        private final KeyedObjectPool keyedPool;

        SynchronizedKeyedObjectPool(final KeyedObjectPool keyedPool) throws IllegalArgumentException {
            if (keyedPool == null) {
                throw new IllegalArgumentException("keyedPool must not be null.");
            }
            this.keyedPool = keyedPool;
            lock = new Object();
        }

        public Object borrowObject(final Object key) throws Exception, NoSuchElementException, IllegalStateException {
            synchronized (lock) {
                return keyedPool.borrowObject(key);
            }
        }

        public void returnObject(final Object key, final Object obj) {
            synchronized (lock) {
                try {
                    keyedPool.returnObject(key, obj);
                } catch (Exception e) {
                    // swallowed
                }
            }
        }

        public void invalidateObject(final Object key, final Object obj) {
            synchronized (lock) {
                try {
                    keyedPool.invalidateObject(key, obj);
                } catch (Exception e) {
                    // swallowed as of Pool 2
                }
            }
        }

        public void addObject(final Object key) throws Exception, IllegalStateException, UnsupportedOperationException {
            synchronized (lock) {
                keyedPool.addObject(key);
            }
        }

        public int getNumIdle(final Object key) throws UnsupportedOperationException {
            synchronized (lock) {
                return keyedPool.getNumIdle(key);
            }
        }

        public int getNumActive(final Object key) throws UnsupportedOperationException {
            synchronized (lock) {
                return keyedPool.getNumActive(key);
            }
        }

        public int getNumIdle() throws UnsupportedOperationException {
            synchronized (lock) {
                return keyedPool.getNumIdle();
            }
        }

        public int getNumActive() throws UnsupportedOperationException {
            synchronized (lock) {
                return keyedPool.getNumActive();
            }
        }

        public void clear() throws Exception, UnsupportedOperationException {
            synchronized (lock) {
                keyedPool.clear();
            }
        }

        public void clear(final Object key) throws Exception, UnsupportedOperationException {
            synchronized (lock) {
                keyedPool.clear(key);
            }
        }

        public void close() {
            try {
                synchronized (lock) {
                    keyedPool.close();
                }
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
        }

        public void setFactory(final KeyedPoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            synchronized (lock) {
                keyedPool.setFactory(factory);
            }
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("SynchronizedKeyedObjectPool");
            sb.append("{keyedPool=").append(keyedPool);
            sb.append('}');
            return sb.toString();
        }
    }

    private static class SynchronizedPoolableObjectFactory implements PoolableObjectFactory {
        private final Object lock;
        private final PoolableObjectFactory factory;

        SynchronizedPoolableObjectFactory(final PoolableObjectFactory factory) throws IllegalArgumentException {
            if (factory == null) {
                throw new IllegalArgumentException("factory must not be null.");
            }
            this.factory = factory;
            lock = new Object();
        }

        public Object makeObject() throws Exception {
            synchronized (lock) {
                return factory.makeObject();
            }
        }

        public void destroyObject(final Object obj) throws Exception {
            synchronized (lock) {
                factory.destroyObject(obj);
            }
        }

        public boolean validateObject(final Object obj) {
            synchronized (lock) {
                return factory.validateObject(obj);
            }
        }

        public void activateObject(final Object obj) throws Exception {
            synchronized (lock) {
                factory.activateObject(obj);
            }
        }

        public void passivateObject(final Object obj) throws Exception {
            synchronized (lock) {
                factory.passivateObject(obj);
            }
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("SynchronizedPoolableObjectFactory");
            sb.append("{factory=").append(factory);
            sb.append('}');
            return sb.toString();
        }
    }

    private static class SynchronizedKeyedPoolableObjectFactory implements KeyedPoolableObjectFactory {
        private final Object lock;
        private final KeyedPoolableObjectFactory keyedFactory;

        SynchronizedKeyedPoolableObjectFactory(final KeyedPoolableObjectFactory keyedFactory) throws IllegalArgumentException {
            if (keyedFactory == null) {
                throw new IllegalArgumentException("keyedFactory must not be null.");
            }
            this.keyedFactory = keyedFactory;
            lock = new Object();
        }

        public Object makeObject(final Object key) throws Exception {
            synchronized (lock) {
                return keyedFactory.makeObject(key);
            }
        }

        public void destroyObject(final Object key, final Object obj) throws Exception {
            synchronized (lock) {
                keyedFactory.destroyObject(key, obj);
            }
        }

        public boolean validateObject(final Object key, final Object obj) {
            synchronized (lock) {
                return keyedFactory.validateObject(key, obj);
            }
        }

        public void activateObject(final Object key, final Object obj) throws Exception {
            synchronized (lock) {
                keyedFactory.activateObject(key, obj);
            }
        }

        public void passivateObject(final Object key, final Object obj) throws Exception {
            synchronized (lock) {
                keyedFactory.passivateObject(key, obj);
            }
        }

        public String toString() {
            final StringBuffer sb = new StringBuffer();
            sb.append("SynchronizedKeyedPoolableObjectFactory");
            sb.append("{keyedFactory=").append(keyedFactory);
            sb.append('}');
            return sb.toString();
        }
    }

    /**
     * Encapsulate the logic for when the next poolable object should be discarded.
     */
    private static class ErodingFactor {
        private final float factor;
        private transient volatile long nextShrink;
        private transient volatile int idleHighWaterMark;

        public ErodingFactor(final float factor) {
            this.factor = factor;
            nextShrink = System.currentTimeMillis() + (long)(900000 * factor); // now + 15 min * factor
            idleHighWaterMark = 1;
        }

        public void update(final int numIdle) {
            update(System.currentTimeMillis(), numIdle);
        }

        public void update(final long now, final int numIdle) {
            final int idle = Math.max(0, numIdle);
            idleHighWaterMark = Math.max(idle, idleHighWaterMark);
            final float maxInterval = 15f;
            final float minutes = maxInterval + ((1f-maxInterval)/idleHighWaterMark) * idle;
            nextShrink = now + (long)(minutes * 60000f * factor);
        }

        public long getNextShrink() {
            return nextShrink;
        }

        public String toString() {
            return "ErodingFactor{" +
                    "factor=" + factor +
                    ", idleHighWaterMark=" + idleHighWaterMark +
                    '}';
        }
    }

    private static class ErodingObjectPool implements ObjectPool {
        private final ObjectPool pool;
        private final ErodingFactor factor;

        public ErodingObjectPool(final ObjectPool pool, final float factor) {
            this.pool = pool;
            this.factor = new ErodingFactor(factor);
        }

        public Object borrowObject() throws Exception, NoSuchElementException, IllegalStateException {
            return pool.borrowObject();
        }

        public void returnObject(final Object obj) {
            boolean discard = false;
            final long now = System.currentTimeMillis();
            synchronized (pool) {
                if (factor.getNextShrink() < now) { // XXX: Pool 3: move test out of sync block
                    final int numIdle = pool.getNumIdle();
                    if (numIdle > 0) {
                        discard = true;
                    }

                    factor.update(now, numIdle);
                }
            }
            try {
                if (discard) {
                    pool.invalidateObject(obj);
                } else {
                    pool.returnObject(obj);
                }
            } catch (Exception e) {
                // swallowed
            }
        }

        public void invalidateObject(final Object obj) {
            try {
                pool.invalidateObject(obj);
            } catch (Exception e) {
                // swallowed
            }
        }

        public void addObject() throws Exception, IllegalStateException, UnsupportedOperationException {
            pool.addObject();
        }

        public int getNumIdle() throws UnsupportedOperationException {
            return pool.getNumIdle();
        }

        public int getNumActive() throws UnsupportedOperationException {
            return pool.getNumActive();
        }

        public void clear() throws Exception, UnsupportedOperationException {
            pool.clear();
        }

        public void close() {
            try {
                pool.close();
            } catch (Exception e) {
                // swallowed
            }
        }

        public void setFactory(final PoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            pool.setFactory(factory);
        }

        public String toString() {
            return "ErodingObjectPool{" +
                    "factor=" + factor +
                    ", pool=" + pool +
                    '}';
        }
    }

    private static class ErodingKeyedObjectPool implements KeyedObjectPool {
        private final KeyedObjectPool keyedPool;
        private final ErodingFactor erodingFactor;

        public ErodingKeyedObjectPool(final KeyedObjectPool keyedPool, final float factor) {
            this(keyedPool, new ErodingFactor(factor));
        }

        protected ErodingKeyedObjectPool(final KeyedObjectPool keyedPool, final ErodingFactor erodingFactor) {
            if (keyedPool == null) {
                throw new IllegalArgumentException("keyedPool must not be null.");
            }
            this.keyedPool = keyedPool;
            this.erodingFactor = erodingFactor;
        }

        public Object borrowObject(final Object key) throws Exception, NoSuchElementException, IllegalStateException {
            return keyedPool.borrowObject(key);
        }

        public void returnObject(final Object key, final Object obj) throws Exception {
            boolean discard = false;
            final long now = System.currentTimeMillis();
            final ErodingFactor factor = getErodingFactor(key);
            synchronized (keyedPool) {
                if (factor.getNextShrink() < now) {
                    final int numIdle = numIdle(key);
                    if (numIdle > 0) {
                        discard = true;
                    }

                    factor.update(now, numIdle);
                }
            }
            try {
                if (discard) {
                    keyedPool.invalidateObject(key, obj);
                } else {
                    keyedPool.returnObject(key, obj);
                }
            } catch (Exception e) {
                // swallowed
            }
        }

        protected int numIdle(final Object key) {
            return getKeyedPool().getNumIdle();
        }

        protected ErodingFactor getErodingFactor(final Object key) {
            return erodingFactor;
        }

        public void invalidateObject(final Object key, final Object obj) {
            try {
                keyedPool.invalidateObject(key, obj);
            } catch (Exception e) {
                // swallowed
            }
        }

        public void addObject(final Object key) throws Exception, IllegalStateException, UnsupportedOperationException {
            keyedPool.addObject(key);
        }

        public int getNumIdle() throws UnsupportedOperationException {
            return keyedPool.getNumIdle();
        }

        public int getNumIdle(final Object key) throws UnsupportedOperationException {
            return keyedPool.getNumIdle(key);
        }

        public int getNumActive() throws UnsupportedOperationException {
            return keyedPool.getNumActive();
        }

        public int getNumActive(final Object key) throws UnsupportedOperationException {
            return keyedPool.getNumActive(key);
        }

        public void clear() throws Exception, UnsupportedOperationException {
            keyedPool.clear();
        }

        public void clear(final Object key) throws Exception, UnsupportedOperationException {
            keyedPool.clear(key);
        }

        public void close() {
            try {
                keyedPool.close();
            } catch (Exception e) {
                // swallowed
            }
        }

        public void setFactory(final KeyedPoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
            keyedPool.setFactory(factory);
        }

        protected KeyedObjectPool getKeyedPool() {
            return keyedPool;
        }

        public String toString() {
            return "ErodingKeyedObjectPool{" +
                    "erodingFactor=" + erodingFactor +
                    ", keyedPool=" + keyedPool +
                    '}';
        }
    }

    private static class ErodingPerKeyKeyedObjectPool extends ErodingKeyedObjectPool {
        private final float factor;
        private final Map factors = Collections.synchronizedMap(new HashMap());

        public ErodingPerKeyKeyedObjectPool(final KeyedObjectPool keyedPool, final float factor) {
            super(keyedPool, null);
            this.factor = factor;
        }

        protected int numIdle(final Object key) {
            return getKeyedPool().getNumIdle(key);
        }

        protected ErodingFactor getErodingFactor(final Object key) {
            ErodingFactor factor = (ErodingFactor)factors.get(key);
            // this may result in two ErodingFactors being created for a key
            // since they are small and cheap this is okay.
            if (factor == null) {
                factor = new ErodingFactor(this.factor);
                factors.put(key, factor);
            }
            return factor;
        }

        public String toString() {
            return "ErodingPerKeyKeyedObjectPool{" +
                    "factor=" + factor +
                    ", keyedPool=" + getKeyedPool() +
                    '}';
        }
    }
}

redpajama_set_name: RedPajamaGithub


Lonci Group is the leading fine ceramic manufacturer which was established in 1988. Lonci has owned two factories and one marketing centre, specialize in production and trading fine ceramics. The main products are: high quality alumina ceramic tubes, alumina ceramic rods, ceramic plates and substrates, ceramic roller, alumina crucible and other special industrial ceramics. Our manufacture stocks over 150,000 pieces quality ceramic tubes, rods and rollers and other technical ceramics, which help us have a significant share in the world market.
While focusing on technical ceramics production, Lonci pays much attention to technology innovation and research, and has been making a lot of breakthroughs in recent years. Up until now, Lonci is holding many self-developed intellectual property rights. Facing today's new international competition, Lonci has been establishing and implementing Globalization Strategy , Famous Brand Strategy and Multi-fields . Until now, our products have been selling to America, Canada, Germany, England, Japan, France, Italy, Korea, India, Egypt, Indonesia, Turkey, Russia etc. Our products are providing service for ceramic industry, petroleum industry, casting industry, steel industry, mining industry, power industry, petrol chemical industry and chemical industry. With high quality products, perfect service and scientific management, the popularity, reputation and social recognition of Lonci is improved greatly on global market.
Lonci Group regards science technology as guidance, quality as life, development as motive, market as center to offer best service and products to customers and markets contribution to society. On basis of double win and mutual benefits, Lonci Group are willing to honestly cooperate with business people from all circles of the world.


text:
One night only, September 29th. Rodgers & Hammerstein's A Grand Night for Singing
EOA Staff | September 20, 2018, 08:26 AM
Catrin Davies
Everyone knows at least one song by Richard Rodgers and Oscar Hammerstein II. Their careers gave the world some of the best musicals ever written, including "The Sound of Music," "Oklahoma!", "South Pacific," and "The King and I." For true fans who love the music, it's rare to find these shows going at the same time. Someone else had the same thought and decided to put all his favorite songs together in one show. That's how "A Grand Night for Singing" was born. As conceived by Walter Bobbie in 1993, this review-style show brings together the best-loved music of all the musicals named above plus a few more.
One of those true Rodgers & Hammerstein fans, Live Arts Maryland's Music Director J Ernest Green, jumped at the chance to bring "A Grand Night for Singing" to Annapolis. On September 29 at Maryland Hall for the Creative Arts, Mr. Green conducts the Annapolis Chorale, members of the Annapolis Chamber Orchestra, and a cast of very talented singers in this Tony Award-nominated celebration. Mr. Bobbie and his collaborators put together more than 30 of Rodgers and Hammerstein's "greatest hits." The show took Broadway by storm and became a favorite among performers as well as audiences.
Joining Mr. Green for this production are the dynamic duo Jason Buckwalter and Kimberly Christie who sang on last year's Pops Concert that featured music from the American Songbook. Catrin Davies, who has been directing many of the chorale's Broadway Night in Annapolis productions, will be stepping into the spotlight for this show and joined by featured chorale members Lindsay Espinosa, Molly Green, Tom Maguette, Heather McMunigal, and Kristin Pagent.
What attracts Mr. Green to this production is its fresh approach to the much-loved songs. "This show is not so much as a review as it is a re-shaping of the individual songs…putting them in more modern settings. The best part is that they managed to do that while honoring the songs and keeping what people love about them."
"A Grand Night for Singing" is a perfect continuation for Live Arts Maryland's Fall Pops Concerts. Last year we explored the American Songbook that featured timeless classics by composers George Gershwin, Cole Porter, and Jerome Kern. This year we can enjoy favorites from Broadway's Golden Era through the music of Rodgers and Hammerstein. Performed with an orchestra, some staging and choreography, and the power and energy of the Annapolis Chorale, this performance is sure to be a grand night of song!
This performance is one night only on Saturday, September 29 at 8 p.m. Live Arts Maryland offers free student rush tickets a half hour before concerts to all full-time students with a valid ID or those under 18 years of age. Tickets range from $46-$51 for adults, $18 for pre-paid students and are on sale now at the Maryland Hall Box Office at 410-280-5640 or www.liveartsmaryland.org. Group rates are available.
Live Arts Maryland is one of the region's largest and most active non-profit performing arts organizations and is dedicated to enhancing community life by performing and presenting high-quality music and providing music education for all ages. Live Arts Maryland is also home to the Annapolis Chamber Orchestra, the Annapolis Youth Chorus and the St. Anne's Concert Series. It also offers such music education programs as the MusicWorks school partnership and a scholarship program for high-school music students. The Annapolis Chorale is a resident company of Maryland Hall for the Creative Arts and is supported by the Maryland State Arts Council, the Arts Council of Anne Arundel County and the City of Annapolis, and CapitalOne Bank.
Category: Events, LIFE IN THE AREA, Local News, MUSIC & ENTERTAINMENT, NEWS, Post To FB
About the Author - EOA Staff
Eye On Annapolis is a community based site focusing strictly on Anne Arundel County. These staff postings are general news postings made by our team of bloggers throughout the day and are not attributed to any one particular staff person.
« Daily News Brief | September 20, 2018
From America's Got Talent to Annapolis. Catapult to perform at Maryland Hall in September »

redpajama_set_name: RedPajamaCommonCrawl


What steps will reproduce the problem? 1. Setup mam to always archive on internal memory (same issue with SQL as well) 2. Send some messages 3. Restart the server What is the expected output? I'm expecting to see all the messages once again and be able to fetch them. What do you see instead? mam is empty and i can't archive any messages sent pre-restart What version of the product are you using? On what operating system? We're running the latest version of prosody on Ubuntu 16 Please provide any additional information below. The response we get from the server when asking for prefs are following : xmlns="jabber:client" id="jebeniKveri" type="result" to="user251@hookchat.com/ab4f7a26-8147-4d59-a35b-9cc5ef25f9b0"><prefs xmlns="urn:xmpp:mam:2" default="always"><always/><never/></prefs></iq Everything works as normal when the server is up and running, all the messages are archived but when we restart the server they are all gone. We tried everything and didn't get it to work. When trying over SQL it doesn't create any additional tables for it nor does it archive.
What does "the latest version" mean, exactly? Check `prosodyctl about`. If this is 0.9.x then what you see is the expected behaviour. Proper archive support was added in 0.10, and if you are using mod_mam from the community repo with 0.9.x then it will only store archives in memory, which are lost on restarts. If that is the case, there should be a log message saying so.
No response, going to assume that comment #2 was the case. Report back if you are still having issues.


The Midnight Black (or Black Friday) paint jobs are a set of black paint jobs in Elite Dangerous available in promotional sales.
Where can I get the Midnight Black paint jobs?
The Midnight Black paint jobs can be purchased from limited time promotional sales on FrontierStore.net and the in-game stores for each platform and were also previously available in a promotional purchase for Elite Dangerous: Horizons (see below). If the paint jobs are not on sale, they are unfortunately not available.
Which ships or vehicles are the midnight black paint jobs available for?
The Midnight Black paint jobs are available for most ships and vehicles that you can buy in-game.
Are the Midnight Black paint jobs the same as the Black Friday paint jobs?
Yes. "Black Friday paint job" refers to the Midnight Black paint jobs.
I play Elite Dangerous on PS4™ or Xbox One, can I buy the Midnight Black paint jobs on FrontierStore.net?
No. To purchase any in-game extras including the Midnight Black paint jobs for your version of the game, please log in and access the in-game store from the Commander you wish to purchase them for.
All FrontierStore.net in-game items are labelled with PC and Mac compatibility only as they will not appear on the Xbox or PS4™ versions of the game.
I pre-ordered Elite Dangerous: Horizons, do I get any Midnight Black paint jobs for free?
Note: Some of the newer Midnight Black paint jobs were not available in this pack.
I'm a proud owner of the Lifetime Expansion Pass. Do I get any of the Midnight Black paint jobs?
Yes! As the Lifetime Expansion Pass includes Elite Dangerous: Horizons, you will have already been gifted the original Midnight Black paint jobs for free! Please check the answer to I pre-ordered Elite Dangerous: Horizons... for the list of included paint jobs.
I've bought a Midnight Black paint job but it doesn't appear in-game?
1) There was an error processing your payment. For PC and Mac players, you can check any purchases made via the Steam Wallet or FrontierStore.net by logging in and checking your order history.
2) If you are a PS4 or Xbox One player, you cannot purchase these paint jobs using FrontierStore.net - these purchases will only apply to the PC or Mac versions of the game. If you have made a purchase for the PC or Mac version in error, please contact the support team.
3) There may be an error already under investigation. Please check for any notices at the top of the support site page to see if the support team are already investigating any delayed orders.
Can I apply these paint jobs to my ships in CQC?
No. The colour of all ships in CQC is decided by your team.


how to clean sanded wood tricks for restoring wood furniture no sanding required johns tricks for restoring wood furniture no sanding required johns creek ga patch.
how to clean sanded wood vacuuming and sweeping often go together when cleaning wood floors .
how to clean sanded wood sanding and refinishing hardwood floors step by step the easiest way to clean reclaimed woodfunky junk interiors the easiest way to clean reclaimed wood before and after funkyjunkinteriorsnet.
how to clean sanded wood image titled clean wood pallets step 1 super crazy everyday life hacks you never thought of hacks super crazy everyday life hacks you never thought of hacks life hacks pinterest cleaning hacks life hacks and hacks.
how to clean sanded wood wood stain refinishing wood with steel wool murphys oil soap danish oil refinishing wood with steel wool murphys oil soap danish oil howards feednwax diy pinterest furniture diy furniture and painted furniture.
how to clean sanded wood learn how to prepare a deck for stain or paint follow these guidelines for cleaning and sanding decks to prepare for applying stains and paints .
how to clean sanded wood image titled clean wood pallets step 2 how to clean your wood deck doityourselfcom what youll need.
how to clean sanded wood use gapseal to create a v shaped barrier between the floorboards fill in bigger gaps how to fix scratches on wood furniture easy diy ways how to fix scratches on wood furniture.
how to clean sanded wood how much does hardwood floor refinishing cost the beginners guide to annie sloan chalk paint the thinking closet prep furniture by cleaning it with warm soapy water.
how to clean sanded wood the easiest way to clean reclaimed wood sanding boards after cleaning funkyjunkinteriorsnet how to apply a stain over wood filler doityourselfcom.
how to clean sanded wood pressure washer cleaning a weathered deck refinishing hardwood floors with a rental floor sander painting polyurethane onto a freshly sanded hardwood floor.
how to clean sanded wood restoring wood floors rules for sanding wood popular woodworking magazine sanding crossgrain tears the wood fibers so the sanding scratches show up much more especially under a stain the best policy is to always sand in the.
how to clean sanded wood buffing is the final stage in the wood floor sanding sequence the beginners guide to annie sloan chalk paint the thinking closet prep furniture by cleaning it with warm soapy water.
how to clean sanded wood the easiest way to clean reclaimed wood before and after funkyjunkinteriorsnet how much does hardwood floor refinishing cost angies list how much does hardwood floor refinishing cost.
how to clean sanded wood refinishing wood with steel wool murphys oil soap danish oil howards feed n wax diy pinterest furniture diy furniture and painted furniture how to clean and prepare wood for diy signs the summery umbrella how to clean and prep wood.
how to clean sanded wood replace damaged deck board how to refinish wood floors this old house.
how to clean sanded wood correct drum technique looks like this rules for sanding wood popular woodworking magazine sanding crossgrain tears the wood fibers so the sanding scratches show up much more especially under a stain the best policy is to always sand in the.
how to clean sanded wood repairing wood veneer furniture sanding cleaning wood veneer youtube reviving wood floors homebuilding renovating repair varnishes rub down the area until the edges of the scratches have feathered out.
how to clean sanded wood ironwood gourmet 28217 large charleston end grain prep station acacia wood how to clean and prepare wood for diy signs the summery umbrella how to clean and prep wood.
how to clean sanded wood fh12djaflosan01 3 follow these hardwood floor sanding tricks for restoring wood furniture no sanding required johns tricks for restoring wood furniture no sanding required johns creek ga patch.
how to clean sanded wood fh99markitcab01 3 refinishing kitchen cabinets refinish kitchen cabinets reviving wood floors homebuilding renovating repair varnishes rub down the area until the edges of the scratches have feathered out.
how to clean sanded wood using a shop vac to remove dust after sanding hardwood floors how to clean wood pallets steps with pictures wikihow image titled clean wood pallets step.
how to clean sanded wood staining wood bench the easiest way to clean reclaimed woodfunky junk interiors the easiest way to clean reclaimed wood before and after funkyjunkinteriorsnet.
how to clean sanded wood image how to paint wood smoothly like a professional.
how to clean sanded wood beginning the first coat of my first project using annie sloan chalk paint how to fix scratches on wood furniture easy diy ways how to fix scratches on wood furniture.
how to clean sanded wood no matter how careful you are water stains happen to wood furniture you can usually get rid of them with a liberal application of mayonnaise remove all sanding dust before finishing wood wood stain.


Specialising in Cuban and Latin music, Havana Social Club brings forward a vibrant and entertaining performance in a heartbeat. Formed by Pablo Calzado Morales (Cuban drummer and percussionist) the collective comprises of members from Cuba, Singapore, Venezuela, and USA who all have a passion for the sound and 'life' for Cuban and Latin music.
Having performed at some of Southeast Asia's finest festivals, venues, and events like No Black Tie (2011), The Fullerton Hotel (Singapore), Publika Jazz Festival 2013 (Kuala Lumpur) and Ljen Summer Festival 2016 (Java) – they're no stranger to bringing on the groove.


text:
/*global beforeEach, before, afterEach, after, describe, it, assert, expect  */
'use strict';

describe('Player View', function () {

	before(function () {
		// Create test fixture.
		this.$fixture = $('

');
	});

	beforeEach(function () {
		// Empty out and rebind the fixture for each run.
		this.$fixture.empty().appendTo($('#fixtures'));

		this.Players = new App.Collections.PlayerCollection();

		this.Players.create({
			email: 'nick.chamberlain.jr@gmail.com',
			name: 'Nick Chamberlain',
			playing: false
		});

		this.view = new App.Views.PlayerView({
			el: this.$fixture,
			model: this.Players.at(0)
		});

		// this gets called by Views.AppView
		this.view.render().el;
	});

	it('Should create a player view with model name', function () {
		var $name = $('h4#username');
		$name.text().should.equal('Nick Chamberlain');
	});

	it('Toggle player playing updates model attribute', function () {
		this.view.model.get('playing').should.be.false;
		this.view.togglePlaying();
		this.view.model.get('playing').should.be.true;
	});

	afterEach(function () {
		// Destroying the model also destroys the view.
		this.view.model.destroy();
	});

	after(function () {
		// Remove all subfixtures after test suite finishes.
		$('#fixtures').empty();
	});
});


text:
Die UCI Asia Tour ist der vom Weltradsportverband Union Cycliste Internationale (UCI) zur Saison 2005 eingeführte asiatische Straßenradsport-Kalender unterhalb der UCI ProTour.

Die Eintagesrennen und Etappenrennen der UCI Asia Tour sind in drei Kategorien (HC, 1 und 2) eingeteilt.

Gesamtstand
(Stand: 30. Oktober 2007)

* U23-Fahrer

Rennkalender

Oktober 2006

November 2006

Dezember 2006

Januar

Februar

März

April

Mai

Juni

Juli

August

September

2007
Radsportveranstaltung 2006
Radsportveranstaltung 2007

redpajama_set_name: RedPajamaWikipedia


text:
What is David Zucker Net Worth 2023: Overview, Interview
Posted on January 1, 2023 December 17, 2023 by fidlarmusic
David Zucker is an American film director, writer, and producer who has worked on some of the most beloved comedy films. The Naked Gun series, and Scary Movie 3. As of 2023, David Zucker net worth is estimated to be around some million dollars.
So If you want to know more information about his current net worth, life, and career, follow our blog now.
What About David Zucker Net Worth and Salary in 2023?
David Zucker's Overview
Why Is David Zucker Famous?
FAQs about David Zucker
How much is Jerry Zucker worth?
Who is David Zucker's wife?
How old is David Zucker?
What happened to Jerry Zucker?
An American Carol (2008)?
David Zucker family guy?
David Zucker is an American director, producer, and screenwriter with a net worth of $60 million as of 2023. He is best known for his comedic films such as Airplane!, The Naked Gun and Scary Movie 3.
Zucker began his career in Hollywood when he wrote, produced, and directed his first feature film, Kentucky Fried Movie, in 1977.
Since then, he has continued to work on major projects, earning an estimated $20 million in salary for his various efforts.
Zucker's first major foray into film was the 1979 movie The Kentucky Fried Movie, which he wrote and directed. The movie was a success and helped launch Zucker's career.
He went on to write and direct Airplane!, which was released in 1980 and became a cult classic. The movie was a spoof on disaster movies and featured Leslie Nielsen in the lead role. Airplane! was followed by the 1981 movie Top Secret!, which was also a spoof.
In 1984, Zucker co-wrote and co-directed Police Academy. The movie was a huge success and spawned six sequels. It was followed by Ruthless People in 1986 and The Naked Gun: From the Files of Police Squad in 1988. Both movies were also very successful and spawned sequels.
In 1989, Zucker wrote and directed The Naked Gun 2 ½: The Smell of Fear. It was followed by the 1994 movie Naked Gun 33 1/3: The Final Insult. He also wrote and directed the 1991 movie The Naked Gun 2 ½: The Smell of Fear.
In the late 1990s, Zucker wrote and directed the comedies BASEketball and Rat Race. He also wrote and directed the 2004 movie Scary Movie 3. In 2006, he wrote and directed the movie Date Movie.
In recent years, Zucker has written and produced several television shows, including The Man Show, Family Business, and Sports Show with Norm Macdonald. He also produced the 2020 Netflix movie Zombieland: Double Tap.
David Zucker is one of comedy's most successful directors and producers. His movies have been seen by millions of people worldwide, and he has earned numerous awards and accolades for his work. He inspires aspiring filmmakers, and his work continues to entertain audiences of all ages.
David Zucker's success as a real estate developer is largely attributed to his ability to identify new opportunities and capitalize on them.
He has a keen eye for potential investments and is always looking for new ways to leverage the real estate market. He has also established strong relationships with banks and other lenders, which has allowed him to secure financing for many of his projects.
David Zucker is a famous American filmmaker, writer, and actor best known for his popular comedies like Airplane!, The Naked Gun and the Scary Movie franchise. His films often feature strong physical comedy, deadpan humor, and parodies of genre conventions.
He frequently collaborates with his brother Jerry Zucker and director Jim Abrahams, forming the trio "The ZAZ Team". David Zucker has received praise from critics and moviegoers alike for his clever and witty approach to filmmaking.
Jerry Zucker is an American film director, producer and writer best known for the films Airplane!, The Naked Gun and Rat Race. He has an estimated net worth of $500 million, making him one of the wealthiest filmmakers in Hollywood.
David Zucker is married to his wife, Karen Maruyama. The two tied the knot in 2009 and have been together ever since.
David Zucker is a highly successful American film director, producer, and screenwriter. He was born on October 16, 1947, in Milwaukee, Wisconsin, making him 75 years old.
Jerry Zucker, the renowned director of Airplane! and The Naked Gun, recently had a sudden health scare. It was reported that he suffered from a heart attack, but he could recover fully.
Jerry is now doing well and is eager to get back to work on his next project. His fans are grateful for his quick recovery and hope he will continue to bring laughter and joy to audiences for years to come.
An American Carol (2008) is a satirical comedy directed by David Zucker and written by Myrna Sokoloff. The movie follows the story of a Hollywood filmmaker, Michael Malone (played by Kevin Farley), who is visited by three ghosts on a mission to change his anti-American ways.
The ghosts represent iconic American figures such as George Washington, Abraham Lincoln, and the Statue of Liberty to help Malone better understand the value of patriotism and the freedom America provides.
An American Carol (2008) is a comedy film starring Kevin Farley, and directed by David Zucker.
The story follows the journey of the main character, Michael Malone, as he tries to overcome his materialistic and anti-American values to become a true patriot.
Along the way, he meets many people who are willing to help him, including three spirits that try to change his perspective on life.
David Zucker's impact on comedy film is undeniable, and many have enjoyed his works for decades. With a net worth of millions, Zucker continues to work hard on various projects to create more entertainment for audiences. If you've ever enjoyed a Zucker comedy flick, check out Fidlarmusic and show your support!
The 20 Kevin Whately Net Worth 2023: Full Guide
Lists 18 Tony Martinez Net Worth 2023: Must Read
What is Shock G Net Worth 2023: Overview, Interview
What is Lenny Pickett Net Worth 2023: Overview, Interview
Top List 16 What is Dan Harmon Net Worth 2023: Full Guide


to help them make confident decisions.
Quit being dull and stale. People expect authentic engagement.
Today, it's no longer just about reach - it's about how motivated people are to engage with you.
Welcome to the Engagement Economy!
Knowing how to interact, engage and, more importantly, guide people in a personal way, whether they're in a store or online, is the only way businesses can survive in this new era.
The competitive advantage lies in a brand's ability to engage and retain customers, regardless of industry.
Do you want to deliver engaging, next-level experiences?
People have to make numerous decisions and choices every day and not all of them are easy.
Many years ago, we realized that what the digital environment was missing was the ability to engage with consumers and walk them through complex decisions in a human-friendly way.


So Dan Gilbert is over LeBron leaving? Riiiiiight.
The Cleveland Cavaliers owner has spent several hundred thousand dollars to pay a team of attorneys to build a tampering case against the Heat that he can then present to the NBA, according to Adrian Wojnarowski of Yahoo.
Gilbert officially declined comment on the report.
The release of this story the day before James returns to Cleveland by Wojnarowski — who has been hard on LeBron James, to put it mildly — makes the cynic in us come to the fore. There may well be some truth here, but take this with a few grains of salt is what we are saying. The timing of this certainly should play well in Cleveland… but certainly that is just a coincidence.
Tampering would be very hard to prove. No Heat player or representative — that includes Dwyane Wade — could talk to LeBron James or his representatives about the specifics of him and Chris Bosh coming to Miami prior to July 1. However, that is very different than the three of them saying, "we should all play together" at the Olympics.
The report is that the attorneys are targeting "an alleged Riley-James meeting in Miami in November 2009, and a meeting of James' inner circle with Wade in Chicago in June 2010, sources said." So, an alleged meeting well before the Heat knew exactly how much cap space they would have available, and Wade meeting with James' team — who met with a whole lot of people — are what we are focusing on here? There may be some smoke, but proving a fire is a very different thing.
If tampering were proven, the penalties could be severe, including losses of draft picks and suspensions for front office personnel.
There is a river of back-channel communications in the NBA. A Mississippi of such talk. To pull out parts of these things and prove tampering is a tall order.
But if you're Gilbert, it's something that plays well with the home fan base on the eve of James' return.


text:
Looking for more? ProQuest® Dissertations & Theses has additional dissertations and theses.
3594 open access dissertations and theses found for:
if(Pragmatist feminism) » Refine Search
1 - 30 of 3594 displayed. Next >
Sort by: Relevancy Most Recent Oldest First
West African Feminism: Maneuvering the Reality of Feminism Using Osun
by Adebayo, Adebanke, M.A. Southern Illinois University at Edwardsville. 2017: 79 pages; 10682016.
Full Text - PDF (507.81 KB)
'Our Feet Are Mired in the Same Soil': Deepening Democracy with the Political Virtue of Sympathetic Inquiry
by Fenton, Jennifer Lynn Kiefer, Ph.D. Marquette University. 2019: 217 pages; 13864568.
Human Rights and Justice Rights Approaches to Gender-Based Violence (GBV): The Case of Kenya's Sexual Offenses Act (KSOA)
by Kamunya, Maryanne W., M.A. University of Massachusetts Boston. 2019: 101 pages; 27665844.
The Effects of Tunisian State Feminism on Women's Associations in the Post-Revolution Context
by Domori, Amelie, M.A. The American University of Paris (France). 2013: 56 pages; 10305829.
Full Text - PDF (801 KB)
Discourse Analysis of Nigerian Feminism
by Okiriguo, Wendy, M.S. Southern Illinois University at Edwardsville. 2016: 99 pages; 10128866.
The Women's Liberation Movement in France and the Origins of Contemporary French feminism, 1944–1981
by Greenwald, Lisa, Ph.D. Emory University. 1996: 270 pages; 3472343.
Full Text - PDF (13.02 MB)
Communication and curation: Embodied meaning and praxis
by Swartz, Jeremy David, Ph.D. University of Oregon. 2016: 292 pages; 10193659.
Occupy feminism
by Cotter, Maura, M.A. California State University, Long Beach. 2015: 64 pages; 1604883.
Feminism, Liberalism, and Relational Autonomy
by McGill-Rutherford, Emily, Ph.D. Vanderbilt University. 2015: 148 pages; 13834905.
From Native Modernism to Native Feminism: Understanding Contemporary Native American Praxis
by Carnahan, Alanna, M.A. California State University, Long Beach. 2019: 112 pages; 13814529.
Living feminism in the academy: South African women tell their stories
by Corneilse, Carol E., Ph.D. University of Maryland, College Park. 2009: 180 pages; 3359370.
Queer Theory and Third-Wave Feminism in Pauline Oliveros's Meditative Works
by Ramirez, Eloy, M.M. The University of Arizona. 2020: 71 pages; 28025772.
Perceptions of feminism and identity among women in the Deaf community
by Jeffers, Sarah E., M.A. California State University, Long Beach. 2012: 113 pages; 1517646.
Responsible Consumerism and Feminism: Marketing Sustainable Products to Women in China
by Pickett, Whitney , M.A. The American University of Paris (France). 2016: 91 pages; 27605891.
Reform from Within: An Ecological Analysis of Institutionalized Feminism at Our University
by Howton, Amy Johnson, Ed.D. University of Cincinnati. 2011: 170 pages; 3475097.
Feminism From the Inside Out: Women and Yoga in the United States
by Champ, Amy Elizabeth, Ph.D. University of California, Davis. 2013: 455 pages; 3602020.
Full Text - PDF (2.4 MB)
Redressing women: Feminism in fashion and the creation of American style, 1930–1960
by Strassel, Annemarie Elizabeth, Ph.D. Yale University. 2008: 286 pages; 3317280.
Primary Feminism: The Politics of Endorsing Hillary Clinton in the 2008 Democratic Presidential Primary
by Calkin, Kayla, M.A. The George Washington University. 2011: 163 pages; 1498499.
In History No One Can Hear You Scream: Feminism and the Horror Film 1974-1996
by Mehls, Robert, M.A. University of Colorado at Boulder. 2015: 145 pages; 10003719.
Street queens: The Original Pinettes and black feminism in New Orleans brass bands
by DeCoste, Kyle, M.A. Tulane University. 2015: 119 pages; 1599202.
Can women have it all?: Hesitant feminism in American women's popular writing
by Aramand, Anne, M.A. University of Massachusetts Boston. 2013: 76 pages; 1550547.
Chicana Feminism Informs Educational Trajectories and Leadership: Graduate Student Testimonios from Nepantla
by Cordova, Amanda Jo, Ph.D. The University of Texas at San Antonio. 2018: 394 pages; 10928787.
American belly dance and the invention of the new exotic: Orientalism, feminism, and popular culture
by Haynes-Clark, Jennifer Lynn, M.A. Portland State University. 2010: 151 pages; 1477134.
R. Murray Gilchrist's short fiction: A missing link between English decadence and Victorian feminism
by Bush, Laurence C., M.A. California State University, Long Beach. 2010: 117 pages; 1493000.
A rhetorical analysis of Catholic feminism: Understanding prophetic and deliberative responses to the institutional Catholic Church
by Mascarenhas, Mridula, Ph.D. The University of Wisconsin - Milwaukee. 2014: 207 pages; 3633350.
Medicalization and neoliberal individualization of women's suffering in the context of third-wave/post-feminism
by Meek, Laura Anne, M.A. The George Washington University. 2010: 109 pages; 1475911.
Cinematic portrayals of ancient women: Cleopatra VII, Livia Augusta, Servilia Caepionis and the three waves of feminism
by Schwab, Andrea, M.A. Florida Atlantic University. 2016: 115 pages; 10583110.
Singing for our lives: Exploring the interaction of community, feminism and musical performance in the common woman chorus
by Womack, Jennifer L., M.A. The University of North Carolina at Chapel Hill. 2009: 130 pages; 1467319.
Refusing to be the other: Barbara Deming's experiments with nonviolence
by Updegrove, R. L., Ph.D. Northern Arizona University. 2014: 285 pages; 3633678.
Lenses of indigenous feminism: Digging up the roots of Western patriarchy in "Perma Red" and "Monkey Beach"
by CampBell, Pamela Kay, M.A. The University of Arizona. 2012: 122 pages; 1531669.
Full Text - PDF (887.7 KB)
1 - 30 of 3594 displayed.
1 2 3 4 5 6 7 8 9 10 11 Next >
Find Open Access Dissertations and Theses
There are additional search options following the search buttons.
Date degree received: from Any year 2021 2020 2019 2018 2017 2016 2015 2014 2013 2012 2011 2010 2009 2008 2007 2006 2005 2004 2003 2002 2001 2000 1999 1998 1997 1996 1995 1994 1993 1992 1991 1990 1989 1988 1987 1986 1985 1984 1983 1982 1981 1980 1979 1978 1977 1976 1975 1974 1973 1972 1971 1970 1969 1968 1967 1966 1965 1964 1963 1962 1961 1960 1959 1958 1957 1956 1955 1954 1953 1952 1951 to Any year 2021 2020 2019 2018 2017 2016 2015 2014 2013 2012 2011 2010 2009 2008 2007 2006 2005 2004 2003 2002 2001 2000 1999 1998 1997 1996 1995 1994 1993 1992 1991 1990 1989 1988 1987 1986 1985 1984 1983 1982 1981 1980 1979 1978 1977 1976 1975 1974 1973 1972 1971 1970 1969 1968 1967 1966 1965 1964 1963 1962 1961 1960 1959 1958 1957 1956 1955 1954 1953 1952 1951
^ Hide options
Title of dissertation/thesis:
School/Institution:
Keywords (dissertation topic):


Category Archives for "Legal resources"
Do you get a criminal record?
According to the verdict, you can be sentenced to imprisonment of up to 2 years. However, the maximum penalty for someone who has files and the past of criminal charges.
Is there a court order and a failure to appear in court?
The police will sometimes have the opportunity to make a written statement. In that case, you can declare yourself guilty and avoid going to court. This is not recommended. It is always better to appear to the court personally, and it is advisable for you to be represented by a lawyer, especially if you hope to avoid criminal convictions. Work shall be subject to a maximum sentence of 2 years in prison. Attending the court, you show judges to understand your actions and accept responsibility seriously.
Are police allowed to use sniffing dogs to detect drugs?
– The order is also not necessary in case of police raids in bars and pubs.
Do I have the right to quit?
Of course, you have the right to feel. You will no longer be punished for not completing the question. If you have cooperated with the police that can be at your disposal during the trial. If you are in doubt, seek legal advice.
What is the case of drug supply?
The supply of illegal substances is a much more serious charge of possession, and the maximum sentence is between 15 years and life imprisonment. A person will be charged with possession when the amount of substance is below the quantity to be transmitted and where there is proof of supply (e.g., Large amounts of money or small supply). The quantity of supplies for each drug varies, but as an example, methylamphetamine has an amount of 3 g that is transmitted, and ecstasy is 0.75 g. When the amount of drugs found in an individual's possession is above the amount transmitted, the prosecution can respond to the weight to prove that the drugs were for supply.


New England-based progressive death metal architects, ESCHATON, will unleash the audio abrasions that make up their Sentinel Apocalypse full-length upon the masses this May via Unique Leader Records.
A theological term that refers to the world during the post historic era of God's overt apocalyptic reign, immediately preceding the end of the world, ESCHATON was founded in 2007 near Providence, Rhode Island and manifests a uniquely belligerent, stand-alone sound that's at once harsh and procedural yet wholly-enthralling. Featuring vocalist Jason Viteri, guitarist brothers Joshua and Jared Berry, bassist Pat Pattison and drummer Darren Cesca (Pillory, Arsis, Goratory, Incinerate), Sentinel Apocalypse was captured at Cesca's House Of Grind Studios in southern Connecticut and supplies eleven tracks of some of the most visceral and unrelenting sounds the collective has ever composed. Rife with surgically precise guitar sweeps, debilitating drum work and enough vocal venom to collapse a population, Sentinel Apocalypse is fit for devotees of the maniacal craftings of Carnifex, The Faceless, Necrophagist, The Black Dahlia Murder and Beneath The Massacre.
Tear your ear drums to the sounds of Sentinel Apocalypse with a brand new video teaser at THIS LOCATION.
Sentinel Apocalypse will be released via Unique Leader Records on May 19th, 2015 with additional teaser tracks and preorders to be announced shortly.