Robust/src/Benchmarks/SingleTM/Labyrinth3D/Vector_t.java

   1 public class Vector_t {
   2   int size;
   3   int capacity;
   4   Object[] elements;
   5 //  QuickSort qsort;
   6
   7   public Vector_t() {
   8 //    qsort = new QuickSort();
   9   }
  10
  11   /* =============================================================================
  12    * Vector_alloc
  13    * -- Returns null if failed
  14    * =============================================================================
  15    */
  16   public static Vector_t vector_alloc (int initCapacity) {
  17     int capacity = Math.imax(initCapacity, 1);
  18     Vector_t vectorPtr = new Vector_t();
  19     if(vectorPtr != null) {
  20       vectorPtr.size = 0;
  21       vectorPtr.capacity = capacity;
  22       vectorPtr.elements = new Object[capacity];
  23       if(vectorPtr.elements == null)
  24         return null;
  25     }
  26     return vectorPtr;
  27   }
  28
  29   /* =============================================================================
  30    * Vector_free
  31    * =============================================================================
  32    */
  33   public void
  34     vector_free ()
  35     {
  36       elements = null;
  37     }
  38
  39   /* =============================================================================
  40    * Vector_at
  41    * -- Returns null if failed
  42    * =============================================================================
  43    */
  44   public Object vector_at (int i) {
  45     if ((i < 0) || (i >= size)) {
  46       System.out.println("Illegal Vector.element\n");
  47       return null;
  48     }
  49     return (elements[i]);
  50   }
  51
  52
  53   /* =============================================================================
  54    * Vector_pushBack
  55    * -- Returns false if fail, else true
  56    * =============================================================================
  57    */
  58   public boolean vector_pushBack (Object dataPtr) {
  59     if (size == capacity) {
  60       int newCapacity = capacity * 2;
  61       Object[] newElements = new Object[newCapacity];
  62
  63       //void** newElements = (void**)malloc(newCapacity * sizeof(void*));
  64       if (newElements == null) {
  65         return false;
  66       }
  67       capacity = newCapacity;
  68       for (int i = 0; i < size; i++) {
  69         newElements[i] = elements[i];
  70       }
  71       elements = null;
  72       elements = newElements;
  73     }
  74
  75     elements[size++] = dataPtr;
  76
  77     return true;
  78   }
  79
  80   /* =============================================================================
  81    * Vector_popBack
  82    * -- Returns null if fail, else returns last element
  83    * =============================================================================
  84    */
  85   public Object
  86     vector_popBack ()
  87     {
  88       if (size < 1) {
  89         return null;
  90       }
  91
  92       return (elements[--(size)]);
  93     }
  94
  95   /* =============================================================================
  96    * Vector_getSize
  97    * =============================================================================
  98    */
  99   public int
 100     vector_getSize ()
 101     {
 102       return (size);
 103     }
 104
 105   /* =============================================================================
 106    * Vector_clear
 107    * =============================================================================
 108    */
 109   public void
 110     vector_clear ()
 111     {
 112       size = 0;
 113     }
 114
 115   /* =============================================================================
 116    * Vector_sort
 117    * =============================================================================
 118    *
 119   public void
 120     vector_sort ()
 121     {
 122       //qsort.sort(elements, 0, (elements.length - 1));
 123       qsort.sort(elements);
 124       //qsort(elements, size, 4, compare);
 125     }
 126
 127   * =============================================================================
 128    * Vector_copy
 129    * =============================================================================
 130    */
 131   public static boolean
 132     vector_copy (Vector_t dstVectorPtr, Vector_t srcVectorPtr)
 133     {
 134       int dstCapacity = dstVectorPtr.capacity;
 135       int srcSize = srcVectorPtr.size;
 136       if (dstCapacity < srcSize) {
 137         int srcCapacity = srcVectorPtr.capacity;
 138         Object[] elements = new Object[srcCapacity];
 139
 140         if (elements == null) {
 141           return false;
 142         }
 143         dstVectorPtr.elements = null;
 144         dstVectorPtr.elements = elements;
 145         dstVectorPtr.capacity = srcCapacity;
 146       }
 147
 148       for(int i = 0; i< srcSize; i++) {
 149         dstVectorPtr.elements[i] = srcVectorPtr.elements[i];
 150       }
 151
 152       dstVectorPtr.size = srcSize;
 153
 154       return true;
 155     }
 156 }