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

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

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

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

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

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

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

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

 protected KeyedObjectPool getKeyedPool() 
{
            return keyedPool;
}

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

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

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

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

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

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

 public  void returnObject(Object key,
    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
            }
}

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

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