mi32/mempool.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * \file mempool.h <mi32/mempool.h>
 * \brief A memory pool management class
 *
 * \if NODOC
 * $Log: mempool.h_v $
 * Revision 1.10  2006/10/12 17:21:03  mju
 * Remove unneeded hdrs.
 *
 * Revision 1.9  2005/11/11 21:36:59  dwilliss
 * Gave MEMPOOLLOW a copy ctor and assignment operator.  They just increment
 * refcount on the private data
 *
 * Revision 1.8  2005/11/11 16:08:36  dwilliss
 * added ctor with size hint
 *
 * Revision 1.7  2003/11/14 18:46:56  dwilliss
 * Don't use _T in templates. Some Unix systems define it in system includes
 *
 * Revision 1.6  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.5  2003/07/09 14:36:37  mju
 * Use standard name for classlibexport.
 *
 * Revision 1.4  2002/12/03 17:08:11  dwilliss
 * Changed API so that Alloc,Realloc and Free take references to pointers.
 * Used template methods to avoid need to cast.
 * Implementation class exported from DLL modified so that all data is in
 *   a PRIVDATA so that the sizeof(MEMPOOLLOW) will never have to change
 * Added a pointer to STATS structure so that if compiled with DEBUG #defined,
 *   (that is, misystem is compiled with DEBUG #defined), you can monitor
 *   the pool's memory usage in the debugger by expanding m_stats.
 *
 * Revision 1.3  2002/12/02 17:24:40  dwilliss
 * Finalized API.  Added Realloc method.  Gave both alloc methods a bClear
 * parameter (optional)
 *
 * Revision 1.2  2002/12/02 16:19:41  dwilliss
 * Document the class itself.
 *
 * Revision 1.1  2002/12/02 16:05:00  dwilliss
 * Initial revision
 *
 *
 * \endif
 ****************************************************************************/

#ifndef INC_MI32_MEMPOOL_H
#define INC_MI32_MEMPOOL_H

#ifndef INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#ifdef MISYSTEMDLL
 #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
 #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class CLASSLIBEXPORT MEMPOOLLOW {
   protected:

      MEMPOOLLOW();

      MEMPOOLLOW (
         INT32 SizeHint
         );

      MEMPOOLLOW (
         const MEMPOOLLOW& rhs
         );

      ~MEMPOOLLOW();


      MEMPOOLLOW& operator= (const MEMPOOLLOW& rhs);

      ERRVALUE AllocLow (
         void** ptr, 
         UINT32 size,
         bool bClear = false     
         );

      ERRVALUE ReallocLow (
         void** ptr, 
         UINT32 size,
         bool bClear = false 
         );

      void SetSizeHintLow (
         UINT32 size
         );

      static void FreeLow (
         void* ptr
         );


   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIVDATA;
      class BUCKET;
      struct STATS {
         UINT32 TotalAlloc;
         UINT32 FreeSpace;
         };
      
      PRIVDATA* m_priv;    
      STATS* m_stats;      
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

#endif 

class MEMPOOL : public MEMPOOLLOW {
   public:
      MEMPOOL() {}

      MEMPOOL (
         INT32 SizeHint
         ) :
         MEMPOOLLOW(SizeHint)
         {}

      ~MEMPOOL() {}

      template <class _CT> ERRVALUE Alloc (
         _CT*& ptr, 
         UINT32 size,
         bool bClear = false     
         ) {
         return (AllocLow((void**)&ptr, size, bClear));
         }

      template <class _CT> ERRVALUE Realloc (
         _CT*& ptr, 
         UINT32 size,
         bool bClear = false 
         ) {
         return (ReallocLow((void**)&ptr, size, bClear));
         }

      void SetSizeHint (
         UINT32 size
         ) {
         SetSizeHintLow(size);
         }


      template<class _CT> static void Free (
         _CT*& ptr
         ) {
         FreeLow(ptr);
         ptr = 0;
         }


   };


#undef CLASSLIBEXPORT

#endif

---