Event/GeneratorObject/include/DataModel/DataPool.h

Go to the documentation of this file.

#ifndef DATAMODEL_DATAPOOL_H
#define DATAMODEL_DATAPOOL_H
/** @class DataPool
 * @brief  a typed memory pool that saves time spent
 *         allocation small object. This is typically used
 *         by container such as DataVector and DataList
 * @author Srini Rajagopalan - ATLAS Collaboration
 *$Id: DataPool.h,v 1.5 2003/08/19 23:52:06 calaf Exp $
 */
 
#ifndef _CPP_VECTOR
#  include <vector>
#endif
#ifndef _CPP_STRING
#  include <string>
#endif
#ifndef GAUDIKERNEL_SYSTEM_H
#  include "GaudiKernel/System.h"
#endif
#ifndef INTERFACES_IINCIDENTSVC_H
#  include "GaudiKernel/IIncidentSvc.h"
#endif
#ifndef KERNEL_STATUSCODES_H
#  include "GaudiKernel/StatusCode.h"
#endif
#ifndef GAUDIKERNEL_IINCIDENTLISTENER_H
#  include "GaudiKernel/IIncidentListener.h"
#endif
 
template <typename VALUE> class DataPool : virtual public IIncidentListener {
public:
  typedef std::vector<VALUE*>           Pool; // FIXME should be DataVector!
  typedef typename Pool::size_type      size_type;
  typedef typename Pool::pointer        pointer;
  typedef typename Pool::reference      reference;
  typedef typename Pool::iterator       iterator;
  typedef typename Pool::const_iterator const_iterator;
 
  //////////////////////////////////////////////////////////////////////
  /// Constructors:
  //////////////////////////////////////////////////////////////////////
 
  /// default constructor will initialize the pool with m_minRefCount
  DataPool<VALUE>();
 
  DataPool<VALUE>( size_type n );
 
  DataPool<VALUE>( int n );
 
  virtual ~DataPool<VALUE>();
  ///////////////////////////////////////////////////////
 
  /// set size of pool:
  void setSize( unsigned int size );
 
  /// reset refCount... but not maxRefCount.
  void reset();
 
  /// erase the pool and initializes m_minRefCount default elements
  void erase();
 
  /// return capacity of pool
  unsigned int capacity() { return m_pool.capacity(); }
 
  /// return size already allocated
  unsigned int allocated() { return m_refCount; }
 
  /// begin iterators over pool
  iterator       begin();
  const_iterator begin() const;
 
  /// the end() method will allow looping over only valid elements
  /// and not over ALL elements of the pool
  iterator       end();
  const_iterator end() const;
 
  /// obtain the next available element in pool by pointer
  /// return as void* to minimize misuse, client usage is:
  /// MyElement* m = new(pool->mem) MyElement(...); // pool is ptr
  void* mem();
 
  /// can also say:
  /// MyElement* m = new ((*pool)()) MyElement(...); // pool = pointer
  /// MyElement* m = new (pool()) MyElement(...); // pool = value
  void* operator()();
 
  /// typename of pool
  static const std::string& typeName();
 
  /// initialization
  void initialize();
 
  /// incident service handle
  void handle( const Incident& );
 
  /// methods to adhere to IInterface:
  virtual unsigned long addRef();
  virtual unsigned long release();
  virtual StatusCode    queryInterface( const InterfaceID& riid, void** ppvInterface );
  //-----------------------------------------------------------//
 
protected:
  /// should we allow clients to get a reference?
  /// obtain the next available element in pool by reference
  /// pool is resized if reached its limit
  reference nextElementRef();
 
  /// resize pool if usage exceeds capacity:
  void resizePool();
 
  //-----------------------------------------------------------//
 
private:
  /// minimum number of elements in pool
  static const unsigned int m_minRefCount = 1024;
 
  /// maximum elements in pool... can grow.
  unsigned int m_maxRefCount;
 
  /// refCount how many pool elements are in use
  unsigned int m_refCount;
 
  /// Pool:
  Pool m_pool;
 
  /// Incident Service
  IIncidentSvc* m_pIncSvc;
 
  /// reference counting to satisfy IInterface
  unsigned long m_instanceCount;
};
 
#include "DataModel/DataPool.icc"
 
#endif