Vector.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 NDB_VECTOR_HPP
  14. #define NDB_VECTOR_HPP
  15. #include <ndb_global.h>
  16. #include <NdbMutex.h>
  17. template<class T>
  18. struct Vector {
  19. public:
  20.   Vector(int sz = 10);
  21.   ~Vector();
  22.   T& operator[](unsigned i);
  23.   const T& operator[](unsigned i) const;
  24.   unsigned size() const { return m_size; };
  25.   
  26.   void push_back(const T &);
  27.   T& back();
  28.   
  29.   void erase(unsigned index);
  30.   
  31.   void clear();
  32.   
  33.   void fill(unsigned new_size, T & obj);
  34.   Vector<T>& operator=(const Vector<T>&);
  35.   T* getBase() { return m_items;}
  36.   const T* getBase() const { return m_items;}
  37. private:
  38.   T * m_items;
  39.   unsigned m_size;
  40.   unsigned m_incSize;
  41.   unsigned m_arraySize;
  42. };
  43. template<class T>
  44. Vector<T>::Vector(int i){
  45.   m_items = new T[i];
  46.   m_size = 0;
  47.   m_arraySize = i;
  48.   m_incSize = 50;
  49. }
  50. template<class T>
  51. Vector<T>::~Vector(){
  52.   delete[] m_items;
  53. }
  54. template<class T>
  55. T &
  56. Vector<T>::operator[](unsigned i){
  57.   if(i >= m_size)
  58.     abort();
  59.   return m_items[i];
  60. }
  61. template<class T>
  62. const T &
  63. Vector<T>::operator[](unsigned i) const {
  64.   if(i >= m_size)
  65.     abort();
  66.   return m_items[i];
  67. }
  68. template<class T>
  69. T &
  70. Vector<T>::back(){
  71.   return (* this)[m_size - 1];
  72. }
  73. template<class T>
  74. void
  75. Vector<T>::push_back(const T & t){
  76.   if(m_size == m_arraySize){
  77.     T * tmp = new T [m_arraySize + m_incSize];
  78.     for (unsigned k = 0; k < m_size; k++)
  79.       tmp[k] = m_items[k];
  80.     delete[] m_items;
  81.     m_items = tmp;
  82.     m_arraySize = m_arraySize + m_incSize;
  83.   }
  84.   m_items[m_size] = t;
  85.   m_size++;
  86. }
  87. template<class T>
  88. void
  89. Vector<T>::erase(unsigned i){
  90.   if(i >= m_size)
  91.     abort();
  92.   
  93.   for (unsigned k = i; k + 1 < m_size; k++)
  94.     m_items[k] = m_items[k + 1];
  95.   m_size--;
  96. }
  97. template<class T>
  98. void
  99. Vector<T>::clear(){
  100.   m_size = 0;
  101. }
  102. template<class T>
  103. void 
  104. Vector<T>::fill(unsigned new_size, T & obj){
  105.   while(m_size <= new_size)
  106.     push_back(obj);
  107. }
  108. template<class T>
  109. Vector<T>& 
  110. Vector<T>::operator=(const Vector<T>& obj){
  111.   if(this != &obj){
  112.     clear();
  113.     for(size_t i = 0; i<obj.size(); i++){
  114.       push_back(obj[i]);
  115.     }
  116.   }
  117.   return * this;
  118. }
  119. template<class T>
  120. struct MutexVector : public NdbLockable {
  121.   MutexVector(int sz = 10);
  122.   ~MutexVector();
  123.   T& operator[](unsigned i);
  124.   const T& operator[](unsigned i) const;
  125.   unsigned size() const { return m_size; };
  126.   
  127.   void push_back(const T &);
  128.   void push_back(const T &, bool lockMutex);
  129.   T& back();
  130.   
  131.   void erase(unsigned index);
  132.   void erase(unsigned index, bool lockMutex);
  133.   void clear();
  134.   void clear(bool lockMutex);
  135.   void fill(unsigned new_size, T & obj);
  136. private:
  137.   T * m_items;
  138.   unsigned m_size;
  139.   unsigned m_incSize;
  140.   unsigned m_arraySize;
  141. };
  142. template<class T>
  143. MutexVector<T>::MutexVector(int i){
  144.   m_items = new T[i];
  145.   m_size = 0;
  146.   m_arraySize = i;
  147.   m_incSize = 50;
  148. }
  149. template<class T>
  150. MutexVector<T>::~MutexVector(){
  151.   delete[] m_items;
  152. }
  153. template<class T>
  154. T &
  155. MutexVector<T>::operator[](unsigned i){
  156.   if(i >= m_size)
  157.     abort();
  158.   return m_items[i];
  159. }
  160. template<class T>
  161. const T &
  162. MutexVector<T>::operator[](unsigned i) const {
  163.   if(i >= m_size)
  164.     abort();
  165.   return m_items[i];
  166. }
  167. template<class T>
  168. T &
  169. MutexVector<T>::back(){
  170.   return (* this)[m_size - 1];
  171. }
  172. template<class T>
  173. void
  174. MutexVector<T>::push_back(const T & t){
  175.   lock();
  176.   if(m_size == m_arraySize){
  177.     T * tmp = new T [m_arraySize + m_incSize];
  178.     for (unsigned k = 0; k < m_size; k++)
  179.       tmp[k] = m_items[k];
  180.     delete[] m_items;
  181.     m_items = tmp;
  182.     m_arraySize = m_arraySize + m_incSize;
  183.   }
  184.   m_items[m_size] = t;
  185.   m_size++;
  186.   unlock();
  187. }
  188. template<class T>
  189. void
  190. MutexVector<T>::push_back(const T & t, bool lockMutex){
  191.   if(lockMutex) 
  192.     lock();
  193.   if(m_size == m_arraySize){
  194.     T * tmp = new T [m_arraySize + m_incSize];
  195.     for (unsigned k = 0; k < m_size; k++)
  196.       tmp[k] = m_items[k];
  197.     delete[] m_items;
  198.     m_items = tmp;
  199.     m_arraySize = m_arraySize + m_incSize;
  200.   }
  201.   m_items[m_size] = t;
  202.   m_size++;
  203.   if(lockMutex)
  204.     unlock();
  205. }
  206. template<class T>
  207. void
  208. MutexVector<T>::erase(unsigned i){
  209.   if(i >= m_size)
  210.     abort();
  211.   
  212.   lock();
  213.   for (unsigned k = i; k + 1 < m_size; k++)
  214.     m_items[k] = m_items[k + 1];
  215.   m_size--;
  216.   unlock();
  217. }
  218. template<class T>
  219. void
  220. MutexVector<T>::erase(unsigned i, bool _lock){
  221.   if(i >= m_size)
  222.     abort();
  223.   
  224.   if(_lock) 
  225.     lock();
  226.   for (unsigned k = i; k + 1 < m_size; k++)
  227.     m_items[k] = m_items[k + 1];
  228.   m_size--;
  229.   if(_lock) 
  230.     unlock();
  231. }
  232. template<class T>
  233. void
  234. MutexVector<T>::clear(){
  235.   lock();
  236.   m_size = 0;
  237.   unlock();
  238. }
  239. template<class T>
  240. void
  241. MutexVector<T>::clear(bool l){
  242.   if(l) lock();
  243.   m_size = 0;
  244.   if(l) unlock();
  245. }
  246. template<class T>
  247. void 
  248. MutexVector<T>::fill(unsigned new_size, T & obj){
  249.   while(m_size <= new_size)
  250.     push_back(obj);
  251. }
  252. #endif