From 731982d47e169437907694d672e9ec89feb43a5e Mon Sep 17 00:00:00 2001 From: adash Date: Wed, 3 Jun 2009 01:24:48 +0000 Subject: [PATCH] add common Library files --- .../Benchmarks/SingleTM/common/BitMap.java | 338 +++++++++++++ .../src/Benchmarks/SingleTM/common/Queue.java | 468 ++++++++++++++++++ .../Benchmarks/SingleTM/common/QuickSort.java | 39 ++ .../Benchmarks/SingleTM/common/Vector_t.java | 154 ++++++ 4 files changed, 999 insertions(+) create mode 100644 Robust/src/Benchmarks/SingleTM/common/BitMap.java create mode 100644 Robust/src/Benchmarks/SingleTM/common/Queue.java create mode 100644 Robust/src/Benchmarks/SingleTM/common/QuickSort.java create mode 100644 Robust/src/Benchmarks/SingleTM/common/Vector_t.java diff --git a/Robust/src/Benchmarks/SingleTM/common/BitMap.java b/Robust/src/Benchmarks/SingleTM/common/BitMap.java new file mode 100644 index 00000000..8f191033 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/common/BitMap.java @@ -0,0 +1,338 @@ +/* ============================================================================= + * + * bitmap.java + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * Ported to Java: + * Author:Alokika dash + * University of California, Irvine + * + * ============================================================================= + * + * For the license of bayes/sort.h and bayes/sort.c, please see the header + * of the files. + * + * ------------------------------------------------------------------------ + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + +#define NUM_BIT_PER_BYTE (8) +#define NUM_BIT_PER_WORD (4 * NUM_BIT_PER_BYTE) + +public class BitMap { + int numBit; + int numWord; + int[] bits; + + public BitMap() { + + } + + public int DIVIDE_AND_ROUND_UP(int a, int b) { + int res1 = a / b; + int res2 = a % b; + int val = (res2 > 0) ? (1) : (0); + return (res1 + val); + } + + + /* ============================================================================= + * bitmap_alloc + * -- Returns null on failure + * ============================================================================= + */ + public static BitMap bitmap_alloc(int numBit) + { + BitMap bitmapPtr = new BitMap(); + if (bitmapPtr == null) { + return null; + } + + bitmapPtr.numBit = numBit; + int numWord = bitmapPtr.DIVIDE_AND_ROUND_UP(numBit, NUM_BIT_PER_WORD); + bitmapPtr.numWord = numWord; + + bitmapPtr.bits = new int[numWord]; + if (bitmapPtr.bits == null) { + return null; + } + for(int i = 0; i < numWord; i++) + bitmapPtr.bits[i] = 0; + + return bitmapPtr; + } + + /* ============================================================================= + * bitmap_free + * ============================================================================= + */ + public void + bitmap_free (BitMap bitmapPtr) + { + bitmapPtr.bits = null; + bitmapPtr = null; + //free(bitmapPtr.bits); + //free(bitmapPtr); + } + + + /* ============================================================================= + * bitmap_set + * -- Sets ith bit to 1 + * -- Returns TRUE on success, else FALSE + * ============================================================================= + */ + /* + bool_t + bitmap_set (bitmap_t* bitmapPtr, int i) + { + if ((i < 0) || (i >= bitmapPtr.numBit)) { + return FALSE; + } + + bitmapPtr.bits[i/NUM_BIT_PER_WORD] |= (1UL << (i % NUM_BIT_PER_WORD)); + + return TRUE; + } + */ + + + /* ============================================================================= + * bitmap_clear + * -- Clears ith bit to 0 + * -- Returns TRUE on success, else FALSE + * ============================================================================= + */ + /* + bool_t + bitmap_clear (bitmap_t* bitmapPtr, int i) + { + if ((i < 0) || (i >= bitmapPtr.numBit)) { + return FALSE; + } + + bitmapPtr.bits[i/NUM_BIT_PER_WORD] &= ~(1UL << (i % NUM_BIT_PER_WORD)); + + return TRUE; + } + */ + + + /* ============================================================================= + * bitmap_clearAll + * -- Clears all bit to 0 + * ============================================================================= + */ + /* + void + bitmap_clearAll (bitmap_t* bitmapPtr) + { + memset(bitmapPtr.bits, 0, (bitmapPtr.numWord * sizeof(uint_t))); + } + */ + + + /* ============================================================================= + * bitmap_isClear + * -- Returns TRUE if ith bit is clear, else FALSE + * ============================================================================= + */ + /* + bool_t + bitmap_isClear (bitmap_t* bitmapPtr, int i) + { + if ((i >= 0) && (i < bitmapPtr.numBit) && + !(bitmapPtr.bits[i/NUM_BIT_PER_WORD] & (1UL << (i % NUM_BIT_PER_WORD)))) { + return TRUE; + } + + return FALSE; + } + */ + + + /* ============================================================================= + * bitmap_isSet + * -- Returns TRUE if ith bit is set, else FALSE + * ============================================================================= + */ + /* + bool_t + bitmap_isSet (bitmap_t* bitmapPtr, int i) + { + if ((i >= 0) && (i < bitmapPtr.numBit) && + (bitmapPtr.bits[i/NUM_BIT_PER_WORD] & (1UL << (i % NUM_BIT_PER_WORD)))) { + return TRUE; + } + + return FALSE; + } + */ + + + /* ============================================================================= + * bitmap_findClear + * -- Returns index of first clear bit + * -- If start index is negative, will start from beginning + * -- If all bits are set, returns -1 + * ============================================================================= + */ + /* + int + bitmap_findClear (bitmap_t* bitmapPtr, int startIndex) + { + int i; + int numBit = bitmapPtr.numBit; + uint_t* bits = bitmapPtr.bits; + + for (i = MAX(startIndex, 0); i < numBit; i++) { + if (!(bits[i/NUM_BIT_PER_WORD] & (1UL << (i % NUM_BIT_PER_WORD)))) { + return i; + } + } + + return -1; + } + */ + + + /* ============================================================================= + * bitmap_findSet + * -- Returns index of first set bit + * -- If start index is negative, will start from beginning + * -- If all bits are clear, returns -1 + * ============================================================================= + */ + /* + int + bitmap_findSet (bitmap_t* bitmapPtr, int startIndex) + { + int i; + int numBit = bitmapPtr.numBit; + uint_t* bits = bitmapPtr.bits; + + for (i = MAX(startIndex, 0); i < numBit; i++) { + if (bits[i/NUM_BIT_PER_WORD] & (1UL << (i % NUM_BIT_PER_WORD))) { + return i; + } + } + + return -1; + } + */ + + /* ============================================================================= + * bitmap_getNumClear + * ============================================================================= + */ + /* + int + bitmap_getNumClear (bitmap_t* bitmapPtr) + { + int numBit = bitmapPtr.numBit; + + return (numBit - bitmap_getNumSet(bitmapPtr)); + } + */ + + + /* ============================================================================= + * bitmap_getNumSet + * ============================================================================= + */ + /* + int + bitmap_getNumSet (bitmap_t* bitmapPtr) + { + int i; + int numBit = bitmapPtr.numBit; + uint_t* bits = bitmapPtr.bits; + int count = 0; + + for (i = 0; i < numBit; i++) { + if (bits[i/NUM_BIT_PER_WORD] & (1UL << (i % NUM_BIT_PER_WORD))) { + count++; + } + } + + return count; + } + */ + + + /* ============================================================================= + * bitmap_copy + * ============================================================================= + */ + /* + void + bitmap_copy (bitmap_t* dstPtr, bitmap_t* srcPtr) + { + assert(dstPtr.numBit == srcPtr.numBit); + memcpy(dstPtr.bits, srcPtr.bits, (dstPtr.numWord * sizeof(uint_t))); + } + */ + + + /* ============================================================================= + * bitmap_toggleAll + * ============================================================================= + */ + /* + void + bitmap_toggleAll (bitmap_t* bitmapPtr) + { + uint_t* bits = bitmapPtr.bits; + int numWord = bitmapPtr.numWord; + int w; + for (w = 0; w < numWord; w++) { + bits[w] ^= (uint_t)(-1L); + } + } + */ +} + +/* ============================================================================= + * + * End of bitmap.java + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/common/Queue.java b/Robust/src/Benchmarks/SingleTM/common/Queue.java new file mode 100644 index 00000000..ef74143c --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/common/Queue.java @@ -0,0 +1,468 @@ +/* ============================================================================= + * + * queue.java + * + * ============================================================================= + * + * Copyright (C) Stanford University, 2006. All Rights Reserved. + * Author: Chi Cao Minh + * + * Ported to Java + * Author:Alokika Dash + * University of California, Irvine + * + * ============================================================================= + * + * Unless otherwise noted, the following license applies to STAMP files: + * + * Copyright (c) 2007, Stanford University + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Stanford University nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * ============================================================================= + */ + +#define QUEUE_GROWTH_FACTOR 2 + +public class Queue { + int pop; /* points before element to pop */ + int push; + int capacity; + Object[] elements; + + public Queue() { + } + + /* ============================================================================= + * queue_alloc + * ============================================================================= + */ + public static Queue queue_alloc (int initCapacity) + { + Queue queuePtr = new Queue(); + + int capacity = ((initCapacity < 2) ? 2 : initCapacity); + queuePtr.elements = new Object[capacity]; + if (queuePtr.elements == null) { + queuePtr = null; + return null; + } + queuePtr.pop = capacity - 1; + queuePtr.push = 0; + queuePtr.capacity = capacity; + + return queuePtr; + } + + + /* ============================================================================= + * Pqueue_alloc + * ============================================================================= + */ + public Queue + Pqueue_alloc (int initCapacity) + { + Queue queuePtr = new Queue(); + + int capacity = ((initCapacity < 2) ? 2 : initCapacity); + queuePtr.elements = new Object[capacity]; + if (queuePtr.elements == null) { + queuePtr = null; + return null; + } + queuePtr.pop = capacity - 1; + queuePtr.push = 0; + queuePtr.capacity = capacity; + + return queuePtr; + } + + + /* ============================================================================= + * TMqueue_alloc + * ============================================================================= + */ + public Queue TMqueue_alloc (int initCapacity) + { + Queue queuePtr = new Queue(); + + int capacity = ((initCapacity < 2) ? 2 : initCapacity); + queuePtr.elements = new Object[capacity]; + if (queuePtr.elements == null) { + queuePtr = null; + return null; + } + queuePtr.pop = capacity - 1; + queuePtr.push = 0; + queuePtr.capacity = capacity; + + return queuePtr; + } + + + /* ============================================================================= + * queue_free + * ============================================================================= + */ + public void + queue_free (Queue queuePtr) + { + queuePtr.elements = null; + queuePtr = null; + } + + + /* ============================================================================= + * Pqueue_free + * ============================================================================= + */ + public void + Pqueue_free (Queue queuePtr) + { + queuePtr.elements = null; + queuePtr = null; + } + + + /* ============================================================================= + * TMqueue_free + * ============================================================================= + */ + public void + TMqueue_free (TM_ARGDECL Queue* queuePtr) + { + queuePtr.elements = null; + queuePtr = null; + } + + + /* ============================================================================= + * queue_isEmpty + * ============================================================================= + */ + public boolean + queue_isEmpty (Queue queuePtr) + { + int pop = queuePtr.pop; + int push = queuePtr.push; + int capacity = queuePtr.capacity; + + return (((pop + 1) % capacity == push) ? true : false); + } + + + /* ============================================================================= + * queue_clear + * ============================================================================= + */ + public void + queue_clear (Queue* queuePtr) + { + queuePtr.pop = queuePtr.capacity - 1; + queuePtr.push = 0; + } + + + /* ============================================================================= + * TMqueue_isEmpty + * ============================================================================= + */ + public boolean + TMqueue_isEmpty (Queue queuePtr) + { + int pop = queuePtr.pop; + int push = queuePtr.push; + int capacity = queuePtr.capacity; + + return (((pop + 1) % capacity == push) ? true : false); + } + + + /* ============================================================================= + * queue_shuffle + * ============================================================================= + */ + public void + queue_shuffle (Queue queuePtr, Random randomPtr) + { + int pop = queuePtr.pop; + int push = queuePtr.push; + int capacity = queuePtr.capacity; + + int numElement; + if (pop < push) { + numElement = push - (pop + 1); + } else { + numElement = capacity - (pop - push + 1); + } + + Object[] elements = queuePtr.elements; + int i; + int base = pop + 1; + for (i = 0; i < numElement; i++) { + int r1 = randomPtr.random_generate() % numElement; + int r2 = randomPtr.random_generate() % numElement; + int i1 = (base + r1) % capacity; + int i2 = (base + r2) % capacity; + Object tmp = elements[i1]; + elements[i1] = elements[i2]; + elements[i2] = tmp; + } + } + + + /* ============================================================================= + * queue_push + * ============================================================================= + */ + public boolean + queue_push (Queue queuePtr, Object dataPtr) + { + int pop = queuePtr.pop; + int push = queuePtr.push; + int capacity = queuePtr.capacity; + + if(pop == push) { + System.out.println("push == pop in Queue.java"); + return false; + } + + /* Need to resize */ + int newPush = (push + 1) % capacity; + if (newPush == pop) { + + int newCapacity = capacity * QUEUE_GROWTH_FACTOR; + Object[] newElements = new Object[newCapacity]; + if (newElements == null) { + return false; + } + + int dst = 0; + Object[] elements = queuePtr.elements; + if (pop < push) { + int src; + for (src = (pop + 1); src < push; src++, dst++) { + newElements[dst] = elements[src]; + } + } else { + int src; + for (src = (pop + 1); src < capacity; src++, dst++) { + newElements[dst] = elements[src]; + } + for (src = 0; src < push; src++, dst++) { + newElements[dst] = elements[src]; + } + } + + elements = null; + queuePtr.elements = newElements; + queuePtr.pop = newCapacity - 1; + queuePtr.capacity = newCapacity; + push = dst; + newPush = push + 1; /* no need modulo */ + } + + queuePtr.elements[push] = dataPtr; + queuePtr.push = newPush; + + return true; + } + + + /* ============================================================================= + * Pqueue_push + * ============================================================================= + */ + public boolean + Pqueue_push (Queue queuePtr, Object dataPtr) + { + int pop = queuePtr.pop; + int push = queuePtr.push; + int capacity = queuePtr.capacity; + + if(pop == push) { + System.out.println("push == pop in Queue.java"); + return false; + } + + /* Need to resize */ + int newPush = (push + 1) % capacity; + if (newPush == pop) { + + int newCapacity = capacity * QUEUE_GROWTH_FACTOR; + Object[] newElements = new Object[newCapacity]; + if (newElements == null) { + return false; + } + + int dst = 0; + Object[] elements = queuePtr.elements; + if (pop < push) { + int src; + for (src = (pop + 1); src < push; src++, dst++) { + newElements[dst] = elements[src]; + } + } else { + int src; + for (src = (pop + 1); src < capacity; src++, dst++) { + newElements[dst] = elements[src]; + } + for (src = 0; src < push; src++, dst++) { + newElements[dst] = elements[src]; + } + } + + elements = null; + queuePtr.elements = newElements; + queuePtr.pop = newCapacity - 1; + queuePtr.capacity = newCapacity; + push = dst; + newPush = push + 1; /* no need modulo */ + + } + + queuePtr.elements[push] = dataPtr; + queuePtr.push = newPush; + + return true; + } + + + /* ============================================================================= + * TMqueue_push + * ============================================================================= + */ + public boolean + TMqueue_push (Queue queuePtr, Object dataPtr) + { + int pop = (queuePtr.pop); + int push = (queuePtr.push); + int capacity = (queuePtr.capacity); + + if(pop == push) { + System.out.println("push == pop in Queue.java"); + return false; + } + + /* Need to resize */ + int newPush = (push + 1) % capacity; + if (newPush == pop) { + int newCapacity = capacity * QUEUE_GROWTH_FACTOR; + Object[] newElements = new Object[newCapacity]; + if (newElements == null) { + return false; + } + + int dst = 0; + Object[] elements = queuePtr.elements; + if (pop < push) { + int src; + for (src = (pop + 1); src < push; src++, dst++) { + newElements[dst] = (elements[src]); + } + } else { + int src; + for (src = (pop + 1); src < capacity; src++, dst++) { + newElements[dst] = (elements[src]); + } + for (src = 0; src < push; src++, dst++) { + newElements[dst] = (elements[src]); + } + } + + elements = null; + queuePtr.elements = newElements; + queuePtr.pop = newCapacity - 1; + queuePtr.capacity = newCapacity; + push = dst; + newPush = push + 1; /* no need modulo */ + + } + + Object[] elements = queuePtr.elements; + elements[push] = dataPtr; + queuePtr.push = newPush; + + return true; + } + + + /* ============================================================================= + * queue_pop + * ============================================================================= + */ + public Object + queue_pop (Queue queuePtr) + { + int pop = queuePtr.pop; + int push = queuePtr.push; + int capacity = queuePtr.capacity; + + int newPop = (pop + 1) % capacity; + if (newPop == push) { + return null; + } + + Object dataPtr = queuePtr.elements[newPop]; + queuePtr.pop = newPop; + + return dataPtr; + } + + + /* ============================================================================= + * TMqueue_pop + * ============================================================================= + */ + public Object + TMqueue_pop (Queue queuePtr) + { + int pop = queuePtr.pop; + int push = queuePtr.push; + int capacity = queuePtr.capacity; + + int newPop = (pop + 1) % capacity; + if (newPop == push) { + return null; + } + + Object[] elements = queuePtr.elements; + Object dataPtr = elements[newPop]; + queuePtr.pop = newPop; + + return dataPtr; + } +} +/* ============================================================================= + * + * End of queue.java + * + * ============================================================================= + */ diff --git a/Robust/src/Benchmarks/SingleTM/common/QuickSort.java b/Robust/src/Benchmarks/SingleTM/common/QuickSort.java new file mode 100644 index 00000000..1e5e10dc --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/common/QuickSort.java @@ -0,0 +1,39 @@ +public class QuickSort { + + public QuickSort() { + + } + + public static void swap (int A[], int x, int y) + { + int temp = A[x]; + A[x] = A[y]; + A[y] = temp; + } + + // Reorganizes the given list so all elements less than the first are + // before it and all greater elements are after it. + public static int partition(int A[], int left, int right) + { + int i = left - 1; + int j = right; + while (true) { + while (less(a[++i], a[right])) // find item on left to swap + ; // a[right] acts as sentinel + while (less(a[right], a[--j])) // find item on right to swap + if (j == left) break; // don't go out-of-bounds + if (i >= j) break; // check if pointers cross + swap(a, i, j); // swap two elements into place + } + swap(a, i, right); // swap with partition element + return i; + } + + public static void Quicksort(int A[], int f, int l) + { + if (f >= l) return; + int pivot_index = partition(A, f, l); + Quicksort(A, f, pivot_index); + Quicksort(A, pivot_index+1, l); + } +} diff --git a/Robust/src/Benchmarks/SingleTM/common/Vector_t.java b/Robust/src/Benchmarks/SingleTM/common/Vector_t.java new file mode 100644 index 00000000..87c95ad9 --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/common/Vector_t.java @@ -0,0 +1,154 @@ +public class Vector_t { + int size; + int capacity; + Object[] elements; + + public Vector_t() { + + } + + /* ============================================================================= + * Vector_alloc + * -- Returns null if failed + * ============================================================================= + */ + public static Vector_t vector_alloc (int initCapacity) { + int capacity = Math.max(initCapacity, 1); + Vector_t vectorPtr = new Vector(); + if(vectorPtr != null) { + vectorPtr.size = 0; + vectorPtr.capacity = capacity; + vectorPtr.elements = new Object[capacity]; + if(vectorPtr.elements == null) + return null; + } + return vectorPtr; + } + + /* ============================================================================= + * Vector_free + * ============================================================================= + */ + public void + vector_free () + { + elements = null; + } + + /* ============================================================================= + * Vector_at + * -- Returns null if failed + * ============================================================================= + */ + public static Object vector_at (Vector_t vectorPtr, int i) { + if ((i < 0) || (i >= vectorPtr.size)) { + System.out.println("Illegal Vector.element\n"); + return null; + } + return (vectorPtr.elements[i]); + } + + + /* ============================================================================= + * Vector_pushBack + * -- Returns false if fail, else true + * ============================================================================= + */ + public boolean vector_pushBack (Object dataPtr) { + if (size == capacity) { + int newCapacity = capacity * 2; + Object[] newElements = new Object[newCapacity]; + + //void** newElements = (void**)malloc(newCapacity * sizeof(void*)); + if (newElements == null) { + return false; + } + capacity = newCapacity; + for (int i = 0; i < size; i++) { + newElements[i] = elements[i]; + } + elements = null; + elements = newElements; + } + + elements[size++] = dataPtr; + + return true; + } + + /* ============================================================================= + * Vector_popBack + * -- Returns null if fail, else returns last element + * ============================================================================= + */ + public Object + vector_popBack () + { + if (size < 1) { + return null; + } + + return (elements[--(size)]); + } + + /* ============================================================================= + * Vector_getSize + * ============================================================================= + */ + public int + vector_getSize () + { + return (size); + } + + /* ============================================================================= + * Vector_clear + * ============================================================================= + */ + public void + vector_clear () + { + size = 0; + } + + /* ============================================================================= + * Vector_sort + * ============================================================================= + */ + public void + vector_sort () + { + QuickSort.Quicksort(elements, 0, elements.length - 1); + //qsort(elements, size, 4, compare); + } + + /* ============================================================================= + * Vector_copy + * ============================================================================= + */ + public static boolean + vector_copy (Vector_t dstVectorPtr, Vector_t srcVectorPtr) + { + int dstCapacity = dstVectorPtr.capacity; + int srcSize = srcVectorPtr.size; + if (dstCapacity < srcSize) { + int srcCapacity = srcVectorPtr.capacity; + Object[] elements = new Object[srcCapacity]; + + if (elements == null) { + return false; + } + dstVectorPtr.elements = null; + dstVectorPtr.elements = elements; + dstVectorPtr.capacity = srcCapacity; + } + + for(int i = 0; i< srcSize; i++) { + dstVectorPtr.elements[i] = srcVectorPtr.elements[i]; + } + + dstVectorPtr.size = srcSize; + + return true; + } +} -- 2.34.1