How to use

assertOpen

method

in

org.apache.commons.pool.impl.GenericObjectPool

/**
 * Create an object, and place it into the pool.
 * addObject() is useful for "pre-loading" a pool with idle objects.
 */
@Override
public void addObject() throws Exception {
  assertOpen();
  if (_factory == null) {
    throw new IllegalStateException("Cannot add objects without a factory.");
  }
  T obj = _factory.makeObject();
  try {
    assertOpen();
    addObjectToPool(obj, false);
  } catch (IllegalStateException ex) { // Pool closed
    try {
      _factory.destroyObject(obj);
    } catch (Exception ex2) {
      // swallow
    }
    throw ex;
  }
}

/**
 * Sets the {@link PoolableObjectFactory factory} this pool uses
 * to create new instances. Trying to change
 * the <code>factory</code> while there are borrowed objects will
 * throw an {@link IllegalStateException}.  If there are instances idle
 * in the pool when this method is invoked, these will be destroyed
 * using the original factory.
 *
 * @param factory the {@link PoolableObjectFactory} used to create new instances.
 * @throws IllegalStateException when the factory cannot be set at this time
 * @deprecated to be removed in version 2.0
 */
@Deprecated
@Override
public void setFactory(PoolableObjectFactory<T> factory) throws IllegalStateException {
  List<ObjectTimestampPair<T>> toDestroy = new ArrayList<ObjectTimestampPair<T>>();
  final PoolableObjectFactory<T> oldFactory = _factory;
  synchronized (this) {
    assertOpen();
    if(0 < getNumActive()) {
      throw new IllegalStateException("Objects are already active");
    } else {
      toDestroy.addAll(_pool);
      _numInternalProcessing = _numInternalProcessing + _pool._size;
      _pool.clear();
    }
    _factory = factory;
  }
  destroy(toDestroy, oldFactory); 
}

assertOpen();

assertOpen();
synchronized (this) {
  if(_pool.isEmpty()) {

/**
 * Create an object, and place it into the pool.
 * addObject() is useful for "pre-loading" a pool with idle objects.
 */
public void addObject() throws Exception {
  assertOpen();
  if (_factory == null) {
    throw new IllegalStateException("Cannot add objects without a factory.");
  }
  Object obj = _factory.makeObject();
  try {
    assertOpen();
    addObjectToPool(obj, false);
  } catch (IllegalStateException ex) { // Pool closed
    try {
      _factory.destroyObject(obj);
    } catch (Exception ex2) {
      // swallow
    }
    throw ex;
  }
}

/**
 * Create an object, and place it into the pool.
 * addObject() is useful for "pre-loading" a pool with idle objects.
 */
public void addObject() throws Exception {
  assertOpen();
  if (_factory == null) {
    throw new IllegalStateException("Cannot add objects without a factory.");
  }
  Object obj = _factory.makeObject();
  try {
    assertOpen();
    addObjectToPool(obj, false);
  } catch (IllegalStateException ex) { // Pool closed
    try {
      _factory.destroyObject(obj);
    } catch (Exception ex2) {
      // swallow
    }
    throw ex;
  }
}

/**
 * Create an object, and place it into the pool.
 * addObject() is useful for "pre-loading" a pool with idle objects.
 */
@Override
public void addObject() throws Exception {
  assertOpen();
  if (_factory == null) {
    throw new IllegalStateException("Cannot add objects without a factory.");
  }
  T obj = _factory.makeObject();
  try {
    assertOpen();
    addObjectToPool(obj, false);
  } catch (IllegalStateException ex) { // Pool closed
    try {
      _factory.destroyObject(obj);
    } catch (Exception ex2) {
      // swallow
    }
    throw ex;
  }
}

/**
 * Create an object, and place it into the pool.
 * addObject() is useful for "pre-loading" a pool with idle objects.
 */
@Override
public void addObject() throws Exception {
  assertOpen();
  if (_factory == null) {
    throw new IllegalStateException("Cannot add objects without a factory.");
  }
  T obj = _factory.makeObject();
  try {
    assertOpen();
    addObjectToPool(obj, false);
  } catch (IllegalStateException ex) { // Pool closed
    try {
      _factory.destroyObject(obj);
    } catch (Exception ex2) {
      // swallow
    }
    throw ex;
  }
}

/**
 * Sets the {@link PoolableObjectFactory factory} this pool uses
 * to create new instances. Trying to change
 * the <code>factory</code> while there are borrowed objects will
 * throw an {@link IllegalStateException}.
 *
 * @param factory the {@link PoolableObjectFactory} used to create new instances.
 * @throws IllegalStateException when the factory cannot be set at this time
 */
public void setFactory(PoolableObjectFactory factory) throws IllegalStateException {
  List toDestroy = new ArrayList();
  synchronized (this) {
    assertOpen();
    if(0 < getNumActive()) {
      throw new IllegalStateException("Objects are already active");
    } else {
      toDestroy.addAll(_pool);
      _numInternalProcessing = _numInternalProcessing + _pool._size;
      _pool.clear();
    }
    _factory = factory;
  }
  destroy(toDestroy);
}

/**
 * Sets the {@link PoolableObjectFactory factory} this pool uses
 * to create new instances. Trying to change
 * the <code>factory</code> while there are borrowed objects will
 * throw an {@link IllegalStateException}.
 *
 * @param factory the {@link PoolableObjectFactory} used to create new instances.
 * @throws IllegalStateException when the factory cannot be set at this time
 */
public void setFactory(PoolableObjectFactory factory) throws IllegalStateException {
  List toDestroy = new ArrayList();
  synchronized (this) {
    assertOpen();
    if(0 < getNumActive()) {
      throw new IllegalStateException("Objects are already active");
    } else {
      toDestroy.addAll(_pool);
      _numInternalProcessing = _numInternalProcessing + _pool._size;
      _pool.clear();
    }
    _factory = factory;
  }
  destroy(toDestroy);
}

/**
 * Sets the {@link PoolableObjectFactory factory} this pool uses
 * to create new instances. Trying to change
 * the <code>factory</code> while there are borrowed objects will
 * throw an {@link IllegalStateException}.  If there are instances idle
 * in the pool when this method is invoked, these will be destroyed
 * using the original factory.
 *
 * @param factory the {@link PoolableObjectFactory} used to create new instances.
 * @throws IllegalStateException when the factory cannot be set at this time
 * @deprecated to be removed in version 2.0
 */
@Deprecated
@Override
public void setFactory(PoolableObjectFactory<T> factory) throws IllegalStateException {
  List<ObjectTimestampPair<T>> toDestroy = new ArrayList<ObjectTimestampPair<T>>();
  final PoolableObjectFactory<T> oldFactory = _factory;
  synchronized (this) {
    assertOpen();
    if(0 < getNumActive()) {
      throw new IllegalStateException("Objects are already active");
    } else {
      toDestroy.addAll(_pool);
      _numInternalProcessing = _numInternalProcessing + _pool._size;
      _pool.clear();
    }
    _factory = factory;
  }
  destroy(toDestroy, oldFactory); 
}

/**
 * Sets the {@link PoolableObjectFactory factory} this pool uses
 * to create new instances. Trying to change
 * the <code>factory</code> while there are borrowed objects will
 * throw an {@link IllegalStateException}.  If there are instances idle
 * in the pool when this method is invoked, these will be destroyed
 * using the original factory.
 *
 * @param factory the {@link PoolableObjectFactory} used to create new instances.
 * @throws IllegalStateException when the factory cannot be set at this time
 * @deprecated to be removed in version 2.0
 */
@Deprecated
@Override
public void setFactory(PoolableObjectFactory<T> factory) throws IllegalStateException {
  List<ObjectTimestampPair<T>> toDestroy = new ArrayList<ObjectTimestampPair<T>>();
  final PoolableObjectFactory<T> oldFactory = _factory;
  synchronized (this) {
    assertOpen();
    if(0 < getNumActive()) {
      throw new IllegalStateException("Objects are already active");
    } else {
      toDestroy.addAll(_pool);
      _numInternalProcessing = _numInternalProcessing + _pool._size;
      _pool.clear();
    }
    _factory = factory;
  }
  destroy(toDestroy, oldFactory); 
}

assertOpen();

assertOpen();

assertOpen();

assertOpen();

assertOpen();
synchronized (this) {
  if(_pool.isEmpty()) {

assertOpen();
synchronized (this) {
  if(_pool.isEmpty()) {

assertOpen();
synchronized (this) {
  if(_pool.isEmpty()) {

assertOpen();
synchronized (this) {
  if(_pool.isEmpty()) {