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