source/libps/psutils.h

0001 /*  see copyright notice in pscript.h */
0002 #ifndef _PSUTILS_H_
0003 #define _PSUTILS_H_
0004
0005 void *ps_vm_malloc(PSUnsignedInteger size);
0006 void *ps_vm_realloc(void *p,PSUnsignedInteger oldsize,PSUnsignedInteger size);
0007 void ps_vm_free(void *p,PSUnsignedInteger size);
0008
0009 #define ps_new(__ptr,__type) {__ptr=(__type *)ps_vm_malloc(sizeof(__type));new (__ptr) __type;}
0010 #define ps_delete(__ptr,__type) {__ptr->~__type();ps_vm_free(__ptr,sizeof(__type));}
0011 #define PS_MALLOC(__size) ps_vm_malloc((__size));
0012 #define PS_FREE(__ptr,__size) ps_vm_free((__ptr),(__size));
0013 #define PS_REALLOC(__ptr,__oldsize,__size) ps_vm_realloc((__ptr),(__oldsize),(__size));
0014
0015 #define ps_aligning(v) (((size_t)(v) + (PS_ALIGNMENT-1)) & (~(PS_ALIGNMENT-1)))
0016
0017 //psvector mini vector class, supports objects by value

0018 template<typename T> class psvector
0019 {
0020 public:
0021     psvector()
0022     {
0023         _vals = NULL;
0024         _size = 0;
0025         _allocated = 0;
0026     }
0027     psvector(const psvector<T>& v)
0028     {
0029         copy(v);
0030     }
0031     void copy(const psvector<T>& v)
0032     {
0033         if(_size) {
0034             resize(0); //destroys all previous stuff

0035         }
0036         //resize(v._size);

0037         if(v._size > _allocated) {
0038             _realloc(v._size);
0039         }
0040         for(PSUnsignedInteger i = 0; i < v._size; i++) {
0041             new ((void *)&_vals[i]) T(v._vals[i]);
0042         }
0043         _size = v._size;
0044     }
0045     ~psvector()
0046     {
0047         if(_allocated) {
0048             for(PSUnsignedInteger i = 0; i < _size; i++)
0049                 _vals[i].~T();
0050             PS_FREE(_vals, (_allocated * sizeof(T)));
0051         }
0052     }
0053     void reserve(PSUnsignedInteger newsize) { _realloc(newsize); }
0054     void resize(PSUnsignedInteger newsize, const T& fill = T())
0055     {
0056         if(newsize > _allocated)
0057             _realloc(newsize);
0058         if(newsize > _size) {
0059             while(_size < newsize) {
0060                 new ((void *)&_vals[_size]) T(fill);
0061                 _size++;
0062             }
0063         }
0064         else{
0065             for(PSUnsignedInteger i = newsize; i < _size; i++) {
0066                 _vals[i].~T();
0067             }
0068             _size = newsize;
0069         }
0070     }
0071     void shrinktofit() { if(_size > 4) { _realloc(_size); } }
0072     T& top() const { return _vals[_size - 1]; }
0073     inline PSUnsignedInteger size() const { return _size; }
0074     bool empty() const { return (_size <= 0); }
0075     inline T &push_back(const T& val = T())
0076     {
0077         if(_allocated <= _size)
0078             _realloc(_size * 2);
0079         return *(new ((void *)&_vals[_size++]) T(val));
0080     }
0081     inline void pop_back()
0082     {
0083         _size--; _vals[_size].~T();
0084     }
0085     void insert(PSUnsignedInteger idx, const T& val)
0086     {
0087         resize(_size + 1);
0088         for(PSUnsignedInteger i = _size - 1; i > idx; i--) {
0089             _vals[i] = _vals[i - 1];
0090         }
0091         _vals[idx] = val;
0092     }
0093     void remove(PSUnsignedInteger idx)
0094     {
0095         _vals[idx].~T();
0096         if(idx < (_size - 1)) {
0097             memmove(&_vals[idx], &_vals[idx+1], sizeof(T) * (_size - idx - 1));
0098         }
0099         _size--;
0100     }
0101     PSUnsignedInteger capacity() { return _allocated; }
0102     inline T &back() const { return _vals[_size - 1]; }
0103     inline T& operator[](PSUnsignedInteger pos) const{ return _vals[pos]; }
0104     T* _vals;
0105 private:
0106     void _realloc(PSUnsignedInteger newsize)
0107     {
0108         newsize = (newsize > 0)?newsize:4;
0109         _vals = (T*)PS_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T));
0110         _allocated = newsize;
0111     }
0112     PSUnsignedInteger _size;
0113     PSUnsignedInteger _allocated;
0114 };
0115
0116 #endif //_PSUTILS_H_