CheckedKeyedObjectPool(KeyedObjectPool keyedPool,
    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  void addObject(Object key) throws Exception, UnsupportedOperationException, IllegalStateException 
{
            keyedPool.addObject(key);
}

 public Object borrowObject(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 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 as of Pool 2
            }
}

 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) 
{
            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 returnObject(Object key,
    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 setFactory(KeyedPoolableObjectFactory factory) throws UnsupportedOperationException, IllegalStateException 
{
            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();
}