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

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 SLLIST_HPP
  14. #define SLLIST_HPP
  15. #include "ArrayPool.hpp"
  16. #include <NdbOut.hpp>
  17. /**
  18.  * Template class used for implementing an
  19.  *   list of object retreived from a pool
  20.  */
  21. template <class T>
  22. class SLList {
  23. public:
  24.   /**
  25.    * List head
  26.    */
  27.   struct Head {
  28.     Head();
  29.     Uint32 firstItem;
  30.   };
  31.   
  32.   SLList(ArrayPool<T> & thePool);
  33.   
  34.   /**
  35.    * Allocate an object from pool - update Ptr
  36.    *
  37.    * Return i
  38.    */
  39.   bool seize(Ptr<T> &);
  40.   /**
  41.    * Allocate object <b>i</b> from pool - update Ptr
  42.    *
  43.    * Return i
  44.    */
  45.   bool seizeId(Ptr<T> &, Uint32 i);
  46.   /**
  47.    * Allocate <b>n</b>objects from pool
  48.    *
  49.    * Return i value of first object allocated or RNIL if fails
  50.    */
  51.   bool seizeN(Ptr<T> &, Uint32 n);
  52.   
  53.   /**
  54.    * Return all objects to the pool
  55.    */
  56.   void release();
  57.   /**
  58.    *  Update i & p value according to <b>i</b>
  59.    */
  60.   void getPtr(Ptr<T> &, Uint32 i) const;
  61.   
  62.   /**
  63.    * Update p value for ptr according to i value 
  64.    */
  65.   void getPtr(Ptr<T> &) const ;
  66.   
  67.   /**
  68.    * Get pointer for i value
  69.    */
  70.   T * getPtr(Uint32 i) const ;
  71.   /**
  72.    * Update ptr to first element in list
  73.    *
  74.    * Return i
  75.    */
  76.   bool first(Ptr<T> &) const ;
  77.   /**
  78.    * Get next element
  79.    *
  80.    * NOTE ptr must be both p & i
  81.    */
  82.   bool next(Ptr<T> &) const ;
  83.   
  84.   /**
  85.    * Check if next exists
  86.    *
  87.    * NOTE ptr must be both p & i
  88.    */
  89.   bool hasNext(const Ptr<T> &) const;
  90.   Uint32 noOfElements() const {
  91.     Uint32 c = 0;
  92.     Uint32 i = head.firstItem;
  93.     while(i != RNIL){
  94.       c++;
  95.       const T * t = thePool.getPtr(i);
  96.       i = t->nextList;
  97.     }
  98.     return c;
  99.   }
  100.   /**
  101.    * Print
  102.    * (Run operator NdbOut<< on every element)
  103.    */
  104.   void print(NdbOut & out) {
  105.     out << "firstItem = " << head.firstItem << endl;
  106.     Uint32 i = head.firstItem;
  107.     while(i != RNIL){
  108.       T * t = thePool.getPtr(i);
  109.       t->print(out); out << " ";
  110.       i = t->next;
  111.     }
  112.   }
  113.   inline bool empty() const { return head.firstItem == RNIL;}
  114. protected:
  115.   Head head;
  116.   ArrayPool<T> & thePool;
  117. };
  118. template<class T>
  119. class LocalSLList : public SLList<T> {
  120. public:
  121.   LocalSLList(ArrayPool<T> & thePool, typename SLList<T>::Head & _src)
  122.     : SLList<T>(thePool), src(_src)
  123.   {
  124.     this->head = src;
  125.   }
  126.   
  127.   ~LocalSLList(){
  128.     src = this->head;
  129.   }
  130. private:
  131.   typename SLList<T>::Head & src;
  132. };
  133. template <class T>
  134. inline
  135. SLList<T>::SLList(ArrayPool<T> & _pool):
  136.   thePool(_pool){
  137. }
  138. template<class T>
  139. inline
  140. SLList<T>::Head::Head(){
  141.   firstItem = RNIL;
  142. }
  143. template <class T>
  144. inline
  145. bool
  146. SLList<T>::seize(Ptr<T> & p){
  147.   thePool.seize(p);
  148.   T * t = p.p;
  149.   Uint32 ff = head.firstItem;
  150.   if(p.i != RNIL){
  151.     t->nextList = ff;
  152.     head.firstItem = p.i;
  153.     return true;
  154.   }
  155.   return false;
  156. }
  157. template <class T>
  158. inline
  159. bool
  160. SLList<T>::seizeId(Ptr<T> & p, Uint32 ir){
  161.   thePool.seizeId(p, ir);
  162.   T * t = p.p;
  163.   Uint32 ff = head.firstItem;
  164.   if(p.i != RNIL){
  165.     t->nextList = ff;
  166.     head.firstItem = p.i;
  167.     return true;
  168.   }
  169.   return false;
  170. }
  171. template <class T>
  172. inline
  173. bool
  174. SLList<T>::seizeN(Ptr<T> & p, Uint32 n){
  175.   for(Uint32 i = 0; i < n; i++){
  176.     if(seize(p) == RNIL){
  177.       /**
  178.        * Failure
  179.        */
  180.       for(; i > 0; i--){
  181. const Uint32 tmp = head.firstItem;
  182. const T * t = thePool.getPtr(tmp);
  183. head.firstItem = t->nextList;
  184. thePool.release(tmp);
  185.       }
  186.       return false;
  187.     }
  188.   }    
  189.   /**
  190.    * Success
  191.    */
  192.   p.i = head.firstItem;
  193.   p.p = thePool.getPtr(head.firstItem);
  194.   
  195.   return true;
  196. }
  197. template <class T>
  198. inline
  199. void 
  200. SLList<T>::release(){
  201.   while(head.firstItem != RNIL){
  202.     const T * t = thePool.getPtr(head.firstItem);
  203.     const Uint32 i = head.firstItem;
  204.     head.firstItem = t->nextList;
  205.     thePool.release(i);
  206.   }
  207. }  
  208. template <class T>
  209. inline
  210. void 
  211. SLList<T>::getPtr(Ptr<T> & p, Uint32 i) const {
  212.   p.i = i;
  213.   p.p = thePool.getPtr(i);
  214. }
  215. template <class T>
  216. inline
  217. void 
  218. SLList<T>::getPtr(Ptr<T> & p) const {
  219.   thePool.getPtr(p);
  220. }
  221.   
  222. template <class T>
  223. inline
  224. T * 
  225. SLList<T>::getPtr(Uint32 i) const {
  226.   return thePool.getPtr(i);
  227. }
  228. /**
  229.  * Update ptr to first element in list
  230.  *
  231.  * Return i
  232.  */
  233. template <class T>
  234. inline
  235. bool
  236. SLList<T>::first(Ptr<T> & p) const {
  237.   Uint32 i = head.firstItem;
  238.   p.i = i;
  239.   if(i != RNIL){
  240.     p.p = thePool.getPtr(i);
  241.     return true;
  242.   }
  243.   p.p = NULL;
  244.   return false;
  245. }
  246. template <class T>
  247. inline
  248. bool
  249. SLList<T>::next(Ptr<T> & p) const {
  250.   Uint32 i = p.p->nextList;
  251.   p.i = i;
  252.   if(i != RNIL){
  253.     p.p = thePool.getPtr(i);
  254.     return true;
  255.   }
  256.   p.p = NULL;
  257.   return false;
  258. }
  259. template <class T>
  260. inline
  261. bool
  262. SLList<T>::hasNext(const Ptr<T> & p) const {
  263.   return p.p->nextList != RNIL;
  264. }
  265. #endif