Branch data     Line data    Source code

       1                 :            : #ifndef SIMPLEARRAY_H
       2                 :            : #define SIMPLEARRAY_H
       3                 :            : 
       4                 :            : #include <algorithm>
       5                 :            : #include <cstdlib>
       6                 :            : 
       7                 :            : template <typename T> 
       8                 :            : class SimpleArray
       9                 :            : {
      10                 :            : private:
      11                 :            :   // TODO: make SimpleArrays copyable
      12                 :            :   SimpleArray(const SimpleArray &);
      13                 :            :   SimpleArray & operator = (const SimpleArray &);
      14                 :            : 
      15                 :            :   T *arr;
      16                 :            :   int arrSize;
      17                 :            :   int arrAllocated;
      18                 :            : public:
      19                 :         19 :   SimpleArray() : arr(NULL), arrSize(0), arrAllocated(0) {}
      20                 :            : 
      21                 :          4 :   SimpleArray( unsigned s ) : arr(NULL), arrSize(s), arrAllocated(s) 
      22                 :            :   {
      23                 :          4 :     resize(s);
      24                 :          4 :   }
      25                 :            :     
      26                 :         23 :   ~SimpleArray()
      27                 :            :   {
      28                 :         23 :     clear();
      29                 :         23 :   }
      30                 :            : 
      31                 :        172 :   int size()     const { return arrSize; }
      32                 :            :   int capacity() const { return arrAllocated; }
      33                 :            : 
      34                 :          5 :   void resize( unsigned s )
      35                 :            :   {
      36                 :          5 :     clear();
      37         [ +  + ]:          5 :     if (s == 0) return;
      38                 :          3 :     arr = (T*)malloc(s*sizeof(T));
      39         [ +  + ]:          7 :     for (unsigned i = 0; i < s; ++i)
      40         [ +  - ]:          4 :       new (arr+i) T();
      41                 :          3 :     arrSize = arrAllocated = s;
      42                 :            :   }
      43                 :            : 
      44                 :         28 :   void clear() 
      45                 :            :   {
      46 [ -  + ][ +  + ]:         28 :     if (arr == NULL) return;
      47 [ +  + ][ +  + ]:        206 :     for (int i = 0; i < arrSize; ++i)
      48                 :        186 :       arr[i].~T();
      49                 :         20 :     free(arr); 
      50                 :         20 :     arr = NULL;
      51                 :         20 :     arrSize = arrAllocated = 0;
      52                 :            :   }
      53                 :            : 
      54                 :            :   void swap(SimpleArray &other)
      55                 :            :   {
      56                 :            :     using std::swap;
      57                 :            :     swap(arr, other.arr);
      58                 :            :     swap(arrSize, other.arrSize);
      59                 :            :     swap(arrAllocated, other.arrAllocated);
      60                 :            :   }
      61                 :            : 
      62                 :            :   typedef T* iterator;
      63                 :            :   typedef const T* const_iterator;
      64                 :            :   iterator       begin()       { return arr; }
      65                 :            :   const_iterator begin() const { return arr; }
      66                 :            :   iterator         end()       { return arr + arrSize; }
      67                 :            :   const_iterator   end() const { return arr + arrSize; }
      68                 :            : 
      69                 :        328 :   T&       operator[]( unsigned idx )       { return arr[idx]; }
      70                 :            :   const T& operator[]( unsigned idx ) const { return arr[idx]; }
      71                 :            : 
      72                 :            :   // Don't use these directly!
      73                 :         34 :   T**  ptr_()      { return &arr; }
      74                 :         34 :   int* size_()     { return &arrSize; }
      75                 :         34 :   int* capacity_() { return &arrAllocated; }
      76                 :            : };
      77                 :            : 
      78                 :            : #define ARRAY_INOUT( A ) (A).ptr_(), (A).capacity_(), (A).size_()
      79                 :            : #define ARRAY_IN( A ) &(A)[0], (A).size()
      80                 :            : 
      81                 :            : namespace std
      82                 :            : {
      83                 :            :   // Alas, this is non-standard, but it works everywhere, and there's no other
      84                 :            :   // way to do it.
      85                 :            :   template<typename T>
      86                 :            :   void swap(SimpleArray<T> &lhs, SimpleArray<T> &rhs)
      87                 :            :   {
      88                 :            :     lhs.swap(rhs);
      89                 :            :   }
      90                 :            : }
      91                 :            : 
      92                 :            : #endif