squtils.h

00001 /*  see copyright notice in squirrel.h */
00002 #ifndef _SQUTILS_H_
00003 #define _SQUTILS_H_
00004 
00005 void *sq_vm_malloc(SQUnsignedInteger size);
00006 void *sq_vm_realloc(void *p,SQUnsignedInteger oldsize,SQUnsignedInteger size);
00007 void sq_vm_free(void *p,SQUnsignedInteger size);
00008 
00009 #define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new (__ptr) __type;}
00010 #define sq_delete(__ptr,__type) {__ptr->~__type();sq_vm_free(__ptr,sizeof(__type));}
00011 #define SQ_MALLOC(__size) sq_vm_malloc((__size));
00012 #define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size));
00013 #define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size));
00014 
00015 #define sq_aligning(v) (((size_t)(v) + (SQ_ALIGNMENT-1)) & (~(SQ_ALIGNMENT-1)))
00016 
00017 //sqvector mini vector class, supports objects by value
00018 template<typename T> class sqvector
00019 {
00020 public:
00021     sqvector()
00022     {
00023         _vals = NULL;
00024         _size = 0;
00025         _allocated = 0;
00026     }
00027     sqvector(const sqvector<T>& v)
00028     {
00029         copy(v);
00030     }
00031     void copy(const sqvector<T>& v)
00032     {
00033         if(_size) {
00034             resize(0); //destroys all previous stuff
00035         }
00036         //resize(v._size);
00037         if(v._size > _allocated) {
00038             _realloc(v._size);
00039         }
00040         for(SQUnsignedInteger i = 0; i < v._size; i++) {
00041             new ((void *)&_vals[i]) T(v._vals[i]);
00042         }
00043         _size = v._size;
00044     }
00045     ~sqvector()
00046     {
00047         if(_allocated) {
00048             for(SQUnsignedInteger i = 0; i < _size; i++)
00049                 _vals[i].~T();
00050             SQ_FREE(_vals, (_allocated * sizeof(T)));
00051         }
00052     }
00053     void reserve(SQUnsignedInteger newsize) { _realloc(newsize); }
00054     void resize(SQUnsignedInteger newsize, const T& fill = T())
00055     {
00056         if(newsize > _allocated)
00057             _realloc(newsize);
00058         if(newsize > _size) {
00059             while(_size < newsize) {
00060                 new ((void *)&_vals[_size]) T(fill);
00061                 _size++;
00062             }
00063         }
00064         else{
00065             for(SQUnsignedInteger i = newsize; i < _size; i++) {
00066                 _vals[i].~T();
00067             }
00068             _size = newsize;
00069         }
00070     }
00071     void shrinktofit() { if(_size > 4) { _realloc(_size); } }
00072     T& top() const { return _vals[_size - 1]; }
00073     inline SQUnsignedInteger size() const { return _size; }
00074     bool empty() const { return (_size <= 0); }
00075     inline T &push_back(const T& val = T())
00076     {
00077         if(_allocated <= _size)
00078             _realloc(_size * 2);
00079         return *(new ((void *)&_vals[_size++]) T(val));
00080     }
00081     inline void pop_back()
00082     {
00083         _size--; _vals[_size].~T();
00084     }
00085     void insert(SQUnsignedInteger idx, const T& val)
00086     {
00087         resize(_size + 1);
00088         for(SQUnsignedInteger i = _size - 1; i > idx; i--) {
00089             _vals[i] = _vals[i - 1];
00090         }
00091         _vals[idx] = val;
00092     }
00093     void remove(SQUnsignedInteger idx)
00094     {
00095         _vals[idx].~T();
00096         if(idx < (_size - 1)) {
00097             memmove(&_vals[idx], &_vals[idx+1], sizeof(T) * (_size - idx - 1));
00098         }
00099         _size--;
00100     }
00101     SQUnsignedInteger capacity() { return _allocated; }
00102     inline T &back() const { return _vals[_size - 1]; }
00103     inline T& operator[](SQUnsignedInteger pos) const{ return _vals[pos]; }
00104     T* _vals;
00105 private:
00106     void _realloc(SQUnsignedInteger newsize)
00107     {
00108         newsize = (newsize > 0)?newsize:4;
00109         _vals = (T*)SQ_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T));
00110         _allocated = newsize;
00111     }
00112     SQUnsignedInteger _size;
00113     SQUnsignedInteger _allocated;
00114 };
00115 
00116 #endif //_SQUTILS_H_