IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 164


Ignore:
Timestamp:
Mar 9, 2004, 2:34:28 PM (22 years ago)
Author:
rhl
Message:

Changed New/Del to Alloc/Free

Location:
trunk/archive/pslib/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/archive/pslib/src/Metadata/metadata.c

    r156 r164  
    1313 * Handle sets of metadata
    1414 */
    15 psMetaDataSet *psMetaDataSetNew(void)   // make a new set of metadata
     15psMetaDataSet *psMetaDataSetAlloc(void) // make a new set of metadata
    1616{
    1717    psMetaDataSet *ms = psAlloc(sizeof(psMetaDataSet));
    1818
    19     ms->list = psDlistNew(NULL);        // list of metadata
    20     ms->table = psHashNew(128);         // hash table
     19    ms->list = psDlistAlloc(NULL);      // list of metadata
     20    ms->table = psHashAlloc(128);       // hash table
    2121
    2222    return ms;
    2323}
    2424
    25 void psMetaDataSetDel(psMetaDataSet *ms) // destroy a set of metadata
     25void psMetaDataSetFree(psMetaDataSet *ms) // destroy a set of metadata
    2626{
    2727    if (ms == NULL) {
    … …  
    2929    }
    3030   
    31     psDlistDel(ms->list, (void (*)(void *))NULL);
    32     psHashDel(ms->table, (void (*)(void *))psMetaDataItemDel);
     31    psDlistFree(ms->list, (void (*)(void *))NULL);
     32    psHashFree(ms->table, (void (*)(void *))psMetaDataItemFree);
    3333
    3434    psFree(ms);
    … …  
    4343 * to the data will be kept.
    4444 */
    45 psMetaDataItem *psMetaDataItemNew(
     45psMetaDataItem *psMetaDataItemAlloc(
    4646    int typeFlags,                      // type of this piece of metadata + flags
    4747    const void *data,                   // value of new item
    … …  
    5252{
    5353    const psMetaDataType type = typeFlags & PS_META_TYPE_MASK; // the type part of typeFlags
    54     const long flags = typeFlags & ~PS_META_TYPE_MASK;         // the flags part of typeFlags
     54    psMetaDataFlags flags = typeFlags & ~PS_META_TYPE_MASK;    // the flags part of typeFlags
    5555    static int id = 0;                  // unique ID for an item of metadata
    5656    psMetaDataItem *ms = psAlloc(sizeof(psMetaDataItem));
    … …  
    9494      case PS_META_ITEM_SET:
    9595        *(void **)&ms->val.v = NULL;
    96         ms->items = psDlistNew(NULL);
     96        ms->items = psDlistAlloc(NULL);
    9797        break;
    9898
    … …  
    106106       
    107107      case PS_META_STR:
    108         *(void **)&ms->val.v = psAlloc(strlen(data) + 1);
    109         strcpy(ms->val.v, data);
     108        *(void **)&ms->val.v = psStringCopy(data);
    110109        break;
    111110       
    … …  
    117116        *(void **)&ms->val.v = (void *)data;
    118117        break;
     118
    119119      case PS_META_NTYPE:
    120120        psAbort(__FILE__, "You cannot get here (%d)\n", __LINE__);
    … …  
    125125}
    126126
    127 void psMetaDataItemDel(psMetaDataItem *ms)      // piece of metadata to destroy
     127void psMetaDataItemFree(psMetaDataItem *ms) // piece of metadata to destroy
    128128{
    129129    if(ms == NULL) {
    … …  
    137137    switch (ms->type) {
    138138      case PS_META_ITEM_SET:
    139         psDlistDel(ms->items, (void (*)(void *))NULL); // they're still in the hash table
     139        psDlistFree(ms->items, (void (*)(void *))NULL); // they're still in the hash table
    140140        ms->items = NULL;
    141141        break;
     142       
    142143      case PS_META_FLOAT:
    143144      case PS_META_INT:
    144145        break;                          // nothing to do
     146       
    145147      case PS_META_STR:
    146148        psFree(ms->val.v);
    … …  
    153155      case PS_META_UNKNOWN:
    154156        break;                          // we don't own the memory
     157       
    155158      case PS_META_NTYPE:
    156159        psAbort(__FILE__, "You cannot get here (%d)\n", __LINE__);
    … …  
    177180        psMetaDataItem *head = meta;
    178181        if (head == NULL) {             // this is the first item of this name
    179             head = psMetaDataAppend(ms, psMetaDataItemNew(PS_META_ITEM_SET, NULL, NULL, item->name));
     182            head = psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_ITEM_SET, NULL, NULL, item->name));
    180183        }           
    181184
    … …  
    199202
    200203        psDlistAppend(head->items, item);
    201         psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemDel);
     204        psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemFree);
    202205
    203206        return item;
    204207    } else if (meta != NULL) {
    205208        psError(__func__, "Key \"%s\" is already present in the metaDataSet 0x%x", item->name, ms);
    206         //psMetaDataItemDel(item);
     209        //psMetaDataItemFree(item);
    207210
    208211        return NULL;
    … …  
    210213
    211214    psDlistAppend(ms->list, item);
    212     psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemDel);
     215    psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemFree);
    213216
    214217    return item;
    … …  
    223226    assert (ms != NULL && ms->list != NULL && ms->table != NULL);
    224227
    225     void *data = psHashRemove(ms->table, key);
    226 
    227     if (data == NULL) {
     228    psMetaDataItem *meta = psHashRemove(ms->table, key);
     229
     230    if (meta == NULL) {
    228231        return NULL;
    229232    } else {
    230         return psDlistRemove(ms->list, data, PS_DLIST_UNKNOWN);
     233        if (meta->flags & PS_META_NON_UNIQUE) { // it's on someone's ->items list; find that someone
     234            char baseKey[strlen(key) + 1];      // Name without the .nnn tacked on
     235            strcpy(baseKey, key);
     236
     237            char *ptr = strrchr(baseKey, '.');
     238            assert (ptr != NULL);
     239            *ptr = '\0';
     240
     241            psMetaDataItem *base = psHashLookup(ms->table, baseKey); // here's the non-qualified metadata
     242            assert (base != NULL);
     243
     244            return psDlistRemove(base->items, meta, PS_DLIST_UNKNOWN);
     245        } else {
     246            return psDlistRemove(ms->list, meta, PS_DLIST_UNKNOWN);
     247        }
    231248    }
    232249}
    … …  
    301318       
    302319        break;
     320       
    303321      case PS_META_FLOAT:
    304322        fprintf(fd, "%g\n", ms->val.f);
    305323        break;
     324       
    306325      case PS_META_INT:
    307326        fprintf(fd, "%d\n", ms->val.i);
    308327        break;
     328       
    309329      case PS_META_STR:
    310330        fprintf(fd, "%s\n", (char *)ms->val.v);
    311331        break;
     332       
    312333      case PS_META_IMG:
    313334        fprintf(fd, "(IMG)\n");
    314335        break;
     336       
    315337      case PS_META_JPEG:
    316338        fprintf(fd, "(JPG)\n");
    317339        break;
     340       
    318341      case PS_META_PNG:
    319342        fprintf(fd, "(PNG)\n");
    320343        break;
     344       
    321345      case PS_META_ASTROM:
    322346        fprintf(fd, "(ASTROM)\n");
    323347        break;
     348       
    324349      case PS_META_UNKNOWN:
    325350        fprintf(fd, "(UNKNOWN)\n");
    326351        break;
     352       
    327353      case PS_META_NTYPE:
    328354        psAbort(__FILE__, "You cannot get here (%d)\n", __LINE__);
    … …  
    343369    psSetLogFormat("NM");               // suppress some of the psLogMsg verbosity
    344370
    345     psMetaDataSet *ms = psMetaDataSetNew(); // set of metadata
     371    psMetaDataSet *ms = psMetaDataSetAlloc(); // set of metadata
    346372    psMetaDataItem *meta = NULL;            // used to traverse a set of metadata
    347373
    348374    for (int i = 0; i < 10; i += 5) {
    349375        float sqrti = sqrt(i);
    350         psMetaDataAppend(ms, psMetaDataItemNew(PS_META_INT, &i, NULL, "const.%d", i));
    351         psMetaDataAppend(ms, psMetaDataItemNew(PS_META_FLOAT, &sqrti, "square root", "const.sqrt%d", i));
    352     }
    353     psMetaDataAppend(ms, psMetaDataItemNew(PS_META_STR | PS_META_NON_UNIQUE,
     376        psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_INT, &i, NULL, "const.%d", i));
     377        psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_FLOAT, &sqrti, "square root", "const.sqrt%d", i));
     378    }
     379    psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_STR | PS_META_NON_UNIQUE,
    354380                                           "Bonjour", "French", "lang.hello"));
    355     psMetaDataAppend(ms, psMetaDataItemNew(PS_META_STR | PS_META_NON_UNIQUE,
     381    psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_STR | PS_META_NON_UNIQUE,
    356382                                           "Aloha", "Hawaiian", "lang.hello"));
    357     psMetaDataAppend(ms, psMetaDataItemNew(PS_META_STR | PS_META_NON_UNIQUE,
     383    psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_STR | PS_META_NON_UNIQUE,
    358384                                           "Good Morning", "English", "lang.hello"));
    359385    /*
    360386     * Print all metadata starting "lang"
    361387     */
     388    psMetaDataItemFree(psMetaDataRemove(ms, "lang.hello.0"));
     389
    362390    psMetaDataSetIterator(ms);
    363391    while ((meta = psMetaDataGetNext(ms, "lang")) != NULL) {
    … …  
    367395     * Remove a key
    368396     */
    369     psMetaDataItemDel(psMetaDataRemove(ms, "lang.hello"));
     397    psMetaDataItemFree(psMetaDataRemove(ms, "lang.hello"));
    370398    /*
    371399     * Print all metadata
    … …  
    388416     * Clean up
    389417     */
    390     psMetaDataSetDel(ms);
     418    psMetaDataSetFree(ms);
    391419    /*
    392420     * Check for memory leaks

  • trunk/archive/pslib/src/Metadata/psMetaData.h

    r156 r164  
    2020} psMetaDataType;
    2121
    22 enum {
     22typedef enum {
    2323    PS_META_TYPE_MASK =     0xffff,     // the type enum must fit in this mask
    2424    PS_META_UNIQUE =       0x10000,     // the name must be unique (default)
    2525    PS_META_NON_UNIQUE =   0x20000,     // the name may be repeated, and should be disambiguated for us
    26 };
     26} psMetaDataFlags;
    2727
    2828/*
    … …  
    3434    char *restrict name;                // Name of item
    3535    psMetaDataType type;                // type of this item
    36     int flags;                          // flags associated with this item
     36    psMetaDataFlags flags;              // flags associated with this item
    3737    const union {
    3838        float f;                        // floating value
    … …  
    5656 * Constructors and destructors
    5757 */
    58 psMetaDataItem *psMetaDataItemNew(
     58psMetaDataItem *psMetaDataItemAlloc(
    5959    int typeFlags,                      // type of this piece of metadata + flags
    6060    const void *val,                    // value of new item
    … …  
    6565    ...);                               // possible arguments for name format
    6666
    67 void psMetaDataItemDel(psMetaDataItem *ms); // piece of metadata to destroy
     67void psMetaDataItemFree(psMetaDataItem *ms); // piece of metadata to destroy
    6868
    69 psMetaDataSet *psMetaDataSetNew(void);    // make a new set of metadata
    70 void psMetaDataSetDel(psMetaDataSet *ms); // destroy a set of metadata
     69psMetaDataSet *psMetaDataSetAlloc(void);   // make a new set of metadata
     70void psMetaDataSetFree(psMetaDataSet *ms); // destroy a set of metadata
    7171
    7272/*****************************************************************************/

  • trunk/archive/pslib/src/Utils/array.c

    r141 r164  
    1010P_PS_CREATE_ARRAY_TYPE(static, my_, psVoidPtr);
    1111
    12 psVoidPtrArray *psVoidPtrArrayNew(int n, int s)
     12psVoidPtrArray *psVoidPtrArrayAlloc(int n, int s)
    1313{
    14     return my_psVoidPtrArrayNew(n, s);
     14    return my_psVoidPtrArrayAlloc(n, s);
    1515}
    1616
    … …  
    2020}
    2121
    22 void psVoidPtrArrayDel(psVoidPtrArray *arr,
    23                        void (*elemDel)(void *)) // destructor for data on array
     22void psVoidPtrArrayFree(psVoidPtrArray *arr,
     23                        void (*elemFree)(void *)) // destructor for data on array
    2424{
    2525    if (arr == NULL) {
    … …  
    2828       
    2929    for (int i = 0; i < arr->n; i++) {
    30         if (elemDel == NULL) {
     30        if (elemFree == NULL) {
    3131            psMemDecrRefCounter(arr->arr[i]);
    3232        } else {
    33             elemDel(psMemDecrRefCounter(arr->arr[i]));
     33            elemFree(psMemDecrRefCounter(arr->arr[i]));
    3434        }
    3535    }
    36     my_psVoidPtrArrayDel(arr);
     36    my_psVoidPtrArrayFree(arr);
    3737}
    3838
    … …  
    4444} psXY;
    4545
    46 psXY *psXYNew(void)
     46psXY *psXYAlloc(void)
    4747{
    4848    return psAlloc(sizeof(psXY));
    4949}
    5050
    51 void psXYDel(psXY *xy)
     51void psXYFree(psXY *xy)
    5252{
    5353    psFree(xy);
    … …  
    6262int main(void)
    6363{
    64     psXYArray *t = psXYArrayNew(10, 15);
    65     psXYPtrArray *pt = psXYPtrArrayNew(10, 10);
     64    psXYArray *t = psXYArrayAlloc(10, 15);
     65    psXYPtrArray *pt = psXYPtrArrayAlloc(10, 10);
    6666
    6767    for (int i = 0; i < t->n; i++) {
    … …  
    7878    printf("\n");
    7979   
    80     psXYArrayDel(t);
     80    psXYArrayFree(t);
    8181
    8282    psXY *xy = psMemDecrRefCounter(pt->arr[0]);
    8383    pt->arr[0] = NULL;
    84     psXYDel(xy);   
     84    psXYFree(xy);   
    8585   
    86     psXYPtrArrayDel(pt);
     86    psXYPtrArrayFree(pt);
    8787
    8888    psMemCheckLeaks(0, NULL, stderr);

  • trunk/archive/pslib/src/Utils/psArray.h

    r141 r164  
    1414    } PS_CONCAT(TYPE, Array); \
    1515    \
    16 PS_CONCAT(TYPE, Array) *PS_CONCAT3(TYPE,Array,New)(int n, int s); \
     16PS_CONCAT(TYPE, Array) *PS_CONCAT3(TYPE,Array,Alloc)(int n, int s); \
    1717PS_CONCAT(TYPE, Array) *PS_CONCAT3(TYPE,Array,Realloc)(PS_CONCAT(TYPE, Array) *arr, int n); \
    18 void PS_CONCAT3(TYPE,Array,Del)(PS_CONCAT(TYPE, Array) *arr)
     18void PS_CONCAT3(TYPE,Array,Free)(PS_CONCAT(TYPE, Array) *arr)
    1919
    2020/*****************************************************************************/
    … …  
    2727#define P_PS_CREATE_ARRAY_TYPE(QUAL,PREFIX,TYPE) \
    2828\
    29 QUAL PS_CONCAT(TYPE, Array) *PS_CONCAT4(PREFIX,TYPE,Array,New)(int n, /* initial dimension */\
     29QUAL PS_CONCAT(TYPE, Array) *PS_CONCAT4(PREFIX,TYPE,Array,Alloc)(int n, /* initial dimension */\
    3030                                                   int s) /* initial number of elements */ \
    3131{ \
    … …  
    3333    \
    3434    if (n > s) { \
    35         psLogMsg(PS_STRING(TYPE) "ArrayNew", PS_LOG_ERROR, "Too few elements requested in array (%d < %d)\n", s, n); \
     35        psLogMsg(PS_STRING(TYPE) "ArrayAlloc", PS_LOG_ERROR, "Too few elements requested in array (%d < %d)\n", s, n); \
    3636        s = n; \
    3737    } \
    … …  
    5252{ \
    5353    if (arr == NULL) { \
    54         return PS_CONCAT4(PREFIX,TYPE,Array,New)(n, n); \
     54        return PS_CONCAT4(PREFIX,TYPE,Array,Alloc)(n, n); \
    5555    } \
    5656    \
    … …  
    6767} \
    6868\
    69 QUAL void PS_CONCAT4(PREFIX,TYPE,Array,Del)(PS_CONCAT(TYPE,Array) *arr) \
     69QUAL void PS_CONCAT4(PREFIX,TYPE,Array,Free)(PS_CONCAT(TYPE,Array) *arr) \
    7070{ \
    7171    if (arr == NULL) { \
    … …  
    8888    P_PS_CREATE_ARRAY_TYPE(static, my_, P_PS_CONCAT(TYPE, Ptr)) \
    8989    \
    90     PS_CONCAT(TYPE, PtrArray) *PS_CONCAT3(TYPE,PtrArray,New)(int n, int s) \
     90    PS_CONCAT(TYPE, PtrArray) *PS_CONCAT3(TYPE,PtrArray,Alloc)(int n, int s) \
    9191    { \
    92         PS_CONCAT(TYPE, PtrArray) *arr = PS_CONCAT4(my_,TYPE,PtrArray,New)(n, s); \
     92        PS_CONCAT(TYPE, PtrArray) *arr = PS_CONCAT4(my_,TYPE,PtrArray,Alloc)(n, s); \
    9393        for (int i = 0; i < arr->n; i++) { \
    94             arr->arr[i] = psMemIncrRefCounter,(PS_CONCAT(TYPE, New)());\
     94            arr->arr[i] = psMemIncrRefCounter,(PS_CONCAT(TYPE, Alloc)());\
    9595        } \
    9696        \
    … …  
    101101    { \
    102102        for (int i = n; i < arr->n; i++) { \
    103             PS_CONCAT(TYPE, Del)(psMemDecrRefCounter(arr->arr[i]));\
     103            PS_CONCAT(TYPE, Free)(psMemDecrRefCounter(arr->arr[i]));\
    104104        } \
    105105        \
    … …  
    107107    } \
    108108    \
    109     void PS_CONCAT3(TYPE,PtrArray,Del)(PS_CONCAT2(TYPE,PtrArray) *arr) \
     109    void PS_CONCAT3(TYPE,PtrArray,Free)(PS_CONCAT2(TYPE,PtrArray) *arr) \
    110110    { \
    111111        if (arr == NULL) { return; } \
    112112        for (int i = 0; i < arr->size; i++) { \
    113             PS_CONCAT(TYPE, Del)(psMemDecrRefCounter(arr->arr[i])); \
     113            PS_CONCAT(TYPE, Free)(psMemDecrRefCounter(arr->arr[i])); \
    114114        } \
    115         PS_CONCAT4(my_, TYPE, PtrArray, Del)(arr); \
     115        PS_CONCAT4(my_, TYPE, PtrArray, Free)(arr); \
    116116    }
    117117
    … …  
    129129} psVoidPtrArray;
    130130
    131 psVoidPtrArray *psVoidPtrArrayNew(int n, int s);
     131psVoidPtrArray *psVoidPtrArrayAlloc(int n, int s);
    132132psVoidPtrArray *psVoidPtrArrayRealloc(psVoidPtrArray *arr, int n);
    133 void psVoidPtrArrayDel(psVoidPtrArray *arr,
    134                        void (*elemDel)(void *)); // destructor for array data
     133void psVoidPtrArrayFree(psVoidPtrArray *arr,
     134                        void (*elemFree)(void *)); // destructor for array data
    135135
    136136
Note: See TracChangeset for help on using the changeset viewer.