Pool.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:6k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef FOR_LIB_POOL_H
  14. #define FOR_LIB_POOL_H
  15.  
  16. //===========================================================================
  17. //
  18. // .PUBLIC
  19. //
  20. //===========================================================================
  21.  
  22. ////////////////////////////////////////////////////////////////
  23. //
  24. // enum { defInitSize = 256, defIncSize  = 64 }; 
  25. // Description: type to store initial and incremental size in.
  26. //
  27. ////////////////////////////////////////////////////////////////
  28. //
  29. // Pool(int anInitSize = defInitSize, int anIncSize = defIncSize);
  30. // Description:
  31. //   Constructor. Allocates anInitSize of objects <template argument>.
  32. //   When the pool runs out of elements, anIncSize elements are added to the
  33. //   pool. (When the pool is not optimized to allocate multiple elements
  34. //   more efficient, the anIncSize MUST be set to 1 to get the best
  35. //   performance...
  36. //
  37. // Parameters:
  38. //   defInitSize: Initial size of the pool (# of elements in the pool)
  39. //   defIncSize:  # of elements added to the pool when a request to an empty
  40. //    pool is made.
  41. // Return value:
  42. //      _ 
  43. // Errors:
  44. //      -
  45. // Asserts:
  46. //   _
  47. //
  48. ////////////////////////////////////////////////////////////////
  49. //
  50. // virtual ~Pool();
  51. // Description:
  52. //   Elements in the pool are all deallocated.
  53. // Parameters:
  54. //   _
  55. // Return value:
  56. //   _
  57. // Errors:
  58. //      -
  59. // Asserts:
  60. //   theEmptyNodeList==0. No elements are in still in use.
  61. //
  62. ////////////////////////////////////////////////////////////////
  63. //
  64. // T& get();
  65. // Description:
  66. //   get's an element from the Pool.
  67. // Parameters:
  68. //   _
  69. // Return value:
  70. //   T& the element extracted from the Pool. (element must be cleared to
  71. //   mimick newly created element)
  72. // Errors:
  73. //      -
  74. // Asserts:
  75. //   _
  76. //
  77. ////////////////////////////////////////////////////////////////
  78. //
  79. // void put(T& aT);
  80. // Description:
  81. //   Returns an element to the pool.
  82. // Parameters:
  83. //   aT The element to put back in the pool
  84. // Return value:
  85. //   void 
  86. // Errors:
  87. //      -
  88. // Asserts:
  89. //   The pool has "empty" elements, to put element back in...
  90. //
  91. //===========================================================================
  92. //
  93. // .PRIVATE
  94. //
  95. //===========================================================================
  96.  
  97. ////////////////////////////////////////////////////////////////
  98. //
  99. // void allocate(int aSize);
  100. // Description:
  101. //   add aSize elements to the pool
  102. // Parameters:
  103. //   aSize: # of elements to add to the pool
  104. // Return value:
  105. //   void 
  106. // Errors:
  107. //      -
  108. // Asserts:
  109. //   _
  110. //
  111. ////////////////////////////////////////////////////////////////
  112. //
  113. // void deallocate();
  114. // Description:
  115. //   frees all elements kept in the pool.
  116. // Parameters:
  117. //   _
  118. // Return value:
  119. //   void 
  120. // Errors:
  121. //      -
  122. // Asserts:
  123. //   No elements are "empty" i.e. in use.
  124. //
  125. //===========================================================================
  126. //
  127. // .PRIVATE
  128. //
  129. //===========================================================================
  130.  
  131. ////////////////////////////////////////////////////////////////
  132. //
  133. // Pool<T>& operator=(const Pool<T>& cp);
  134. // Description:
  135. //   Prohibit use of assignement operator.
  136. // Parameters:
  137. //   cp
  138. // Return value:
  139. //   Pool<T>& 
  140. // Asserts:
  141. //   _
  142. //
  143. ////////////////////////////////////////////////////////////////
  144. //
  145. // Pool(const Pool<T>& cp);
  146. // Description:
  147. //   Prohibit use of default copy constructor.
  148. // Parameters:
  149. //   cp
  150. // Return value:
  151. //   _
  152. // Errors:
  153. //      -
  154. // Asserts:
  155. //   _
  156. //
  157. ////////////////////////////////////////////////////////////////
  158. //
  159. // int initSize;
  160. // Description: size of the initial size of the pool
  161. //
  162. ////////////////////////////////////////////////////////////////
  163. //
  164. // int incSize;
  165. // Description: # of elements added to the pool when pool is exhausted.
  166. //
  167. ////////////////////////////////////////////////////////////////
  168. //
  169. // PoolElement<T>* theFullNodeList;
  170. // Description: List to contain all "unused" elements in the pool
  171. //
  172. ////////////////////////////////////////////////////////////////
  173. //
  174. // PoolElement<T>* theEmptyNodeList;
  175. // Description: List to contain all "in use" elements in the pool
  176. //
  177. //-------------------------------------------------------------------------
  178. template <class T>
  179. class Pool
  180. {
  181. public:
  182.   enum { defInitSize = 256, defIncSize  = 64 }; 
  183.    
  184.   Pool(int anInitSize = defInitSize, int anIncSize = defIncSize) :
  185.     theIncSize(anIncSize),
  186.     theTop(0),
  187.     theCurrentSize(0),   
  188.     theList(0)
  189.   {
  190.     allocate(anInitSize);
  191.   }
  192.   
  193.   virtual ~Pool(void)
  194.   {
  195.     for (int i=0; i <theTop ; ++i)
  196.       delete theList[i];
  197.     
  198.     delete []theList;
  199.   }
  200.   
  201.   T* get();
  202.   void put(T* aT);
  203.   unsigned size(){ return theTop; };
  204.   
  205. protected:
  206.   void allocate(int aSize)
  207.   {
  208.     T** tList = theList;
  209.     int i;
  210.     theList = new T*[aSize+theCurrentSize];
  211.     // allocate full list
  212.     for (i = 0; i < theTop; i++) {
  213.       theList[i] = tList[i];
  214.     }
  215.     delete []tList;
  216.     for (; (theTop < aSize); theTop++){
  217.       theList[theTop] = (T*)new T;
  218.     }
  219.     theCurrentSize += aSize;
  220.   }
  221.   
  222. private:
  223.   Pool<T>& operator=(const Pool<T>& cp);
  224.   Pool(const Pool<T>& cp);
  225.   
  226.   int theIncSize;
  227.   int theTop;
  228.   int theCurrentSize;
  229.   
  230.   T** theList;
  231. };
  232. //******************************************************************************
  233. template <class T> inline T* Pool<T>::get()
  234. {
  235.    T* tmp;
  236.    if( theTop == 0 )
  237.    {
  238.       allocate(theIncSize);
  239.    }
  240.    --theTop;
  241.    tmp = theList[theTop];
  242.    return tmp;
  243. }
  244. //
  245. //******************************************************************************
  246. template <class T> inline void Pool<T>::put(T* aT)
  247. {
  248.    theList[theTop]= aT;
  249.    ++theTop;
  250. }
  251. #endif