Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. #ifndef _VECTOR_INCLUDED
  2. #define _VECTOR_INCLUDED
  3. #include <stdlib.h>
  4. #include <string.h>
  5. extern void *__cdecl operator new(size_t);
  6. inline void *__cdecl operator new(size_t, void *_P)
  7. { return (_P); }
  8. namespace std
  9. {
  10.   template<class T> class vector
  11.   {
  12.     unsigned length;
  13.     unsigned allocated;
  14.     T* data;
  15.   public:
  16.     typedef unsigned size_type;
  17.     typedef T* iterator;
  18.     vector():length(0),allocated(0),data(NULL) {}
  19.     ~vector() {for (unsigned i=length;i--;)data[i].~T();free(data);}
  20.     unsigned size() const {return length;}
  21.     void clear() {length=0;}
  22.     T& operator[](unsigned pos) {return data[pos];}
  23.     T* begin() {return data;}
  24.     T* end() {return data+length;}
  25.     void push_back(const T& x)
  26.     {
  27.       if (length==allocated)
  28.       {
  29.         allocated+=16;
  30.         data=(T*)realloc(data,allocated*sizeof(T));
  31.       }
  32.       new (data+length++) T(x);
  33.     }
  34.     bool empty() const {return length==0;}
  35.     void pop_back() {data[--length].~T();}
  36.     T& back() {return data[length-1];}
  37.     iterator erase(iterator it)
  38.     {
  39.       T* a=it;
  40.       while (++a != data+length)
  41.       {
  42.         a[-1] = *a;
  43.       }
  44.       length--;
  45.       return it;
  46.     }
  47.     /*iterator*/T* insert(iterator where, const T& what = T())
  48.     {
  49.       int z=where-data;
  50.       if (length==allocated)
  51.       {
  52.         allocated+=16;
  53.         data=(T*)realloc(data,allocated*sizeof(T));
  54.       }
  55.       T* a=data+length;
  56.       T* b=data+z;
  57.       length++;
  58.       while (a != b)
  59.       {
  60.         *a = a[-1];
  61.         --a;
  62.       }
  63.       *a = what;
  64.       return /*iterator*/a;
  65.     }
  66.   };
  67.   struct _generic_vector
  68.   {
  69.     unsigned length;
  70.     unsigned allocated;
  71.     void** data;
  72.   };
  73.   inline void _generic_pointer_push_back(_generic_vector* v, void* a)
  74.   {
  75.     if (v->length==v->allocated)
  76.     {
  77.       v->allocated+=16;
  78.       v->data=(void**)realloc(v->data,v->allocated*sizeof(void*));
  79.     }
  80.     v->data[v->length++]=a;
  81.   }
  82.   inline void _generic_pointer_erase(_generic_vector* v, void** a)
  83.   {
  84.     while (++a != v->data+v->length)
  85.     {
  86.       a[-1] = *a;
  87.     }
  88.     v->length--;
  89.   }
  90.   inline void** _generic_pointer_insert(_generic_vector* v, void** where, void* what)
  91.   {
  92.     int z=where-v->data;
  93.     if (v->length==v->allocated)
  94.     {
  95.       v->allocated+=16;
  96.       v->data=(void**)realloc(v->data,v->allocated*sizeof(void*));
  97.     }
  98.     void** a=v->data+v->length;
  99.     void** b=v->data+z;
  100.     v->length++;
  101.     while (a != b)
  102.     {
  103.       *a = a[-1];
  104.       --a;
  105.     }
  106.     *a = what;
  107.     return a;
  108.   }
  109.   template<class T> class vector<T*>
  110.   {
  111.     unsigned length;
  112.     unsigned allocated;
  113.     T** data;
  114.   public:
  115.     typedef unsigned size_type;
  116.     typedef T** iterator;
  117.     vector():length(0),allocated(0),data(NULL) {}
  118.     ~vector() {free(data);}
  119.     unsigned size() const {return length;}
  120.     void clear() {length=0;}
  121.     T*& operator[](unsigned pos) {return data[pos];}
  122.     iterator begin() {return iterator(data);}
  123.     iterator end() {return iterator(data+length);}
  124.     void push_back(T* const& x)
  125.     { _generic_pointer_push_back((_generic_vector*)this, (void*)x); }
  126.     bool empty() const {return length==0;}
  127.     void pop_back() {--length;}
  128.     T*& back() {return data[length-1];}
  129.     iterator erase(iterator it)
  130.     { _generic_pointer_erase((_generic_vector*)this, (void**)it); return it; }
  131.     iterator insert(iterator where, T* const& what)
  132.     { return (T**)_generic_pointer_insert((_generic_vector*)this, (void**)where, what); }
  133.   };
  134. }
  135. #endif
  136.