开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
ArrayPool.hpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：18k
源码类别：

MySQL数据库

开发平台：

Visual C++

ArrayPool.hpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #ifndef ARRAY_POOL_HPP
  18. #define ARRAY_POOL_HPP
  20. #include <ndb_global.h>
  22. #include <pc.hpp>
  23. #include <ErrorReporter.hpp>
  24. #include <NdbMem.h>
  25. #include <Bitmask.hpp>
  27. template <class T> class Array;
  28. template <class T> class SLList;
  29. template <class T> class DLList;
  30. template <class T> class DLHashTable;
  32. /**
  33.  * Template class used for implementing an
  34.  *   pool of object (in an array with a free list)
  35.  */
  36. template <class T>
  37. class ArrayPool {
  38. public:
  39.   ArrayPool();
  40.   ~ArrayPool();
  41.   
  42.   /**
  43.    * Set the size of the pool
  44.    *
  45.    * Note, can currently only be called once
  46.    */
  47.   bool setSize(Uint32 noOfElements);
  49.   inline Uint32 getNoOfFree() const {
  50.     return noOfFree;
  51.   }
  53.   inline Uint32 getSize() const {
  54.     return size;
  55.   }
  57.   /**
  58.    * Update p value for ptr according to i value 
  59.    */
  60.   void getPtr(Ptr<T> &);
  61.   void getPtr(ConstPtr<T> &) const;
  62.   void getPtr(Ptr<T> &, bool CrashOnBoundaryError);
  63.   void getPtr(ConstPtr<T> &, bool CrashOnBoundaryError) const;
  64.   
  65.   /**
  66.    * Get pointer for i value
  67.    */
  68.   T * getPtr(Uint32 i);
  69.   const T * getConstPtr(Uint32 i) const;
  70.   T * getPtr(Uint32 i, bool CrashOnBoundaryError);
  71.   const T * getConstPtr(Uint32 i, bool CrashOnBoundaryError) const;
  73.   /**
  74.    * Update p & i value for ptr according to <b>i</b> value 
  75.    */
  76.   void getPtr(Ptr<T> &, Uint32 i);
  77.   void getPtr(ConstPtr<T> &, Uint32 i) const;
  78.   void getPtr(Ptr<T> &, Uint32 i, bool CrashOnBoundaryError);
  79.   void getPtr(ConstPtr<T> &, Uint32 i, bool CrashOnBoundaryError) const;
  81.   /**
  82.    * Allocate an object from pool - update Ptr
  83.    *
  84.    * Return i
  85.    */
  86.   bool seize(Ptr<T> &);
  88.   /**
  89.    * Allocate object <b>i</b> from pool - update Ptr
  90.    */
  91.   bool seizeId(Ptr<T> &, Uint32 i);
  93.   /**
  94.    * Check if <b>i</b> is allocated.
  95.    */
  96.   bool findId(Uint32 i) const;
  98.   /**
  99.    * Return an object to pool
  100.    */
  101.   void release(Uint32 i);
  103.   /**
  104.    * Return an object to pool
  105.    */
  106.   void release(Ptr<T> &);
  108. #ifdef ARRAY_GUARD
  109.   /**
  110.    *  Checks if i is a correct seized record
  111.    *
  112.    *  @note Since this is either an expensive method, 
  113.    *        or needs bitmask stuff, this method is only 
  114.    *        recommended for debugging.
  115.    *
  116.    */
  117.   bool isSeized(Uint32 i) const {
  118.     if (i>=size) return false;
  119.     return BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i);
  120.   }
  121. #endif
  123. protected:
  124.   friend class Array<T>;
  125.   friend class SLList<T>;
  126.   friend class DLList<T>;
  127.   friend class DLHashTable<T>;
  129.   /**
  130.    * Allocate <b>n</b> consecutive object from pool
  131.    *   return base
  132.    */
  133.   Uint32 seizeN(Uint32 n);
  135.   /**
  136.    * Deallocate <b>n<b> consecutive object to pool
  137.    *  starting from base
  138.    */
  139.   void releaseN(Uint32 base, Uint32 n);
  141. public:
  142.   /**
  143.    * Release a singel linked list in o(1)
  144.    * @param first i-value of first element in list
  145.    * @param last  i-value of last element in list
  146.    * @note nextPool must be used as next pointer in list
  147.    */
  148.   void releaseList(Uint32 n, Uint32 first, Uint32 last);
  149.   //private:
  151. #ifdef DEBUG
  152.   Uint32 getNoOfFree2() const {
  153.     Uint32 c2 = size;
  154.     for(Uint32 i = 0; i<((size + 31)>> 5); i++){
  155.       Uint32 w = theAllocatedBitmask[i];
  156.       for(Uint32 j = 0; j<32; j++){
  157. if((w & 1) == 1){
  158.   c2--;
  159. }
  160. w >>= 1;
  161.       }
  162.     }
  163.     return c2;
  164.   }
  166.   Uint32 getNoOfFree3() const {
  167.     Uint32 c = 0;
  168.     Ptr<T> p;
  169.     p.i = firstFree;
  170.     while(p.i != RNIL){
  171.       c++;
  172.       p.p = &theArray[p.i];
  173.       p.i = p.p->next;
  174.     }
  175.     return c;
  176.   }
  177. #endif
  179. protected:
  180.   Uint32 firstFree;
  181.   Uint32 size;
  182.   Uint32 noOfFree;
  183.   T * theArray;
  184.   Uint32 bitmaskSz;
  185.   Uint32 *theAllocatedBitmask;
  186. };
  188. template <class T>
  189. inline
  190. ArrayPool<T>::ArrayPool(){
  191.   firstFree = RNIL;
  192.   size = 0;
  193.   noOfFree = 0;
  194.   theArray = 0;
  195. #ifdef ARRAY_GUARD
  196.   theAllocatedBitmask = 0;
  197. #endif
  198. }
  200. template <class T>
  201. inline
  202. ArrayPool<T>::~ArrayPool(){
  203.   if(theArray != 0){
  204.     NdbMem_Free(theArray);
  205.     theArray = 0;
  206. #ifdef ARRAY_GUARD
  207.     delete []theAllocatedBitmask;
  208.     theAllocatedBitmask = 0;
  209. #endif
  210.   }
  211. }
  212.   
  213. /**
  214.  * Set the size of the pool
  215.  *
  216.  * Note, can currently only be called once
  217.  */
  218. template <class T>
  219. inline
  220. bool
  221. ArrayPool<T>::setSize(Uint32 noOfElements){
  222.   if(size == 0){
  223.     if(noOfElements == 0)
  224.       return true;
  225.     theArray = (T *)NdbMem_Allocate(noOfElements * sizeof(T));
  226.     if(theArray == 0)
  227.       return false;
  228.     size = noOfElements;
  229.     noOfFree = noOfElements;
  231.     /**
  232.      * Set next pointers
  233.      */
  234.     T * t = &theArray[0];
  235.     for(Uint32 i = 0; i<size; i++){
  236.       t->nextPool = (i + 1);
  237.       t++;
  238.     }
  239.     theArray[size-1].nextPool = RNIL;
  240.     firstFree = 0;
  242. #ifdef ARRAY_GUARD
  243.     bitmaskSz = (noOfElements + 31) >> 5;
  244.     theAllocatedBitmask = new Uint32[bitmaskSz];
  245.     BitmaskImpl::clear(bitmaskSz, theAllocatedBitmask);
  246. #endif
  247.     
  248.     return true;
  249.   }
  250.   return false;
  251. }
  252.   
  253. template <class T>
  254. inline
  255. void
  256. ArrayPool<T>::getPtr(Ptr<T> & ptr){
  257.   Uint32 i = ptr.i;
  258.   if(i < size){
  259.     ptr.p = &theArray[i];
  260. #ifdef ARRAY_GUARD
  261.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  262.       return;
  263.     /**
  264.      * Getting a non-seized element
  265.      */
  266.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  267. #endif
  268.   } else {
  269.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  270.   }
  271. }
  273. template <class T>
  274. inline
  275. void
  276. ArrayPool<T>::getPtr(ConstPtr<T> & ptr) const {
  277.   Uint32 i = ptr.i;
  278.   if(i < size){
  279.     ptr.p = &theArray[i];
  280. #ifdef ARRAY_GUARD
  281.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  282.       return;
  283.     /**
  284.      * Getting a non-seized element
  285.      */
  286.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  287. #endif
  288.   } else {
  289.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  290.   }
  291. }
  293. template <class T>
  294. inline
  295. void
  296. ArrayPool<T>::getPtr(Ptr<T> & ptr, Uint32 i){
  297.   ptr.i = i;
  298.   if(i < size){
  299.     ptr.p = &theArray[i];
  300. #ifdef ARRAY_GUARD
  301.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  302.       return;
  303.     /**
  304.      * Getting a non-seized element
  305.      */
  306.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  307. #endif
  308.   } else {
  309.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  310.   }
  311. }
  313. template <class T>
  314. inline
  315. void
  316. ArrayPool<T>::getPtr(ConstPtr<T> & ptr, Uint32 i) const {
  317.   ptr.i = i;
  318.   if(i < size){
  319.     ptr.p = &theArray[i];
  320. #ifdef ARRAY_GUARD
  321.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  322.       return;
  323.     /**
  324.      * Getting a non-seized element
  325.      */
  326.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  327. #endif
  328.   } else {
  329.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  330.   }
  331. }
  332.   
  333. template <class T>
  334. inline
  335. T * 
  336. ArrayPool<T>::getPtr(Uint32 i){
  337.   if(i < size){
  338. #ifdef ARRAY_GUARD
  339.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  340.       return &theArray[i];
  341.     /**
  342.      * Getting a non-seized element
  343.      */
  344.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  345.     return 0;
  346. #else
  347.     return &theArray[i];
  348. #endif
  349.   } else {
  350.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  351.     return 0;
  352.   }
  353. }
  355. template <class T>
  356. inline
  357. const T * 
  358. ArrayPool<T>::getConstPtr(Uint32 i) const {
  359.   if(i < size){
  360. #ifdef ARRAY_GUARD
  361.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  362.       return &theArray[i];
  363.     /**
  364.      * Getting a non-seized element
  365.      */
  366.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  367.     return 0;
  368. #else
  369.     return &theArray[i];
  370. #endif
  371.   } else {
  372.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  373.     return 0;
  374.   }
  375. }
  377. template <class T>
  378. inline
  379. void
  380. ArrayPool<T>::getPtr(Ptr<T> & ptr, bool CrashOnBoundaryError){
  381.   Uint32 i = ptr.i;
  382.   if(i < size){
  383.     ptr.p = &theArray[i];
  384. #ifdef ARRAY_GUARD
  385.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  386.       return;
  387.     /**
  388.      * Getting a non-seized element
  389.      */
  390.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  391. #endif
  392.   } else {
  393.     ptr.i = RNIL;
  394.   }
  395. }
  397. template <class T>
  398. inline
  399. void
  400. ArrayPool<T>::getPtr(ConstPtr<T> & ptr, bool CrashOnBoundaryError) const {
  401.   Uint32 i = ptr.i;
  402.   if(i < size){
  403.     ptr.p = &theArray[i];
  404. #ifdef ARRAY_GUARD
  405.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  406.       return;
  407.     /**
  408.      * Getting a non-seized element
  409.      */
  410.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  411. #endif
  412.   } else {
  413.     ptr.i = RNIL;
  414.   }
  415. }
  417. template <class T>
  418. inline
  419. void
  420. ArrayPool<T>::getPtr(Ptr<T> & ptr, Uint32 i, bool CrashOnBoundaryError){
  421.   ptr.i = i;
  422.   if(i < size){
  423.     ptr.p = &theArray[i];
  424. #ifdef ARRAY_GUARD
  425.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  426.       return;
  427.     /**
  428.      * Getting a non-seized element
  429.      */
  430.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  431. #endif
  432.   } else {
  433.     ptr.i = RNIL;
  434.   }
  435. }
  437. template <class T>
  438. inline
  439. void
  440. ArrayPool<T>::getPtr(ConstPtr<T> & ptr, Uint32 i, 
  441.      bool CrashOnBoundaryError) const {
  442.   ptr.i = i;
  443.   if(i < size){
  444.     ptr.p = &theArray[i];
  445. #ifdef ARRAY_GUARD
  446.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  447.       return;
  448.     /**
  449.      * Getting a non-seized element
  450.      */
  451.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  452. #endif
  453.   } else {
  454.     ptr.i = RNIL;
  455.   }
  456. }
  457.   
  458. template <class T>
  459. inline
  460. T * 
  461. ArrayPool<T>::getPtr(Uint32 i, bool CrashOnBoundaryError){
  462.   if(i < size){
  463. #ifdef ARRAY_GUARD
  464.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  465.       return &theArray[i];
  466.     /**
  467.      * Getting a non-seized element
  468.      */
  469.     ErrorReporter::handleAssert("ArrayPool<T>::getPtr", __FILE__, __LINE__);
  470.     return 0;
  471. #else
  472.     return &theArray[i];
  473. #endif
  474.   } else {
  475.     return 0;
  476.   }
  477. }
  479. template <class T>
  480. inline
  481. const T * 
  482. ArrayPool<T>::getConstPtr(Uint32 i, bool CrashOnBoundaryError) const {
  483.   if(i < size){
  484. #ifdef ARRAY_GUARD
  485.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i))
  486.       return &theArray[i];
  487.     /**
  488.      * Getting a non-seized element
  489.      */
  490.     ErrorReporter::handleAssert("ArrayPool<T>::getConstPtr", __FILE__,__LINE__);
  491.     return 0;
  492. #else
  493.     return &theArray[i];
  494. #endif
  495.   } else {
  496.     return 0;
  497.   }
  498. }
  499.   
  500. /**
  501.  * Allocate an object from pool - update Ptr
  502.  *
  503.  * Return i
  504.  */
  505. template <class T>
  506. inline
  507. bool
  508. ArrayPool<T>::seize(Ptr<T> & ptr){
  509.   Uint32 ff = firstFree;
  510.   if(ff != RNIL){
  511.     firstFree = theArray[ff].nextPool;
  512.     
  513.     ptr.i = ff;
  514.     ptr.p = &theArray[ff];
  515. #ifdef ARRAY_GUARD
  516.     if(!BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, ff)){
  517.       BitmaskImpl::set(bitmaskSz, theAllocatedBitmask, ff);
  518.       noOfFree--;
  519.       return true;
  520.     } else {
  521.       /**
  522.        * Seizing an already seized element
  523.        */
  524.       ErrorReporter::handleAssert("ArrayPool<T>::seize", __FILE__, __LINE__);
  525.       return false;
  526.     }
  527. #else
  528.     noOfFree--;
  529.     return true;
  530. #endif
  531.   }
  532.   ptr.i = RNIL;
  533.   ptr.p = NULL;
  534.   return false;
  535. }
  537. template <class T>
  538. inline
  539. bool
  540. ArrayPool<T>::seizeId(Ptr<T> & ptr, Uint32 i){
  541.   Uint32 ff = firstFree;
  542.   Uint32 prev = RNIL;
  543.   while(ff != i && ff != RNIL){
  544.     prev = ff;
  545.     ff = theArray[ff].nextPool;
  546.   }
  547.   
  548.   if(ff != RNIL){
  549.     if(prev == RNIL)
  550.       firstFree = theArray[ff].nextPool;
  551.     else
  552.       theArray[prev].nextPool = theArray[ff].nextPool;
  553.     
  554.     ptr.i = ff;
  555.     ptr.p = &theArray[ff];
  556. #ifdef ARRAY_GUARD
  557.     if(!BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, ff)){
  558.       BitmaskImpl::set(bitmaskSz, theAllocatedBitmask, ff);
  559.       noOfFree--;
  560.       return true;
  561.     } else {
  562.       /**
  563.        * Seizing an already seized element
  564.        */
  565.       ErrorReporter::handleAssert("ArrayPool<T>::seizeId", __FILE__, __LINE__);
  566.       return false;
  567.     }
  568. #else
  569.     noOfFree--;
  570.     return true;
  571. #endif
  572.   }
  573.   ptr.i = RNIL;
  574.   ptr.p = NULL;
  575.   return false;
  576. }
  578. template <class T>
  579. inline
  580. bool
  581. ArrayPool<T>::findId(Uint32 i) const {
  582.   if (i >= size)
  583.     return false;
  584.   Uint32 ff = firstFree;
  585.   while(ff != i && ff != RNIL){
  586.     ff = theArray[ff].nextPool;
  587.   }
  588.   return (ff == RNIL);
  589. }
  591. template<class T>
  592. Uint32
  593. ArrayPool<T>::seizeN(Uint32 n){
  594.   Uint32 curr = firstFree;
  595.   Uint32 prev = RNIL;
  596.   Uint32 sz = 0;
  597.   while(sz < n && curr != RNIL){
  598.     if(theArray[curr].nextPool == (curr + 1)){
  599.       sz++;
  600.     } else {
  601.       sz = 0;
  602.       prev = curr;
  603.     }
  604.     curr = theArray[curr].nextPool;
  605.   }
  606.   if(sz != n){
  607.     return RNIL;
  608.   }
  609.   const Uint32 base = curr - n;
  610.   if(base == firstFree){
  611.     firstFree = curr;
  612.   } else {
  613.     theArray[prev].nextPool = curr;
  614.   }
  615.   
  616.   noOfFree -= n;
  617. #ifdef ARRAY_GUARD
  618.   for(Uint32 j = base; j<curr; j++){
  619.     if(!BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, j)){
  620.       BitmaskImpl::set(bitmaskSz, theAllocatedBitmask, j);
  621.     } else {
  622.       /**
  623.        * Seizing an already seized element
  624.        */
  625.       ErrorReporter::handleAssert("ArrayPool<T>::seize", __FILE__, __LINE__);
  626.       return RNIL;
  627.     }
  628.   }
  629. #endif
  630.   return base;
  631. }
  633. template<class T>
  634. inline
  635. void 
  636. ArrayPool<T>::releaseN(Uint32 base, Uint32 n){
  637.   Uint32 curr = firstFree;
  638.   Uint32 prev = RNIL;
  639.   while(curr < base){
  640.     prev = curr;
  641.     curr = theArray[curr].nextPool;
  642.   }
  643.   if(curr == firstFree){
  644.     firstFree = base;
  645.   } else {
  646.     theArray[prev].nextPool = base;
  647.   }
  648.   const Uint32 end = base + n;
  649.   for(Uint32 i = base; i<end; i++){
  650. #ifdef ARRAY_GUARD
  651.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i)){
  652.       BitmaskImpl::clear(bitmaskSz, theAllocatedBitmask, i);
  653.     } else {
  654.       /**
  655.        * Relesing a already released element
  656.        */
  657.     ErrorReporter::handleAssert("ArrayPool<T>::release", __FILE__, __LINE__);
  658.       return;
  659.     }
  660. #endif
  661.     theArray[i].nextPool = i + 1;
  662.   }
  663.   theArray[end-1].nextPool = curr;
  664.   noOfFree += n;
  665. }
  667. template<class T>
  668. inline
  669. void 
  670. ArrayPool<T>::releaseList(Uint32 n, Uint32 first, Uint32 last){
  672.   if(first < size && last < size){
  673.     Uint32 ff = firstFree;
  674.     firstFree = first;
  675.     theArray[last].nextPool = ff;
  676.     noOfFree += n;
  678. #ifdef ARRAY_GUARD
  679.     Uint32 tmp = first;
  680.     for(Uint32 i = 0; i<n; i++){
  681.       if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, tmp)){
  682. BitmaskImpl::clear(bitmaskSz, theAllocatedBitmask, tmp);
  683.       } else {
  684. /**
  685.  * Relesing a already released element
  686.  */
  687. ErrorReporter::handleAssert("ArrayPool<T>::releaseList", 
  688.     __FILE__, __LINE__);
  689. return;
  690.       }
  691.       tmp = theArray[tmp].nextPool;
  692.     }
  693. #endif
  694.     return;
  695.   }
  696.   ErrorReporter::handleAssert("ArrayPool<T>::releaseList", __FILE__, __LINE__);
  697. }
  699. /**
  700.  * Return an object to pool
  701.  */
  702. template <class T>
  703. inline
  704. void
  705. ArrayPool<T>::release(Uint32 _i){
  706.   const Uint32 i = _i;
  707.   if(i < size){
  708.     Uint32 ff = firstFree;
  709.     theArray[i].nextPool = ff;
  710.     firstFree = i;
  712. #ifdef ARRAY_GUARD
  713.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i)){
  714.       BitmaskImpl::clear(bitmaskSz, theAllocatedBitmask, i);
  715.       noOfFree++;
  716.       return;
  717.     }
  718.     /**
  719.      * Relesing a already released element
  720.      */
  721.     ErrorReporter::handleAssert("ArrayPool<T>::release", __FILE__, __LINE__);
  722. #endif
  723.     noOfFree++;
  724.     return;
  725.   }
  726.   ErrorReporter::handleAssert("ArrayPool<T>::release", __FILE__, __LINE__);
  727. }
  729. /**
  730.  * Return an object to pool
  731.  */
  732. template <class T>
  733. inline
  734. void
  735. ArrayPool<T>::release(Ptr<T> & ptr){
  736.   Uint32 i = ptr.i;
  737.   if(i < size){
  738.     Uint32 ff = firstFree;
  739.     theArray[i].nextPool = ff;
  740.     firstFree = i;
  742. #ifdef ARRAY_GUARD
  743.     if(BitmaskImpl::get(bitmaskSz, theAllocatedBitmask, i)){
  744.       BitmaskImpl::clear(bitmaskSz, theAllocatedBitmask, i);
  745.       //assert(noOfFree() == noOfFree2());
  746.       noOfFree++;
  747.       return;
  748.     }
  749.     /**
  750.      * Relesing a already released element
  751.      */
  752.     ErrorReporter::handleAssert("ArrayPool<T>::release", __FILE__, __LINE__);
  753. #endif
  754.     noOfFree++;
  755.     return;
  756.   }
  757.   ErrorReporter::handleAssert("ArrayPool<T>::release", __FILE__, __LINE__);
  758. }
  760. template <class T>
  761. class UnsafeArrayPool : public ArrayPool<T> {
  762. public:
  763.   /**
  764.    * Update p value for ptr according to i value 
  765.    *   ignore if it's allocated or not
  766.    */
  767.   void getPtrForce(Ptr<T> &);
  768.   void getPtrForce(ConstPtr<T> &) const;
  769.   T * getPtrForce(Uint32 i);
  770.   const T * getConstPtrForce(Uint32 i) const;
  771.   void getPtrForce(Ptr<T> &, Uint32 i);
  772.   void getPtrForce(ConstPtr<T> &, Uint32 i) const;
  773. };
  775. template <class T>
  776. inline
  777. void 
  778. UnsafeArrayPool<T>::getPtrForce(Ptr<T> & ptr){
  779.   Uint32 i = ptr.i;
  780.   if(i < this->size){
  781.     ptr.p = &this->theArray[i];
  782.   } else {
  783.     ErrorReporter::handleAssert("UnsafeArrayPool<T>::getPtr", 
  784. __FILE__, __LINE__);
  785.   }
  786. }
  788. template <class T>
  789. inline
  790. void 
  791. UnsafeArrayPool<T>::getPtrForce(ConstPtr<T> & ptr) const{
  792.   Uint32 i = ptr.i;
  793.   if(i < this->size){
  794.     ptr.p = &this->theArray[i];
  795.   } else {
  796.     ErrorReporter::handleAssert("UnsafeArrayPool<T>::getPtr", 
  797. __FILE__, __LINE__);
  798.   }
  799. }
  801. template <class T>
  802. inline
  803. T * 
  804. UnsafeArrayPool<T>::getPtrForce(Uint32 i){
  805.   if(i < this->size){
  806.     return &this->theArray[i];
  807.   } else {
  808.     ErrorReporter::handleAssert("UnsafeArrayPool<T>::getPtr", 
  809. __FILE__, __LINE__);
  810.     return 0;
  811.   }
  812. }
  814. template <class T>
  815. inline
  816. const T * 
  817. UnsafeArrayPool<T>::getConstPtrForce(Uint32 i) const {
  818.   if(i < this->size){
  819.     return &this->theArray[i];
  820.   } else {
  821.     ErrorReporter::handleAssert("UnsafeArrayPool<T>::getPtr",
  822. __FILE__, __LINE__);
  823.     return 0;
  824.   }
  825. }
  827. template <class T>
  828. inline
  829. void 
  830. UnsafeArrayPool<T>::getPtrForce(Ptr<T> & ptr, Uint32 i){
  831.   ptr.i = i;
  832.   if(i < this->size){
  833.     ptr.p = &this->theArray[i];
  834.     return ;
  835.   } else {
  836.     ErrorReporter::handleAssert("UnsafeArrayPool<T>::getPtr", 
  837. __FILE__, __LINE__);
  838.   }
  839. }
  841. template <class T>
  842. inline
  843. void 
  844. UnsafeArrayPool<T>::getPtrForce(ConstPtr<T> & ptr, Uint32 i) const{
  845.   ptr.i = i;
  846.   if(i < this->size){
  847.     ptr.p = &this->theArray[i];
  848.     return ;
  849.   } else {
  850.     ErrorReporter::handleAssert("UnsafeArrayPool<T>::getPtr", 
  851. __FILE__, __LINE__);
  852.   }
  853. }
  856. #endif