external/squirrel/squirrel/squtils.h

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