src/squirrel/squirrel/squtils.h

   1 /*      see copyright notice in squirrel.h */
   2 #ifndef _SQUTILS_H_
   3 #define _SQUTILS_H_
   4
   5 #define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new (__ptr) __type;}
   6 #define sq_delete(__ptr,__type) {__ptr->~__type();sq_vm_free(__ptr,sizeof(__type));}
   7 #define SQ_MALLOC(__size) sq_vm_malloc((__size));
   8 #define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size));
   9 #define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size));
  10
  11 //sqvector mini vector class, supports objects by value
  12 template<typename T> class sqvector
  13 {
  14 public:
  15         sqvector()
  16         {
  17                 _vals = NULL;
  18                 _size = 0;
  19                 _allocated = 0;
  20         }
  21         sqvector(const sqvector<T>& v)
  22         {
  23                 copy(v);
  24         }
  25         void copy(const sqvector<T>& v)
  26         {
  27                 resize(v._size);
  28                 for(SQUnsignedInteger i = 0; i < v._size; i++) {
  29                         new ((void *)&_vals[i]) T(v._vals[i]);
  30                 }
  31                 _size = v._size;
  32         }
  33         ~sqvector()
  34         {
  35                 if(_allocated) {
  36                         for(SQUnsignedInteger i = 0; i < _size; i++)
  37                                 _vals[i].~T();
  38                         SQ_FREE(_vals, (_allocated * sizeof(T)));
  39                 }
  40         }
  41         void reserve(SQUnsignedInteger newsize) { _realloc(newsize); }
  42         void resize(SQUnsignedInteger newsize, const T& fill = T())
  43         {
  44                 if(newsize > _allocated)
  45                         _realloc(newsize);
  46                 if(newsize > _size) {
  47                         while(_size < newsize) {
  48                                 new ((void *)&_vals[_size]) T(fill);
  49                                 _size++;
  50                         }
  51                 }
  52                 else{
  53                         for(SQUnsignedInteger i = newsize; i < _size; i++) {
  54                                 _vals[i].~T();
  55                         }
  56                         _size = newsize;
  57                 }
  58         }
  59         void shrinktofit() { if(_size > 4) { _realloc(_size); } }
  60         T& top() const { return _vals[_size - 1]; }
  61         inline SQUnsignedInteger size() const { return _size; }
  62         bool empty() const { return (_size <= 0); }
  63         inline T &push_back(const T& val = T())
  64         {
  65                 if(_allocated <= _size)
  66                         _realloc(_size * 2);
  67                 return *(new ((void *)&_vals[_size++]) T(val));
  68         }
  69         inline void pop_back()
  70         {
  71                 _size--; _vals[_size].~T();
  72         }
  73         void insert(SQUnsignedInteger idx, const T& val)
  74         {
  75                 resize(_size + 1);
  76                 for(SQUnsignedInteger i = _size - 1; i > idx; i--) {
  77                         _vals[i] = _vals[i - 1];
  78                 }
  79         _vals[idx] = val;
  80         }
  81         void remove(SQUnsignedInteger idx)
  82         {
  83                 _vals[idx].~T();
  84                 if(idx < (_size - 1)) {
  85                         memmove(&_vals[idx], &_vals[idx+1], sizeof(T) * (_size - idx - 1));
  86                 }
  87                 _size--;
  88         }
  89         SQUnsignedInteger capacity() { return _allocated; }
  90         inline T &back() const { return _vals[_size - 1]; }
  91         inline T& operator[](SQUnsignedInteger pos) const{ return _vals[pos]; }
  92         T* _vals;
  93 private:
  94         void _realloc(SQUnsignedInteger newsize)
  95         {
  96                 newsize = (newsize > 0)?newsize:4;
  97                 _vals = (T*)SQ_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T));
  98                 _allocated = newsize;
  99         }
 100         SQUnsignedInteger _size;
 101         SQUnsignedInteger _allocated;
 102 };
 103
 104 #endif //_SQUTILS_H_