---

sglObjPool.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sglObjPool.hpp
 *   Author: Tom Stimson
 *  Created: 26 Mar 2000
 *****************************************************************************/

#ifndef __SGL_OBJPOOL_HPP
#define __SGL_OBJPOOL_HPP

#include <sgl.h>
#include <vector>


template <class T>
class sglObjPool : public vector<T*>
{
public:
   typedef typename vector<T*>::const_iterator base_iterator;

public:
   // start     = initial number of objects to allocate
   // increment = number of objects to allocate when pool gets full
   sglObjPool(unsigned int start, unsigned int increment);
   ~sglObjPool();

   // Gets an unused object from the pool.
   T* newObject();

   // Returns an iterator to the current end of the used items in the pool.
   base_iterator currEnd() const { return m_curr_end; }

   // Returns the number of currently used objects in the pool.
   unsigned int currSize() const { return m_curr_end - begin(); }

   // Marks all items in the pool as unused.
   void reset() { m_curr_end = begin(); }

private: // not implemented
   sglObjPool();
   sglObjPool(const sglObjPool &);
   sglObjPool &operator=(const sglObjPool &);

private:
   unsigned int             m_increment;
   base_iterator            m_curr_end;
};


//----------------------------------------------------------------------------
template <class T>
inline sglObjPool<T>::sglObjPool(unsigned int start, unsigned int increment)
   : m_increment(increment)
{
   for (unsigned int i = 0; i < start; ++i)
      push_back(new T);

   m_curr_end = begin();
}

//----------------------------------------------------------------------------
template <class T>
inline sglObjPool<T>::~sglObjPool()
{
   for (base_iterator it = begin(); it != end(); ++it)
   {
      delete *it;
   }
}

//----------------------------------------------------------------------------
template <class T>
inline T* sglObjPool<T>::newObject()
{
   if (m_curr_end == end())
   {
      for (unsigned int i = 0; i < m_increment; ++i)
      {
         push_back(new T);
      }

      // push_back may invalidate iterators
      m_curr_end = end() - m_increment;
   }

   T* obj = *m_curr_end;
   ++m_curr_end;
   return obj;
}

#endif

---