core/common/ts_vector.h

   1 /*
   2  * Simple vector (Thread safe implementation)
   3  *
   4  *                               Impl. by Eru
   5  */
   6
   7 #ifndef _CORELIB_COMMON_TS_VECTOR_H_
   8 #define _CORELIB_COMMON_TS_VECTOR_H_
   9
  10
  11 // Interface
  12 template <class T> class ITSVector
  13 {
  14 protected:
  15         size_t capacity;
  16         T **ary;
  17
  18 public:
  19         size_t count;
  20
  21         ITSVector() : count(0), capacity(32)
  22         {
  23                 ary = new T*[capacity];
  24         }
  25
  26         ~ITSVector()
  27         {
  28                 for (size_t i=0; i<count; ++i)
  29                         delete ary[i];
  30                 delete[] ary;
  31         }
  32
  33         virtual bool empty()
  34         {
  35                 return count == 0;
  36         }
  37
  38         virtual void lock() = 0;
  39         virtual void unlock() = 0;
  40
  41         virtual bool erase(size_t idx)
  42         {
  43                 delete ary[idx];
  44 //              for (size_t i=idx+1; i<count; ++i)
  45 //                      ary[i-1] = ary[i];
  46                 memmove(&ary[idx], &ary[idx+1], sizeof(T*) * (--count - idx));
  47
  48                 return true;
  49         }
  50
  51         virtual bool clear()
  52         {
  53                 for (size_t i=0; i<count; ++i)
  54                 {
  55                         delete ary[i];
  56                 }
  57                 count = 0;
  58
  59                 return true;
  60         }
  61
  62         virtual bool find(const T& tgt)
  63         {
  64                 for (size_t i=0; i<count; ++i)
  65                 {
  66                         if (*ary[i] == tgt)
  67                                 return true;
  68                 }
  69
  70                 return false;
  71         }
  72
  73         virtual bool find(const T& tgt, size_t* idx)
  74         {
  75                 for (size_t i=0; i<count; ++i)
  76                 {
  77                         if (*ary[i] == tgt)
  78                         {
  79                                 *idx = i;
  80                                 return true;
  81                         }
  82                 }
  83
  84                 return false;
  85         }
  86
  87         virtual bool push_back(const T& val)
  88         {
  89                 T *ptr = new T(val);
  90
  91                 if (count + 1 > capacity)
  92                 {
  93                         T **ptr = new T*[capacity * 2];
  94                         if (!ptr)
  95                                 return false;
  96
  97                         for (size_t i=0; i<capacity; ++i)
  98                                 ptr[i] = ary[i];
  99                         delete[] ary;
 100
 101                         ary = ptr;
 102                         capacity <<= 1;
 103                 }
 104
 105                 ary[count++] = ptr;
 106
 107                 return true;
 108         }
 109
 110         virtual T& at(size_t idx)
 111         {
 112                 if (idx >= count)
 113                         throw std::out_of_range("out of bounds");
 114
 115                 return *ary[idx];
 116         }
 117
 118         virtual T& operator[](size_t idx)
 119         {
 120                 return at(idx);
 121         }
 122 };
 123
 124
 125 #endif