IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 5, 2004, 10:43:57 AM (22 years ago)
Author:
harman
Message:

Updated per SDR documentation bug fixes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/collections/psArray.c

    r502 r578  
    88 *  @author Ross Harman, MHPCC
    99 *   
    10  *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2004-04-22 21:15:01 $
     10 *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-05-05 20:43:22 $
    1212 *
    1313 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4848/*****************************************************************************/
    4949
    50 static void* p_psArrayAlloc(psType *arrType, psElemType elemType, int nalloc, int elemSize)
     50static void* p_psArrayAlloc(psArray *restrict psArr, psElemType elemType, int nalloc, int elemSize)
    5151{
    5252    void *arr = NULL;
    5353
    54     arrType->dimen = PS_DIMEN_VECTOR;
    55     arrType->type = elemType;
     54    psArr->type.dimen = PS_DIMEN_VECTOR;
     55    psArr->type.type = elemType;
     56    psArr->nalloc = nalloc;
     57    psArr->n = 0;
    5658
    5759    if(nalloc != 0) {
    … …  
    6264}
    6365
    64 static psVoidPtrArray *p_psVoidPtrArrayRealloc(psVoidPtrArray *restrict psArr, int nalloc)
    65 {
    66     if(nalloc < psArr->n) {                                         // For decrease in psArray size
     66static void* p_psArrayRealloc(psArray *restrict psArr, void *arr, int nalloc, int elemSize)
     67{
     68    // For decrease in psArray size
     69    if(nalloc < psArr->n) {
    6770        psArr->n = nalloc;
    68         psArr->nalloc = nalloc;
    69         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));   // For increase in psArray size
    70     } else if(nalloc > psArr->nalloc) {
    71         psArr->nalloc = nalloc;
    72         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));
    73     } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     71    }
     72
     73    psArr->nalloc = nalloc;
     74
     75    return psRealloc(arr, nalloc*elemSize);
     76}
     77
     78/*****************************************************************************/
     79/* FUNCTION IMPLEMENTATION - PUBLIC                                          */
     80/*****************************************************************************/
     81psArray* psIntArrayAlloc(int nalloc)
     82{
     83    psArray *psArr = NULL;
     84    psArr = psAlloc(sizeof(psArray));
     85    psArr->arr.intArr = (int*)p_psArrayAlloc(psArr, PS_TYPE_INT, nalloc, sizeof(int));
     86    return psArr;
     87}
     88
     89psArray *psIntArrayRealloc(psArray *restrict psArr, int nalloc)
     90{
     91    if(psArr == NULL) {                                 // For creating new psArray with realloc
     92        psArr = psIntArrayAlloc(nalloc);
     93    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
     94        psArr->arr.intArr = p_psArrayRealloc(psArr, psArr->arr.intArr, nalloc, sizeof(int));
     95    }
     96
     97    return psArr;
     98}
     99
     100void psIntArrayFree(psArray *restrict psArr)
     101{
     102    if (psArr == NULL) {
     103        return;
     104    }
     105
     106    psFree(psArr->arr.intArr);
     107    psFree(psArr);
     108}
     109
     110psArray* psFloatArrayAlloc(int nalloc)
     111{
     112    psArray *psArr = NULL;
     113    psArr = psAlloc(sizeof(psArray));
     114    psArr->arr.fltArr = (float*)p_psArrayAlloc(psArr, PS_TYPE_FLOAT, nalloc, sizeof(float));
     115    return psArr;
     116}
     117
     118psArray *psFloatArrayRealloc(psArray *restrict psArr, int nalloc)
     119{
     120    if(psArr == NULL) {                                 // For creating new psArray with realloc
     121        psArr = psFloatArrayAlloc(nalloc);
     122    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
     123        psArr->arr.fltArr = p_psArrayRealloc(psArr, psArr->arr.fltArr, nalloc, sizeof(float));
     124    }
     125
     126    return psArr;
     127}
     128
     129void psFloatArrayFree(psArray *restrict psArr)
     130{
     131    if (psArr == NULL) {
     132        return;
     133    }
     134    psFree(psArr->arr.fltArr);
     135    psFree(psArr);
     136}
     137
     138psArray* psDoubleArrayAlloc(int nalloc)
     139{
     140    psArray *psArr = NULL;
     141    psArr = psAlloc(sizeof(psArray));
     142    psArr->arr.dblArr = (double*)p_psArrayAlloc(psArr, PS_TYPE_DOUBLE, nalloc, sizeof(double));
     143    return psArr;
     144}
     145
     146psArray *psDoubleArrayRealloc(psArray *restrict psArr, int nalloc)
     147{
     148    if(psArr == NULL) {                                 // For creating new psArray with realloc
     149        psArr = psDoubleArrayAlloc(nalloc);
     150    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
     151        psArr->arr.dblArr = p_psArrayRealloc(psArr, psArr->arr.dblArr, nalloc, sizeof(double));
     152    }
     153
     154    return psArr;
     155}
     156
     157void psDoubleArrayFree(psArray *restrict psArr)
     158{
     159    if (psArr == NULL) {
     160        return;
     161    }
     162    psFree(psArr->arr.dblArr);
     163    psFree(psArr);
     164}
     165
     166psArray* psComplexArrayAlloc(int nalloc)
     167{
     168    psArray *psArr = NULL;
     169    psArr = psAlloc(sizeof(psArray));
     170    psArr->arr.cFltArr = (complex float*)p_psArrayAlloc(psArr, PS_TYPE_COMPLEX, nalloc, sizeof(complex float));
     171    return psArr;
     172}
     173
     174psArray *psComplexArrayRealloc(psArray *restrict psArr, int nalloc)
     175{
     176    if(psArr == NULL) {                                 // For creating new psArray with realloc
     177        psArr = psComplexArrayAlloc(nalloc);
     178    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
     179        psArr->arr.cFltArr = p_psArrayRealloc(psArr, psArr->arr.cFltArr, nalloc, sizeof(complex float));
     180    }
     181
     182    return psArr;
     183}
     184
     185void psComplexArrayFree(psArray *restrict psArr)
     186{
     187    if (psArr == NULL) {
     188        return;
     189    }
     190    psFree(psArr->arr.cFltArr);
     191    psFree(psArr);
     192}
     193
     194psArray* psVoidPtrArrayAlloc(int nalloc)
     195{
     196    psArray *psArr = NULL;
     197    psArr = psAlloc(sizeof(psArray));
     198    psArr->arr.ptrArr = p_psArrayAlloc(psArr, PS_TYPE_OTHER, nalloc, sizeof(void *));
     199    return psArr;
     200}
     201
     202psArray *psVoidPtrArrayRealloc(psArray *restrict psArr, int nalloc)
     203{
     204    int i = 0;
     205
     206    for (i = nalloc; i < psArr->n; i++) {               // For reduction in array size
     207        psMemDecrRefCounter(psArr->arr.ptrArr[i]);
     208    }
     209
     210    if(psArr == NULL) {                                 // For creating new psArray with realloc
    74211        psArr = psVoidPtrArrayAlloc(nalloc);
    75     }
    76 
    77     return psArr;
    78 }
    79 
    80 static void p_psVoidPtrArrayFree(psVoidPtrArray *restrict psArr)
    81 {
    82     if (psArr == NULL) {
    83         return;
    84     }
    85     psFree(psArr->arr);
    86     psFree(psArr);
    87 }
    88 
    89 /*****************************************************************************/
    90 /* FUNCTION IMPLEMENTATION - PUBLIC                                          */
    91 /*****************************************************************************/
    92 
    93 psIntArray* psIntArrayAlloc(int nalloc)
    94 {
    95     psIntArray *psArr = NULL;
    96     psArr = (psIntArray*)psAlloc(sizeof(psIntArray));
    97     psArr->nalloc = nalloc;
    98     psArr->n = 0;
    99     psArr->arr = (int*)p_psArrayAlloc(&psArr->type, PS_TYPE_INT, nalloc, sizeof(int));
    100 
    101     return psArr;
    102 }
    103 
    104 psIntArray *psIntArrayRealloc(psIntArray *psArr, int nalloc)
    105 {
    106     if(nalloc < psArr->n) {                                         // For decrease in psArray size
    107         psArr->n = nalloc;
    108         psArr->nalloc = nalloc;
    109         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));     // For increase in psArray size
    110     } else if(nalloc > psArr->nalloc) {
    111         psArr->nalloc = nalloc;
    112         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));
    113     } else if(psArr == NULL) {                                      // For creating new psArray with realloc
    114         psArr = psIntArrayAlloc(nalloc);
    115     }
    116 
    117     return psArr;
    118 }
    119 
    120 void psIntArrayFree(psIntArray *restrict psArr)
    121 {
    122     if (psArr == NULL) {
    123         return;
    124     }
    125 
    126     psFree(psArr->arr);
    127     psFree(psArr);
    128 }
    129 
    130 psFloatArray* psFloatArrayAlloc(int nalloc)
    131 {
    132     psFloatArray *psArr = NULL;
    133     psArr = (psFloatArray*)psAlloc(sizeof(psFloatArray));
    134     psArr->nalloc = nalloc;
    135     psArr->n = 0;
    136     psArr->arr = (float*)p_psArrayAlloc(&psArr->type, PS_TYPE_FLOAT, nalloc, sizeof(float));
    137 
    138     return psArr;
    139 }
    140 
    141 psFloatArray *psFloatArrayRealloc(psFloatArray *psArr, int nalloc)
    142 {
    143     if(nalloc < psArr->n) {                                         // For decrease in psArray size
    144         psArr->n = nalloc;
    145         psArr->nalloc = nalloc;
    146         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));   // For increase in psArray size
    147     } else if(nalloc > psArr->nalloc) {
    148         psArr->nalloc = nalloc;
    149         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));
    150     } else if(psArr == NULL) {                                      // For creating new psArray with realloc
    151         psArr = psFloatArrayAlloc(nalloc);
    152     }
    153 
    154     return psArr;
    155 }
    156 
    157 void psFloatArrayFree(psFloatArray *restrict psArr)
    158 {
    159     if (psArr == NULL) {
    160         return;
    161     }
    162     psFree(psArr->arr);
    163     psFree(psArr);
    164 }
    165 
    166 psDoubleArray* psDoubleArrayAlloc(int nalloc)
    167 {
    168     psDoubleArray *psArr = NULL;
    169     psArr = (psDoubleArray*)psAlloc(sizeof(psDoubleArray));
    170     psArr->nalloc = nalloc;
    171     psArr->n = 0;
    172     psArr->arr = (double*)p_psArrayAlloc(&psArr->type, PS_TYPE_DOUBLE, nalloc, sizeof(double));
    173 
    174     return psArr;
    175 }
    176 
    177 psDoubleArray *psDoubleArrayRealloc(psDoubleArray *psArr, int nalloc)
    178 {
    179     if(nalloc < psArr->n) {                                         // For decrease in psArray size
    180         psArr->n = nalloc;
    181         psArr->nalloc = nalloc;
    182         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));  // For increase in psArray size
    183     } else if(nalloc > psArr->nalloc) {
    184         psArr->nalloc = nalloc;
    185         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));
    186     } else if(psArr == NULL) {                                      // For creating new psArray with realloc
    187         psArr = psDoubleArrayAlloc(nalloc);
    188     }
    189 
    190     return psArr;
    191 }
    192 
    193 void psDoubleArrayFree(psDoubleArray *restrict psArr)
    194 {
    195     if (psArr == NULL) {
    196         return;
    197     }
    198     psFree(psArr->arr);
    199     psFree(psArr);
    200 }
    201 
    202 psComplexArray* psComplexArrayAlloc(int nalloc)
    203 {
    204     psComplexArray *psArr = NULL;
    205     psArr = (psComplexArray*)psAlloc(sizeof(psComplexArray));
    206     psArr->nalloc = nalloc;
    207     psArr->n = 0;
    208     psArr->arr = (complex float*)p_psArrayAlloc(&psArr->type, PS_TYPE_COMPLEX, nalloc, sizeof(complex float));
    209 
    210     return psArr;
    211 }
    212 
    213 psComplexArray *psComplexArrayRealloc(psComplexArray *psArr, int nalloc)
    214 {
    215     if(nalloc < psArr->n) {                                                 // For decrease in psArray size
    216         psArr->n = nalloc;
    217         psArr->nalloc = nalloc;
    218         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));   // For increase in psArray size
    219     } else if(nalloc > psArr->nalloc) {
    220         psArr->nalloc = nalloc;
    221         psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));
    222     } else if(psArr == NULL) {                                              // For creating new psArray with realloc
    223         psArr = psComplexArrayAlloc(nalloc);
    224     }
    225 
    226     return psArr;
    227 }
    228 
    229 void psComplexArrayFree(psComplexArray *restrict psArr)
    230 {
    231     if (psArr == NULL) {
    232         return;
    233     }
    234     psFree(psArr->arr);
    235     psFree(psArr);
    236 }
    237 
    238 psVoidPtrArray* psVoidPtrArrayAlloc(int nalloc)
    239 {
    240     psVoidPtrArray *psArr = NULL;
    241     psArr = (psVoidPtrArray*)psAlloc(sizeof(psVoidPtrArray));
    242     psArr->nalloc = nalloc;
    243     psArr->n = 0;
    244     psArr->arr = (void*)p_psArrayAlloc(&psArr->type, PS_TYPE_OTHER, nalloc, sizeof(void*));
    245 
    246     return psArr;
    247 }
    248 
    249 psVoidPtrArray *psVoidPtrArrayRealloc(psVoidPtrArray *restrict psArr, int nalloc, void (*elemFree)(void *))
    250 {
    251     int i = 0;
    252 
    253     if(psArr == NULL) {
    254         return psArr;
    255     }
    256 
    257     for (i = nalloc; i < psArr->n; i++) {
    258         if(elemFree == NULL) {
    259             psMemDecrRefCounter(psArr->arr[i]);
    260         } else {
    261             elemFree(psMemDecrRefCounter(psArr->arr[i]));
    262         }
    263     }
    264 
    265     return p_psVoidPtrArrayRealloc(psArr, nalloc);
    266 }
    267 
    268 void psVoidPtrArrayFree(psVoidPtrArray *restrict psArr, void (*elemFree)(void *))
     212    } else if(psArr->nalloc != nalloc) {                // No need to realloc to same size
     213        psArr->arr.ptrArr = p_psArrayRealloc(psArr, psArr->arr.ptrArr, nalloc, sizeof(void *));
     214    }
     215
     216    return psArr;
     217}
     218
     219void psVoidPtrArrayFree(psArray *restrict psArr, void (*elemFree)(void *))
    269220{
    270221    int i = 0;
    … …  
    276227    for(i = 0; i < psArr->nalloc; i++) {
    277228        if(elemFree == NULL) {
    278             psMemDecrRefCounter(psArr->arr[i]);
     229            psMemDecrRefCounter(psArr->arr.ptrArr[i]);
    279230        } else {
    280             elemFree(psMemDecrRefCounter(psArr->arr[i]));
     231            elemFree(psMemDecrRefCounter(psArr->arr.ptrArr[i]));
    281232        }
    282233    }
    283     p_psVoidPtrArrayFree(psArr);
    284 }
    285 
     234
     235    // Free pointer array
     236    psFree(psArr->arr.ptrArr);
     237    psFree(psArr);
     238}
     239
Note: See TracChangeset for help on using the changeset viewer.