class ObjectPool
{
 public:
  //
  // Creates an object pool with chunkSize objects.
  // Whenever the object pool runs out of objects, chunkSize
  // more objects will be added to the pool. The pool only grows:
  // objects are never removed from the pool (freed), until
  // the pool is destroyed.
  //
  // chunkSize must be greater than 0.
  //
  ObjectPool(int chunkSize = kDefaultChunkSize)
    throw(invalid_argument, bad_alloc);

  //
  // Frees all the allocated objects. Invalidates any objects that have
  // been aquired for use.
  //
  ~ObjectPool();

  //
  // Reserve an object for use. The reference to the object is invalidated
  // if the object pool itself is freed.
  // 
  // Clients must not free the object!
  //
  T &acquireObject();

  //
  // Return the object to the pool. Clients must not use the object after
  // it has been returned to the pool.
  //
  void releaseObject(T &obj);

 protected:
  //
  // mFreeList stores the objects that are not currently in use
  // by clients.
  //
  queue mFreeList;
  //
  // mAllObjects stores pointers to all the objects, in use
  // or not. This vector is needed in order to ensure that all
  // objects are freed properly in the destructor.
  //
  vector mAllObjects;

  int mChunkSize;
  static const int kDefaultChunkSize;

  //
  // Allocate mChunkSize new objects and adds them
  // to the mFreeList.
  //
  void allocateChunk();
  static void arrayDeleteObject(T *obj);

 private:
  // prevent assignment and pass-by-value
  ObjectPool(const ObjectPool &src);
  ObjectPool &operator=(const ObjectPool &rhs);
};