Index: trunk/psLib/src/collections/psArray.c
===================================================================
--- trunk/psLib/src/collections/psArray.c	(revision 502)
+++ trunk/psLib/src/collections/psArray.c	(revision 578)
@@ -8,6 +8,6 @@
  *  @author Ross Harman, MHPCC
  *   
- *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-04-22 21:15:01 $
+ *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-05-05 20:43:22 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -48,10 +48,12 @@
 /*****************************************************************************/
 
-static void* p_psArrayAlloc(psType *arrType, psElemType elemType, int nalloc, int elemSize)
+static void* p_psArrayAlloc(psArray *restrict psArr, psElemType elemType, int nalloc, int elemSize)
 {
     void *arr = NULL;
 
-    arrType->dimen = PS_DIMEN_VECTOR;
-    arrType->type = elemType;
+    psArr->type.dimen = PS_DIMEN_VECTOR;
+    psArr->type.type = elemType;
+    psArr->nalloc = nalloc;
+    psArr->n = 0;
 
     if(nalloc != 0) {
@@ -62,209 +64,158 @@
 }
 
-static psVoidPtrArray *p_psVoidPtrArrayRealloc(psVoidPtrArray *restrict psArr, int nalloc)
-{
-    if(nalloc < psArr->n) {                                         // For decrease in psArray size
+static void* p_psArrayRealloc(psArray *restrict psArr, void *arr, int nalloc, int elemSize)
+{
+    // For decrease in psArray size
+    if(nalloc < psArr->n) {
         psArr->n = nalloc;
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));   // For increase in psArray size
-    } else if(nalloc > psArr->nalloc) {
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));
-    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
+    }
+
+    psArr->nalloc = nalloc;
+
+    return psRealloc(arr, nalloc*elemSize);
+}
+
+/*****************************************************************************/
+/* FUNCTION IMPLEMENTATION - PUBLIC                                          */
+/*****************************************************************************/
+psArray* psIntArrayAlloc(int nalloc)
+{
+    psArray *psArr = NULL;
+    psArr = psAlloc(sizeof(psArray));
+    psArr->arr.intArr = (int*)p_psArrayAlloc(psArr, PS_TYPE_INT, nalloc, sizeof(int));
+    return psArr;
+}
+
+psArray *psIntArrayRealloc(psArray *restrict psArr, int nalloc)
+{
+    if(psArr == NULL) {                                 // For creating new psArray with realloc
+        psArr = psIntArrayAlloc(nalloc);
+    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
+        psArr->arr.intArr = p_psArrayRealloc(psArr, psArr->arr.intArr, nalloc, sizeof(int));
+    }
+
+    return psArr;
+}
+
+void psIntArrayFree(psArray *restrict psArr)
+{
+    if (psArr == NULL) {
+        return;
+    }
+
+    psFree(psArr->arr.intArr);
+    psFree(psArr);
+}
+
+psArray* psFloatArrayAlloc(int nalloc)
+{
+    psArray *psArr = NULL;
+    psArr = psAlloc(sizeof(psArray));
+    psArr->arr.fltArr = (float*)p_psArrayAlloc(psArr, PS_TYPE_FLOAT, nalloc, sizeof(float));
+    return psArr;
+}
+
+psArray *psFloatArrayRealloc(psArray *restrict psArr, int nalloc)
+{
+    if(psArr == NULL) {                                 // For creating new psArray with realloc
+        psArr = psFloatArrayAlloc(nalloc);
+    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
+        psArr->arr.fltArr = p_psArrayRealloc(psArr, psArr->arr.fltArr, nalloc, sizeof(float));
+    }
+
+    return psArr;
+}
+
+void psFloatArrayFree(psArray *restrict psArr)
+{
+    if (psArr == NULL) {
+        return;
+    }
+    psFree(psArr->arr.fltArr);
+    psFree(psArr);
+}
+
+psArray* psDoubleArrayAlloc(int nalloc)
+{
+    psArray *psArr = NULL;
+    psArr = psAlloc(sizeof(psArray));
+    psArr->arr.dblArr = (double*)p_psArrayAlloc(psArr, PS_TYPE_DOUBLE, nalloc, sizeof(double));
+    return psArr;
+}
+
+psArray *psDoubleArrayRealloc(psArray *restrict psArr, int nalloc)
+{
+    if(psArr == NULL) {                                 // For creating new psArray with realloc
+        psArr = psDoubleArrayAlloc(nalloc);
+    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
+        psArr->arr.dblArr = p_psArrayRealloc(psArr, psArr->arr.dblArr, nalloc, sizeof(double));
+    }
+
+    return psArr;
+}
+
+void psDoubleArrayFree(psArray *restrict psArr)
+{
+    if (psArr == NULL) {
+        return;
+    }
+    psFree(psArr->arr.dblArr);
+    psFree(psArr);
+}
+
+psArray* psComplexArrayAlloc(int nalloc)
+{
+    psArray *psArr = NULL;
+    psArr = psAlloc(sizeof(psArray));
+    psArr->arr.cFltArr = (complex float*)p_psArrayAlloc(psArr, PS_TYPE_COMPLEX, nalloc, sizeof(complex float));
+    return psArr;
+}
+
+psArray *psComplexArrayRealloc(psArray *restrict psArr, int nalloc)
+{
+    if(psArr == NULL) {                                 // For creating new psArray with realloc
+        psArr = psComplexArrayAlloc(nalloc);
+    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
+        psArr->arr.cFltArr = p_psArrayRealloc(psArr, psArr->arr.cFltArr, nalloc, sizeof(complex float));
+    }
+
+    return psArr;
+}
+
+void psComplexArrayFree(psArray *restrict psArr)
+{
+    if (psArr == NULL) {
+        return;
+    }
+    psFree(psArr->arr.cFltArr);
+    psFree(psArr);
+}
+
+psArray* psVoidPtrArrayAlloc(int nalloc)
+{
+    psArray *psArr = NULL;
+    psArr = psAlloc(sizeof(psArray));
+    psArr->arr.ptrArr = p_psArrayAlloc(psArr, PS_TYPE_OTHER, nalloc, sizeof(void *));
+    return psArr;
+}
+
+psArray *psVoidPtrArrayRealloc(psArray *restrict psArr, int nalloc)
+{
+    int i = 0;
+
+    for (i = nalloc; i < psArr->n; i++) {               // For reduction in array size
+        psMemDecrRefCounter(psArr->arr.ptrArr[i]);
+    }
+
+    if(psArr == NULL) {                                 // For creating new psArray with realloc
         psArr = psVoidPtrArrayAlloc(nalloc);
-    }
-
-    return psArr;
-}
-
-static void p_psVoidPtrArrayFree(psVoidPtrArray *restrict psArr)
-{
-    if (psArr == NULL) {
-        return;
-    }
-    psFree(psArr->arr);
-    psFree(psArr);
-}
-
-/*****************************************************************************/
-/* FUNCTION IMPLEMENTATION - PUBLIC                                          */
-/*****************************************************************************/
-
-psIntArray* psIntArrayAlloc(int nalloc)
-{
-    psIntArray *psArr = NULL;
-    psArr = (psIntArray*)psAlloc(sizeof(psIntArray));
-    psArr->nalloc = nalloc;
-    psArr->n = 0;
-    psArr->arr = (int*)p_psArrayAlloc(&psArr->type, PS_TYPE_INT, nalloc, sizeof(int));
-
-    return psArr;
-}
-
-psIntArray *psIntArrayRealloc(psIntArray *psArr, int nalloc)
-{
-    if(nalloc < psArr->n) {                                         // For decrease in psArray size
-        psArr->n = nalloc;
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));     // For increase in psArray size
-    } else if(nalloc > psArr->nalloc) {
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));
-    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
-        psArr = psIntArrayAlloc(nalloc);
-    }
-
-    return psArr;
-}
-
-void psIntArrayFree(psIntArray *restrict psArr)
-{
-    if (psArr == NULL) {
-        return;
-    }
-
-    psFree(psArr->arr);
-    psFree(psArr);
-}
-
-psFloatArray* psFloatArrayAlloc(int nalloc)
-{
-    psFloatArray *psArr = NULL;
-    psArr = (psFloatArray*)psAlloc(sizeof(psFloatArray));
-    psArr->nalloc = nalloc;
-    psArr->n = 0;
-    psArr->arr = (float*)p_psArrayAlloc(&psArr->type, PS_TYPE_FLOAT, nalloc, sizeof(float));
-
-    return psArr;
-}
-
-psFloatArray *psFloatArrayRealloc(psFloatArray *psArr, int nalloc)
-{
-    if(nalloc < psArr->n) {                                         // For decrease in psArray size
-        psArr->n = nalloc;
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));   // For increase in psArray size
-    } else if(nalloc > psArr->nalloc) {
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));
-    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
-        psArr = psFloatArrayAlloc(nalloc);
-    }
-
-    return psArr;
-}
-
-void psFloatArrayFree(psFloatArray *restrict psArr)
-{
-    if (psArr == NULL) {
-        return;
-    }
-    psFree(psArr->arr);
-    psFree(psArr);
-}
-
-psDoubleArray* psDoubleArrayAlloc(int nalloc)
-{
-    psDoubleArray *psArr = NULL;
-    psArr = (psDoubleArray*)psAlloc(sizeof(psDoubleArray));
-    psArr->nalloc = nalloc;
-    psArr->n = 0;
-    psArr->arr = (double*)p_psArrayAlloc(&psArr->type, PS_TYPE_DOUBLE, nalloc, sizeof(double));
-
-    return psArr;
-}
-
-psDoubleArray *psDoubleArrayRealloc(psDoubleArray *psArr, int nalloc)
-{
-    if(nalloc < psArr->n) {                                         // For decrease in psArray size
-        psArr->n = nalloc;
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));  // For increase in psArray size
-    } else if(nalloc > psArr->nalloc) {
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));
-    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
-        psArr = psDoubleArrayAlloc(nalloc);
-    }
-
-    return psArr;
-}
-
-void psDoubleArrayFree(psDoubleArray *restrict psArr)
-{
-    if (psArr == NULL) {
-        return;
-    }
-    psFree(psArr->arr);
-    psFree(psArr);
-}
-
-psComplexArray* psComplexArrayAlloc(int nalloc)
-{
-    psComplexArray *psArr = NULL;
-    psArr = (psComplexArray*)psAlloc(sizeof(psComplexArray));
-    psArr->nalloc = nalloc;
-    psArr->n = 0;
-    psArr->arr = (complex float*)p_psArrayAlloc(&psArr->type, PS_TYPE_COMPLEX, nalloc, sizeof(complex float));
-
-    return psArr;
-}
-
-psComplexArray *psComplexArrayRealloc(psComplexArray *psArr, int nalloc)
-{
-    if(nalloc < psArr->n) {                                                 // For decrease in psArray size
-        psArr->n = nalloc;
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));   // For increase in psArray size
-    } else if(nalloc > psArr->nalloc) {
-        psArr->nalloc = nalloc;
-        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));
-    } else if(psArr == NULL) {                                              // For creating new psArray with realloc
-        psArr = psComplexArrayAlloc(nalloc);
-    }
-
-    return psArr;
-}
-
-void psComplexArrayFree(psComplexArray *restrict psArr)
-{
-    if (psArr == NULL) {
-        return;
-    }
-    psFree(psArr->arr);
-    psFree(psArr);
-}
-
-psVoidPtrArray* psVoidPtrArrayAlloc(int nalloc)
-{
-    psVoidPtrArray *psArr = NULL;
-    psArr = (psVoidPtrArray*)psAlloc(sizeof(psVoidPtrArray));
-    psArr->nalloc = nalloc;
-    psArr->n = 0;
-    psArr->arr = (void*)p_psArrayAlloc(&psArr->type, PS_TYPE_OTHER, nalloc, sizeof(void*));
-
-    return psArr;
-}
-
-psVoidPtrArray *psVoidPtrArrayRealloc(psVoidPtrArray *restrict psArr, int nalloc, void (*elemFree)(void *))
-{
-    int i = 0;
-
-    if(psArr == NULL) {
-        return psArr;
-    }
-
-    for (i = nalloc; i < psArr->n; i++) {
-        if(elemFree == NULL) {
-            psMemDecrRefCounter(psArr->arr[i]);
-        } else {
-            elemFree(psMemDecrRefCounter(psArr->arr[i]));
-        }
-    }
-
-    return p_psVoidPtrArrayRealloc(psArr, nalloc);
-}
-
-void psVoidPtrArrayFree(psVoidPtrArray *restrict psArr, void (*elemFree)(void *))
+    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
+        psArr->arr.ptrArr = p_psArrayRealloc(psArr, psArr->arr.ptrArr, nalloc, sizeof(void *));
+    }
+
+    return psArr;
+}
+
+void psVoidPtrArrayFree(psArray *restrict psArr, void (*elemFree)(void *))
 {
     int i = 0;
@@ -276,10 +227,13 @@
     for(i = 0; i < psArr->nalloc; i++) {
         if(elemFree == NULL) {
-            psMemDecrRefCounter(psArr->arr[i]);
+            psMemDecrRefCounter(psArr->arr.ptrArr[i]);
         } else {
-            elemFree(psMemDecrRefCounter(psArr->arr[i]));
+            elemFree(psMemDecrRefCounter(psArr->arr.ptrArr[i]));
         }
     }
-    p_psVoidPtrArrayFree(psArr);
-}
-
+
+    // Free pointer array
+    psFree(psArr->arr.ptrArr);
+    psFree(psArr);
+}
+