include <ObjectPool.h>
  
  template<typename T>
  const int ObjectPool<T>::kDefaultChunkSize = 10;
  
  template <typename T>
  ObjectPool<T>::ObjectPool(int chunkSize) throw(invalid_argument, bad_alloc) :
    mChunkSize(chunkSize)
  {
    if (mChunkSize <= 0) {
      throw invalid_argument("chunk size must be positive");
    }
    // Create mChunkSize objects to start
    allocateChunk();
  }
  
    //
    // Allocates an array of mChunkSize objects because that's
    // more efficient than allocating each of them individually.
    // Stores a pointer to the first element of the array in the mAllObjects
    // vector. Adds a pointer to each new object to the mFreeList.
    //
  template <typename T>
  void ObjectPool<T>::allocateChunk()
  {
    T *newObjects = new T[mChunkSize];
    mAllObjects.push_back(newObjects);
    for (int i = 0; i < mChunkSize; i++) {
      mFreeList.push(&newObjects[i]);
    }
  }
  
    //
    // Freeing function for use in the for_each algorithm in the
    // destructor.
    //
  template<typename T>
  void ObjectPool<T>::arrayDeleteObject(T *obj)
  {
    delete [] obj;
  }
  
  template <typename T>
  ObjectPool<T>::~ObjectPool()
  {
    // free each of the allocation chunks
    for_each(mAllObjects.begin(), mAllObjects.end(), arrayDeleteObject);
  }
  
  template <typename T>
  T &ObjectPool<T>::acquireObject()
  {
    if (mFreeList.empty()) {
      allocateChunk();
    }
    T *obj = mFreeList.front();
    mFreeList.pop();
    return (*obj);
  }
  
  template <typename T>
  void ObjectPool<T>::releaseObject(T &obj)
  {
    mFreeList.push(&obj);
  }