IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 3, 2004, 1:19:07 PM (22 years ago)
Author:
harman
Message:

Updates for version 10 of SDRS

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astronomy/psMetadata.c

    r2521 r2607  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2004-11-30 00:26:53 $
     14*  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2004-12-03 23:14:28 $
    1616*
    1717*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    8080    psFree(metadataItem->name);
    8181    psFree(metadataItem->comment);
    82     psFree(metadataItem->items);
    83     if (type == PS_META_STR || type == PS_META_VEC || type == PS_META_IMG || type == PS_META_LOOKUPTABLE ||
    84             type == PS_META_JPEG || type == PS_META_PNG || type == PS_META_ASTROM || type == PS_META_UNKNOWN ||
    85             type == PS_META_HASH) {
     82    if (type != PS_META_PRIMITIVE) {
    8683        psFree(metadataItem->data.V);
    8784    }
    … …  
    10198/*****************************************************************************/
    10299
    103 psMetadataItem* psMetadataItemAlloc(const char *name, psMetadataType type, const char *comment, ...)
     100psMetadataItem* psMetadataItemAlloc(const char *name, psElemType pType, psMetadataType type,
     101                                    const char *comment, ...)
    104102{
    105103    va_list argPtr;
    … …  
    110108
    111109    // Call metadata item allocation
    112     metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
     110    metadataItem = psMetadataItemAllocV(name, pType, type, comment, argPtr);
    113111
    114112    // Clean up stack after variable arguement has been used
    … …  
    118116}
    119117
    120 psMetadataItem* psMetadataItemAllocV(const char *name, psMetadataType type, const char *comment,
    121                                      va_list argPtr)
    122 {
    123     psVector *vecIn = NULL;
    124     psVector *vecOut = NULL;
     118psMetadataItem* psMetadataItemAllocV(const char *name, psElemType pType, psMetadataType type,
     119                                     const char *comment, va_list argPtr)
     120{
    125121    psMetadataItem* metadataItem = NULL;
    126122
    … …  
    129125
    130126    // Allocate metadata item
    131     metadataItem = (psMetadataItem* ) psAlloc(sizeof(psMetadataItem));
     127    metadataItem = (psMetadataItem*) psAlloc(sizeof(psMetadataItem));
     128    metadataItem->data.V = NULL;
    132129
    133130    // Set deallocator
    … …  
    148145    // Set metadata item type
    149146    metadataItem->type = type;
    150     metadataItem->data.V = NULL;
    151 
    152     // Allocate metadata items with same name.
    153     metadataItem->items = psListAlloc(NULL);
     147    metadataItem->pType = pType;
    154148
    155149    // Allocate and set metadata item name
    … …  
    158152
    159153    // Set metadata item value
    160     switch (type) {
    161     case PS_META_ITEM_SET:
    162         break;
    163     case PS_META_BOOL:
    164         metadataItem->data.B = (psBool)va_arg(argPtr, psS32);
    165         break;
    166     case PS_META_S32:
    167         metadataItem->data.S32 = (psS32)va_arg(argPtr, psS32);
    168         break;
    169     case PS_META_F32:
    170         metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64);
    171         break;
    172     case PS_META_F64:
    173         metadataItem->data.F64 = va_arg(argPtr, psF64);
     154    switch(type) {
     155    case PS_META_PRIMITIVE:
     156        switch(pType) {
     157        case PS_TYPE_BOOL:
     158            metadataItem->data.B = (psBool)va_arg(argPtr, psS32);
     159            break;
     160        case PS_TYPE_S32:
     161            metadataItem->data.S32 = (psS32)va_arg(argPtr, psS32);
     162            break;
     163        case PS_TYPE_F32:
     164            metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64);
     165            break;
     166        case PS_TYPE_F64:
     167            metadataItem->data.F64 = (psF64)va_arg(argPtr, psF64);
     168            break;
     169        default:
     170            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
     171            psFree(metadataItem);
     172            metadataItem = NULL;
     173        }
    174174        break;
    175175    case PS_META_STR:
     176        // Perform copy of input strings
    176177        metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH);
    177178        break;
     179    case PS_META_LIST:
    178180    case PS_META_VEC:
    179         vecIn = (psVector*)va_arg(argPtr, psVector*);
    180         vecOut = psVectorAlloc(vecIn->nalloc, vecIn->type.type);
    181         memcpy(vecOut->data.V, vecIn->data.V, vecIn->nalloc*PSELEMTYPE_SIZEOF(vecIn->type.type));
    182         metadataItem->data.V = vecOut;
    183         break;
     181    case PS_META_HASH:
    184182    case PS_META_LOOKUPTABLE:
    185         metadataItem->data.V = va_arg(argPtr, psLookupTable*); // Deep copy of input data not performed
    186         break;
    187     case PS_META_HASH:
    188         metadataItem->data.V = va_arg(argPtr, psHash*); // Deep copy of input data not performed
    189         break;
    190     case PS_META_IMG:
    191183    case PS_META_JPEG:
    192184    case PS_META_PNG:
    193185    case PS_META_ASTROM:
    194186    case PS_META_UNKNOWN:
     187        // Copy of input data not performed due to variability of data types
     188        metadataItem->data.V = va_arg(argPtr, psPtr);
     189        break;
    195190    default:
    196191        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
    … …  
    209204
    210205    // Allocate metadata
    211     metadata = (psMetadata* ) psAlloc(sizeof(psMetadata));
     206    metadata = (psMetadata*) psAlloc(sizeof(psMetadata));
    212207    // Set deallocator
    213208    p_psMemSetDeallocator(metadata, (psFreeFcn) metadataFree);
    214209
    215210    // Allocate metadata's internal containers
    216     list = (psList* ) psListAlloc(NULL);
    217     table = (psHash* ) psHashAlloc(10);
     211    list = (psList*) psListAlloc(NULL);
     212    table = (psHash*) psHashAlloc(10);
    218213
    219214    metadata->list = list;
    … …  
    223218}
    224219
    225 psBool psMetadataAddItem( psMetadata *restrict md, psMetadataItem *restrict metadataItem, psS32 location )
     220psBool psMetadataAddItem(psMetadata *restrict md, psMetadataItem *restrict metadataItem, psS32 location)
    226221{
    227222    char * key = NULL;
    … …  
    230225    psMetadataItem *existingEntry = NULL;
    231226    psMetadataItem *newFolderEntry = NULL;
    232     psMetadataType newType = PS_META_ITEM_SET;
     227    psMetadataType newType;
    233228
    234229    PS_PTR_CHECK_NULL(md,NULL);
    … …  
    247242    if(existingEntry != NULL) {
    248243
    249         if(existingEntry->type == PS_META_ITEM_SET) {
     244        if(existingEntry->type == PS_META_LIST) {
     245
     246            if(existingEntry->data.list == NULL) {
     247                existingEntry->data.list = psListAlloc(NULL);
     248            }
    250249
    251250            // Add leaf node to existing folder node
    252             if(!psListAdd(existingEntry->items, PS_LIST_TAIL, metadataItem)) {
    253                 psError(PS_ERR_UNKNOWN,false,
    254                         PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
    255                         metadataItem->name );
    256                 return false;
    257             }
    258         } else if(existingEntry->type != PS_META_ITEM_SET && newType!= PS_META_ITEM_SET) {
     251            if(!psListAdd(existingEntry->data.list, PS_LIST_TAIL, metadataItem)) {
     252                psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED, metadataItem->name);
     253                return false;
     254            }
     255        } else if(existingEntry->type != PS_META_LIST && newType!= PS_META_LIST) {
    259256
    260257            // Leaf node replaces another leaf. Make new folder node and add leaves.
    261             newFolderEntry = psMetadataItemAlloc(key, PS_META_ITEM_SET, NULL, NULL);
    262 
    263             if(!psListAdd(newFolderEntry->items, PS_LIST_TAIL, existingEntry)) {
    264                 psError(PS_ERR_UNKNOWN,false,
    265                         PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
    266                         key);
     258            newFolderEntry = psMetadataItemAlloc(key, PS_TYPE_PTR, PS_META_LIST, NULL, NULL);
     259            newFolderEntry->data.list = psListAlloc(NULL);
     260
     261            if(!psListAdd(newFolderEntry->data.list, PS_LIST_TAIL, existingEntry)) {
     262                psError(PS_ERR_UNKNOWN,false, PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,key);
    267263                psFree(newFolderEntry);
    268264                return false;
    269265            }
    270266
    271             if(!psListAdd(newFolderEntry->items, PS_LIST_TAIL, metadataItem)) {
    272                 psError(PS_ERR_UNKNOWN,false,
    273                         PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
    274                         key);
     267            if(!psListAdd(newFolderEntry->data.list, PS_LIST_TAIL, metadataItem)) {
     268                psError(PS_ERR_UNKNOWN,false, PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,key);
    275269                psFree(newFolderEntry);
    276270                return false;
    … …  
    278272
    279273            if(!psHashRemove(mdTable, key)) {
    280                 psError(PS_ERR_UNKNOWN,false,
    281                         PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,
    282                         key);
     274                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,key);
    283275                psFree(newFolderEntry);
    284276                return false;
    … …  
    286278
    287279            if(!psHashAdd(mdTable, key, newFolderEntry)) {
    288                 psError(PS_ERR_UNKNOWN,false,
    289                         PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,
    290                         key);
     280                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
    291281                psFree(newFolderEntry);
    292282                return false;
    … …  
    298288
    299289            // Folder node replaces leaf or folder node - Put old node into new folder and remove from table
    300             if(!psListAdd(metadataItem->items, PS_LIST_TAIL, existingEntry)) {
    301                 psError(PS_ERR_UNKNOWN,false,
    302                         PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
    303                         key);
     290            if(metadataItem->data.list == NULL) {
     291                metadataItem->data.list = psListAlloc(NULL);
     292            }
     293
     294            if(!psListAdd(metadataItem->data.list, PS_LIST_TAIL, existingEntry)) {
     295                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,key);
    304296                return false;
    305297            }
    306298
    307299            if(!psHashRemove(mdTable, key)) {
    308                 psError(PS_ERR_UNKNOWN,false,
    309                         PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,
    310                         key);
     300                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,key);
    311301                return false;
    312302            }
    313303
    314304            if(!psHashAdd(mdTable, key, metadataItem)) {
    315                 psError(PS_ERR_UNKNOWN,false,
    316                         PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,
    317                         key);
     305                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
    318306                return false;
    319307            }
    … …  
    323311        // Node doesn't exist - Add new metadata item to metadata collection's hash
    324312        if(!psHashAdd(mdTable, key, metadataItem)) {
    325             psError(PS_ERR_UNKNOWN,false,
    326                     PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,
    327                     key);
     313            psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
    328314            return false;
    329315        }
    … …  
    331317
    332318    // Add items to metadata collection's list, even if they have the same metadata item names. Folder nodes
    333     // (PS_META_ITEM_SET metadata items) are not added, since the metadata list is flat.
    334     if(metadataItem->type != PS_META_ITEM_SET) {
     319    // (PS_META_LIST metadata items) are not added, since the metadata list is flat.
     320    if(metadataItem->type != PS_META_LIST) {
    335321        if(!psListAdd(mdList, location, metadataItem)) {
    336             psError(PS_ERR_UNKNOWN,false,
    337                     PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,
    338                     key);
     322            psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,key);
    339323            return false;
    340324        }
    … …  
    344328}
    345329
    346 psBool psMetadataAdd(psMetadata* restrict md, psS32 where, const char *name, psMetadataType type,
    347                      const char *comment, ...)
     330psBool psMetadataAdd(psMetadata* restrict md, psS32 where, const char *name, psElemType pType,
     331                     psMetadataType type, const char *comment, ...)
    348332{
    349333    va_list argPtr;
    … …  
    351335
    352336    va_start(argPtr, comment);
    353     metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
     337    metadataItem = psMetadataItemAllocV(name, pType, type, comment, argPtr);
    354338    va_end(argPtr);
    355339
    356340    if (!psMetadataAddItem(md, metadataItem, where)) {
    357         psError(PS_ERR_UNKNOWN,false,
    358                 PS_ERRORTEXT_psMetadata_ADD_FAILED);
     341        psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_FAILED);
    359342        psFree(metadataItem);
    360343        return false;
    … …  
    368351psBool psMetadataRemove(psMetadata* restrict md, psS32 where, const char *restrict key)
    369352{
    370     psS32 numChildren = 0;
    371353    psList* mdList = NULL;
     354    psList* entryList = NULL;
    372355    psHash* mdTable = NULL;
    373356    psMetadataItem* entry = NULL;
    … …  
    386369
    387370        // Remove by key name
    388         entry = (psMetadataItem* ) psHashLookup(mdTable, key);
     371        entry = (psMetadataItem*)psHashLookup(mdTable, key);
    389372        if (entry == NULL) {
    390             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    391                     PS_ERRORTEXT_psMetadata_FIND_FAILED,
    392                     key);
     373            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_FAILED, key);
    393374            return false;
    394375        }
    395376
    396         numChildren = entry->items->size;
    397         if (entry->type == PS_META_ITEM_SET && numChildren > 0) {
     377        if (entry->type == PS_META_LIST) {
    398378
    399379            // Table entry has children. Entry and children must be removed from metadata collection's list
    400             psListSetIterator(entry->items, PS_LIST_HEAD);
    401             entryChild = psListGetCurrent(entry->items);
    402             while (entryChild != NULL) {
     380            psListSetIterator(entryList, PS_LIST_HEAD);
     381            entryChild = psListGetCurrent(entryList);
     382            while(entryChild != NULL) {
    403383                if (!psListRemove(mdList, PS_LIST_UNKNOWN, entryChild)) {
    404                     psError(PS_ERR_UNKNOWN,false,
    405                             PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED,
    406                             key);
     384                    psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED, key);
    407385                    return false;
    408386                }
    409                 entryChild = psListGetNext(entry->items);
     387                entryChild = psListGetNext(entryList);
    410388            }
    411389        } else {
    … …  
    413391            // Table entry has no children. Remove entry from metadata collection's list
    414392            if (!psListRemove(mdList, PS_LIST_UNKNOWN, entry)) {
    415                 psError(PS_ERR_UNKNOWN,false,
    416                         PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED,
    417                         key);
     393                psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED, key);
    418394                return false;
    419395            }
    … …  
    421397        // Remove entry from metadata collection's table
    422398        if (!psHashRemove(mdTable, key)) {
    423             psError(PS_ERR_UNKNOWN,false,
    424                     PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,
    425                     key);
     399            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
    426400            return false;
    427401        }
    … …  
    431405        entry = psListGet(mdList, where);
    432406        if (entry == NULL) {
    433             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    434                     PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED,
    435                     where);
     407            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, where);
    436408            return false;
    437409        }
    438410
    439411        key = entry->name;
    440         if (key == NULL) {
    441             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    442                     PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED,
    443                     where);
     412        if(key == NULL) {
     413            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED, where);
    444414            return false;
    445415        }
    … …  
    463433    mdTable = md->table;
    464434
    465     entry = (psMetadataItem* ) psHashLookup(mdTable, key);
     435    entry = (psMetadataItem*)psHashLookup(mdTable, key);
    466436    if (entry == NULL) {
    467437        return NULL;
    … …  
    478448    PS_PTR_CHECK_NULL(md->list,NULL);
    479449
    480     entry = (psMetadataItem* ) psListGet(md->list, where);
     450    entry = (psMetadataItem*) psListGet(md->list, where);
    481451    if (entry == NULL) {
    482         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    483                 PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED,
    484                 where);
     452        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, where);
    485453        return NULL;
    486454    }
Note: See TracChangeset for help on using the changeset viewer.