external/squirrel/squirrel/squtils.h

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