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

Location:
trunk/psLib/src/collections
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/collections/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    }

  • trunk/psLib/src/collections/psMetadata.h

    r2521 r2607  
    1111*  @author Ross Harman, MHPCC
    1212*
    13 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2004-11-30 00:27:14 $
     13*  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
     14*  @date $Date: 2004-12-03 23:14:34 $
    1515*
    1616*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3333 */
    3434typedef enum {
    35     PS_META_ITEM_SET = 0,              ///< Null. Metadata is in psMetadataItem.items
    36     PS_META_BOOL,                      ///< Boolean data.
    37     PS_META_S32,                       ///< Signed 32-bit integer data.
    38     PS_META_F32,                       ///< Single-precision float data.
    39     PS_META_F64,                       ///< Double-precision float data.
    40     PS_META_STR,                       ///< String data (Stored in as psPtr ).
    41     PS_META_VEC,                       ///< Vector data (Stored in as psPtr ).
    42     PS_META_HASH,                      ///< Hash data (Stored in as psPtr ).
    43     PS_META_IMG,                       ///< Image data (Stored in as psPtr ).
    44     PS_META_LOOKUPTABLE,               ///< Lookup table data (Stored as void *).
    45     PS_META_JPEG,                      ///< JPEG data (Stored in as psPtr ).
    46     PS_META_PNG,                       ///< PNG data (Stored in as psPtr ).
    47     PS_META_ASTROM,                    ///< Astrometric coefficients (Stored in as psPtr ).
    48     PS_META_UNKNOWN,                   ///< Other data (Stored in as psPtr ).
     35    PS_META_PRIMITIVE,                 ///< Primitive data.
     36    PS_META_LIST,                      ///< List data (Stored as item.data.list).
     37    PS_META_STR,                       ///< String data (Stored as item.data.V).
     38    PS_META_VEC,                       ///< Vector data (Stored as item.data.V).
     39    PS_META_IMG,                       ///< Image data (Stored as item.data.V).
     40    PS_META_HASH,                      ///< Hash data (Stored as item.data.V).
     41    PS_META_LOOKUPTABLE,               ///< Lookup table data (Stored as item.data.V).
     42    PS_META_JPEG,                      ///< JPEG data (Stored as item.data.V).
     43    PS_META_PNG,                       ///< PNG data (Stored as item.data.V).
     44    PS_META_ASTROM,                    ///< Astrometric coefficients (Stored as item.data.V).
     45    PS_META_UNKNOWN,                   ///< Other data (Stored as item.data.V).
    4946    PS_META_NTYPE                      ///< Number of types. Must be last.
    5047} psMetadataType;
    51 
    52 /** Metadata item data structure.
    53  *
    54  * Struct for maintaining metadata items of varying types. It also contains
    55  * information about the item name, flags, comments, and other items with the same name.
    56  */
    57 typedef struct psMetadataItem
    58 {
    59     const psS32 id;                      ///< Unique ID for metadata item.
    60     char *restrict name;               ///< Name of metadata item.
    61     psMetadataType type;               ///< Type of metadata item.
    62     union {
    63         psBool B;                        ///< boolean data
    64         psS32 S32;                     ///< Signed 32-bit integer data.
    65         psF32 F32;                     ///< Single-precision float data.
    66         psF64 F64;                     ///< Double-precision float data.
    67         psPtr V;                       ///< Pointer to other type of data.
    68     } data;                            ///< Union for data types.
    69     char *comment;                     ///< Optional comment ("", not NULL).
    70     psList* restrict items;            ///< List of psMetadataItems with same name.
    71 }
    72 psMetadataItem;
    7348
    7449/** Metadata data structure.
    … …  
    8560}
    8661psMetadata;
     62
     63/** Metadata item data structure.
     64 *
     65 * Struct for maintaining metadata items of varying types. It also contains
     66 * information about the item name, flags, comments, and other items with the same name.
     67 */
     68typedef struct psMetadataItem
     69{
     70    const psS32 id;                    ///< Unique ID for metadata item.
     71    char *name;                        ///< Name of metadata item.
     72    psMetadataType type;               ///< Type of metadata item.
     73    psElemType pType;                  ///< Primitive data type
     74    union {
     75        psBool B;                      ///< boolean data
     76        psS32 S32;                     ///< Signed 32-bit integer data.
     77        psF32 F32;                     ///< Single-precision float data.
     78        psF64 F64;                     ///< Double-precision float data.
     79        psList *list;                  ///< List data.
     80        psMetadata *md;                ///< Metadata data.
     81        psPtr V;                       ///< Pointer to other type of data.
     82    } data;                            ///< Union for data types.
     83    char *comment;                     ///< Optional comment ("", not NULL).
     84}
     85psMetadataItem;
    8786
    8887/** Create a metadata item.
    … …  
    103102psMetadataItem* psMetadataItemAlloc(
    104103    const char *name,                  ///< Name of metadata item.
     104    psElemType pType,                  ///< Primitive type.
    105105    psMetadataType type,               ///< Type of metadata item.
    106106    const char *comment,               ///< Comment for metadata item.
    … …  
    125125psMetadataItem* psMetadataItemAllocV(
    126126    const char *name,                  ///< Name of metadata item.
     127    psElemType pType,                  ///< Primitive type.
    127128    psMetadataType type,               ///< Type of metadata item.
    128129    const char *comment,               ///< Comment for metadata item.
    … …  
    149150    psMetadata* restrict md,           ///< Metadata collection to insert metadat item.
    150151    psMetadataItem* restrict item,     ///< Metadata item to be added.
    151     psS32 location                       ///< Location to be added.
     152    psS32 location                     ///< Location to be added.
    152153);
    153154
    … …  
    160161psBool psMetadataAdd(
    161162    psMetadata* restrict md,           ///< Metadata collection to insert metadat item.
    162     psS32 where,                         ///< Location to be added.
     163    psS32 where,                       ///< Location to be added.
    163164    const char *name,                  ///< Name of metadata item.
     165    psElemType pType,                  ///< Primitive type.
    164166    psMetadataType type,               ///< Type of metadata item.
    165167    const char *comment,               ///< Comment for metadata item.
    … …  
    179181psBool psMetadataRemove(
    180182    psMetadata* restrict md,           ///< Metadata collection to insert metadat item.
    181     psS32 where,                         ///< Location to be removed.
     183    psS32 where,                       ///< Location to be removed.
    182184    const char *restrict key           ///< Name of metadata key.
    183185);
    … …  
    205207psMetadataItem* psMetadataGet(
    206208    psMetadata* restrict md,           ///< Metadata collection to insert metadat item.
    207     psS32 where                          ///< Location to be retrieved.
     209    psS32 where                        ///< Location to be retrieved.
    208210);
    209211
    … …  
    217219psBool psMetadataSetIterator(
    218220    psMetadata* restrict md,           ///< Metadata collection to iterate.
    219     psS32 where                          ///< Location of iterator.
     221    psS32 where                        ///< Location of iterator.
    220222);
    221223
    … …  
    229231    psMetadata* restrict md,           ///< Metadata collection to iterate.
    230232    const char *restrict match,        ///< Beginning of key name.
    231     psS32 which                          ///< Iterator to be used.
     233    psS32 which                        ///< Iterator to be used.
    232234);
    233235
    … …  
    241243    psMetadata* restrict md,           ///< Metadata collection to iterate.
    242244    const char *restrict match,        ///< Beginning of key name.
    243     psS32 which                          ///< Iterator to be used.
     245    psS32 which                        ///< Iterator to be used.
    244246);
    245247

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

    r2525 r2607  
    99*  @author Ross Harman, MHPCC
    1010*
    11 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2004-11-30 01:09:14 $
     11*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2004-12-03 23:14:40 $
    1313*
    1414*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    6060/** Free and null temporary variables used by config file parser */
    6161#define CLEAR_TEMPS()                                                                                        \
    62 if(strName) {                                                                                            \
    63     psFree(strName);                                                                                     \
    64     strName = NULL;                                                                                      \
    65 }                                                                                                        \
    66 if(strType) {                                                                                            \
    67     psFree(strType);                                                                                     \
    68     strType = NULL;                                                                                      \
    69 }                                                                                                        \
    70 if(strValue) {                                                                                           \
    71     psFree(strValue);                                                                                    \
    72     strValue = NULL;                                                                                     \
    73 }                                                                                                        \
    74 if(strComment) {                                                                                         \
    75     psFree(strComment);                                                                                  \
    76     strComment = NULL;                                                                                   \
    77 }                                                                                                        \
    78 if(tempVec) {                                                                                            \
    79     psFree(tempVec);                                                                                     \
    80     tempVec = NULL;                                                                                      \
     62if(strName) {                                                                                                \
     63    psFree(strName);                                                                                         \
     64    strName = NULL;                                                                                          \
     65}                                                                                                            \
     66if(strType) {                                                                                                \
     67    psFree(strType);                                                                                         \
     68    strType = NULL;                                                                                          \
     69}                                                                                                            \
     70if(strValue) {                                                                                               \
     71    psFree(strValue);                                                                                        \
     72    strValue = NULL;                                                                                         \
     73}                                                                                                            \
     74if(strComment) {                                                                                             \
     75    psFree(strComment);                                                                                      \
     76    strComment = NULL;                                                                                       \
    8177}
    8278
    … …  
    316312{
    317313    psMetadataType type;
     314    psElemType pType;
    318315
    319316    PS_PTR_CHECK_NULL(fd,);
    … …  
    322319
    323320    type = metadataItem->type;
     321    pType = metadataItem->pType;
    324322
    325323    switch(type) {
    326     case PS_META_BOOL:
    327         fprintf(fd, format, metadataItem->data.B);
    328         break;
    329     case PS_META_S32:
    330         fprintf(fd,format, metadataItem->data.S32);
    331         break;
    332     case PS_META_F32:
    333         fprintf(fd, format, metadataItem->data.F32);
    334         break;
    335     case PS_META_F64:
    336         fprintf(fd, format, metadataItem->data.F64);
     324    case PS_META_PRIMITIVE:
     325        switch(pType) {
     326        case PS_TYPE_BOOL:
     327            fprintf(fd, format, metadataItem->data.B);
     328            break;
     329        case PS_TYPE_S32:
     330            fprintf(fd,format, metadataItem->data.S32);
     331            break;
     332        case PS_TYPE_F32:
     333            fprintf(fd, format, metadataItem->data.F32);
     334            break;
     335        case PS_TYPE_F64:
     336            fprintf(fd, format, metadataItem->data.F64);
     337            break;
     338        default:
     339            psError(PS_ERR_BAD_PARAMETER_TYPE,true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, (int)pType);
     340        }
    337341        break;
    338342    case PS_META_STR:
    339         fprintf(fd, format, metadataItem->data.V);
     343        fprintf(fd,format, metadataItem->data.V);
    340344        break;
    341345    default:
    … …  
    359363    psS32 numKeys = 0;
    360364    psS32 keyNum = 0;
    361     psMetadataType metadataItemType;
    362365    fitsfile *fd = NULL;
    363366
    … …  
    416419        switch (keyType) {
    417420        case 'I':
    418             metadataItemType = PS_META_S32;
    419             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atoi(keyValue));
     421            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_S32, PS_META_PRIMITIVE,
     422                                    keyComment, atoi(keyValue));
    420423            break;
    421424        case 'F':
    422             metadataItemType = PS_META_F64;
    423             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atof(keyValue));
     425            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_F64, PS_META_PRIMITIVE,
     426                                    keyComment, atof(keyValue));
    424427            break;
    425428        case 'C':
    426             metadataItemType = PS_META_STR;
    427             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue);
     429            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_PTR, PS_META_STR, keyComment,
     430                                    keyValue);
    428431            break;
    429432        case 'L':
    430             metadataItemType = PS_META_BOOL;
    431433            tempBool = (keyValue[0] == 'T') ? 1 : 0;
    432             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool);
     434            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_BOOL, PS_META_PRIMITIVE, keyComment,
     435                                    tempBool);
    433436            break;
    434437        case 'U':
    435438        case 'X':
    436439        default:
    437             psError(PS_ERR_IO, true,
    438                     PS_ERRORTEXT_psMetadataIO_FITS_METATYPE_INVALID,
    439                     keyType);
     440            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FITS_METATYPE_INVALID, keyType);
    440441            return output;
    441442        }
    442443
    443444        if (!success) {
    444             psError(PS_ERR_UNKNOWN, false,
    445                     PS_ERRORTEXT_psMetadataIO_ADD_FAILED,
    446                     keyName);
     445            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadataIO_ADD_FAILED, keyName);
    447446            return output;
    448447        }
    … …  
    452451}
    453452
    454 
    455 psS32 psMetadataParseConfig(psMetadata** md, const char *fileName, psBool overwrite)
     453psMetadata* psMetadataParseConfig(psMetadata* md, psU32 *nFail, const char *fileName, psBool overwrite)
    456454{
    457455    psBool tempBool;
    … …  
    463461    char *linePtr = NULL;
    464462    psS32 status = 0;
    465     psS32 lineCount = 0;
    466     psS32 failedLines = 0;
     463    psU32 lineCount = 0;
    467464    psF64 tempDbl = 0.0;
    468465    psS32 tempInt = 0.0;
    … …  
    470467    psVector *tempVec = NULL;
    471468    FILE *fp = NULL;
    472     psElemType elemType;
     469    psElemType pType;
    473470    psMetadataType mdType;
    474471
    475472
    476473    // Check for nulls
    477     PS_PTR_CHECK_NULL(fileName,-1);
     474    PS_PTR_CHECK_NULL(fileName,NULL);
    478475    if((fp=fopen(fileName, "r")) == NULL) {
    479         psError(PS_ERR_IO, true,
    480                 PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED,
    481                 fileName);
    482         return -1;
     476        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED, fileName);
     477        return NULL;
    483478    }
    484479
    485480    // Allocate metadata if necessary
    486     if (*md == NULL) {
    487         *md = psMetadataAlloc();
     481    if (md == NULL) {
     482        md = psMetadataAlloc();
    488483    }
    489484
    … …  
    504499            // Check for more than one '*' or '@' in a line
    505500            if(repeatedChars(linePtr, '@') > 1) {
    506                 failedLines++;
     501                (*nFail)++;
    507502                psError(PS_ERR_IO, true,
    508                         PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR,
    509                         '@', lineCount, fileName);
     503                        PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '@', lineCount, fileName);
    510504                continue;
    511505            } else if(repeatedChars(linePtr, '*') > 1) {
    512                 failedLines++;
     506                (*nFail)++;
    513507                psError(PS_ERR_IO, true,
    514                         PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR,
    515                         '*', lineCount, fileName);
     508                        PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '*', lineCount, fileName);
    516509                continue;
    517510            } else if(repeatedChars(linePtr, '~') > 0) {
    518                 failedLines++;
     511                (*nFail)++;
    519512                psError(PS_ERR_IO, true,
    520                         PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR,
    521                         '~', lineCount, fileName);
     513                        PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '~', lineCount, fileName);
    522514                continue;
    523515            }
    … …  
    526518            strName = getToken(&linePtr, " ", &status);
    527519            if(strName==NULL || status) {
    528                 failedLines++;
     520                (*nFail)++;
    529521                status = 0;
    530522                psError(PS_ERR_IO, true,
    531                         PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    532                         "name",lineCount, fileName);
     523                        PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "name", lineCount, fileName);
    533524                continue;
    534525            }
    … …  
    537528            strType = getToken(&linePtr, " ", &status);
    538529            if(strType==NULL) {
    539                 failedLines++;
     530                (*nFail)++;
    540531                status = 0;
    541                 psError(PS_ERR_IO, true,
    542                         PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    543                         "type",lineCount, fileName);
     532                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "type",lineCount,
     533                        fileName);
    544534                continue;
    545535            } else if(!strncmp(strType, "*", 1)) {
    546                 mdType = PS_META_ITEM_SET;
     536                mdType = PS_META_LIST;
     537                pType = PS_TYPE_PTR;
    547538            } else if(!strncmp(strType, "STR", 3)) {
    548539                mdType = PS_META_STR;
    549                 elemType = PS_TYPE_PTR;
     540                pType = PS_TYPE_PTR;
    550541            } else if(!strncmp(strType, "BOOL", 3)) {
    551                 mdType = PS_META_BOOL;
    552                 elemType = PS_TYPE_U8;
     542                mdType = PS_META_PRIMITIVE;
     543                pType = PS_TYPE_BOOL;
    553544            } else if(!strncmp(strType, "S32", 3)) {
    554                 mdType = PS_META_S32;
    555                 elemType = PS_TYPE_S32;
     545                mdType = PS_META_PRIMITIVE;
     546                pType = PS_TYPE_S32;
    556547            } else if(!strncmp(strType, "F32", 3)) {
    557                 mdType = PS_META_F32;
    558                 elemType = PS_TYPE_F32;
     548                mdType = PS_META_PRIMITIVE;
     549                pType = PS_TYPE_F32;
    559550            } else if(!strncmp(strType, "F64", 3)) {
    560                 mdType = PS_META_F64;
    561                 elemType = PS_TYPE_F64;
     551                mdType = PS_META_PRIMITIVE;
     552                pType = PS_TYPE_F64;
    562553            } else {
    563                 failedLines++;
    564                 psError(PS_ERR_IO, true,
    565                         PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
    566                         strType, lineCount, fileName);
     554                (*nFail)++;
     555                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, strType, lineCount,
     556                        fileName);
    567557                continue;
    568558            }
    … …  
    573563
    574564            // Get the metadata item value if there is one. Lines with * don't have values.
    575             if(mdType != PS_META_ITEM_SET) {
     565            if(mdType != PS_META_LIST) {
    576566                strValue = getToken(&linePtr, "#", &status);
    577567                if(strValue==NULL) {
    578                     failedLines++;
     568                    (*nFail)++;
    579569                    status = 0;
    580                     psError(PS_ERR_IO, true,
    581                             PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    582                             "value",lineCount, fileName);
     570                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "value", lineCount,
     571                            fileName);
    583572                    continue;
    584573                }
    … …  
    588577            strComment = getToken(&linePtr,"~", &status);
    589578            if(status) {
    590                 failedLines++;
     579                (*nFail)++;
    591580                status = 0;
    592                 psError(PS_ERR_IO, true,
    593                         PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    594                         "comment",lineCount, fileName);
     581                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "comment", lineCount,
     582                        fileName);
    595583                continue;
    596584            }
    … …  
    599587            and allow switch/case below to add new item. If overwrite is false, then report error. If found
    600588            item is folder node, then psMetadataAdd will automatically add a new child. */
    601             metadataItem = psMetadataLookup(*md, strName);
     589            metadataItem = psMetadataLookup(md, strName);
    602590            if(metadataItem != NULL) {
    603                 if(metadataItem->type!=PS_META_ITEM_SET) {
     591                if(metadataItem->type!=PS_META_LIST) {
    604592                    if(overwrite) {
    605                         psMetadataRemove(*md, PS_LIST_UNKNOWN, strName);
     593                        psMetadataRemove(md, PS_LIST_UNKNOWN, strName);
    606594                    } else {
    607                         failedLines++;
    608                         psError(PS_ERR_IO, true,
    609                                 PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM,
    610                                 strName, lineCount, fileName);
     595                        (*nFail)++;
     596                        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM, strName, lineCount,
     597                                fileName);
    611598                        continue;
    612599                    }
    … …  
    616603            // Create and add metadata item to metadata and parse values
    617604            switch (mdType) {
    618             case PS_META_ITEM_SET:
    619                 psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, NULL, NULL);
     605            case PS_META_LIST:
     606                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, NULL);
    620607                break;
    621             case PS_META_BOOL:
    622                 tempBool = parseBool(strValue, &status);
     608            case PS_META_STR:
     609                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, strValue);
     610                break;
     611            case PS_META_VEC:
     612                tempVec = parseVector(strValue, pType, &status);
    623613                if(!status) {
    624                     psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, tempBool);
     614                    psMetadataAdd(md, PS_LIST_TAIL, strName+1, pType, mdType, strComment, tempVec);
    625615                } else {
    626616                    status = 0;
    627                     failedLines++;
    628                     psError(PS_ERR_IO, true,
    629                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    630                             strValue, strName, strType, lineCount, fileName);
     617                    (*nFail)++;
     618                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     619                            strType, lineCount, fileName);
    631620                    continue;
    632621                }
    633622                break;
    634             case PS_META_S32:
    635                 tempInt = (psS32)parseValue(strValue, &status);
    636                 if(!status) {
    637                     psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, tempInt);
    638                 } else {
    639                     status = 0;
    640                     failedLines++;
    641                     psError(PS_ERR_IO, true,
    642                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    643                             strValue, strName, strType, lineCount, fileName);
     623            case PS_META_PRIMITIVE:
     624                switch (pType) {
     625                case PS_TYPE_BOOL:
     626                    tempBool = parseBool(strValue, &status);
     627                    if(!status) {
     628                        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, tempBool);
     629                    } else {
     630                        status = 0;
     631                        (*nFail)++;
     632                        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     633                                strType, lineCount, fileName);
     634                        continue;
     635                    }
     636                    break;
     637                case PS_TYPE_S32:
     638                    tempInt = (psS32)parseValue(strValue, &status);
     639                    if(!status) {
     640                        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, tempInt);
     641                    } else {
     642                        status = 0;
     643                        (*nFail)++;
     644                        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     645                                strType, lineCount, fileName);
     646                        continue;
     647                    }
     648                    break;
     649                case PS_TYPE_F32:
     650                case PS_TYPE_F64:
     651                    tempDbl = parseValue(strValue, &status);
     652                    if(!status) {
     653                        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, tempDbl);
     654                    } else {
     655                        status = 0;
     656                        (*nFail)++;
     657                        psError(PS_ERR_IO, true,
     658                                PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType, lineCount,
     659                                fileName);
     660                        continue;
     661                    }
     662                    break;
     663                default:
     664                    (*nFail)++;
     665                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, mdType, lineCount,
     666                            fileName);
    644667                    continue;
    645                 }
    646                 break;
    647             case PS_META_F32:
    648             case PS_META_F64:
    649                 tempDbl = parseValue(strValue, &status);
    650                 if(!status) {
    651                     psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, tempDbl);
    652                 } else {
    653                     status = 0;
    654                     failedLines++;
    655                     psError(PS_ERR_IO, true,
    656                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    657                             strValue, strName, strType, lineCount, fileName);
    658                     continue;
    659                 }
    660                 break;
    661             case PS_META_STR:
    662                 psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, strValue);
    663                 break;
    664             case PS_META_VEC:
    665                 tempVec = parseVector(strValue, elemType, &status);
    666                 if(!status) {
    667                     psMetadataAdd(*md, PS_LIST_TAIL, strName+1, mdType, strComment, tempVec);
    668                 } else {
    669                     status = 0;
    670                     failedLines++;
    671                     psError(PS_ERR_IO, true,
    672                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    673                             strValue, strName, strType, lineCount, fileName);
    674                     continue;
    675                 }
     668                } // switch
    676669                break;
    677670            default:
    678                 failedLines++;
    679                 psError(PS_ERR_IO, true,
    680                         PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
    681                         mdType, lineCount, fileName);
     671                (*nFail)++;
     672                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, mdType, lineCount,
     673                        fileName);
    682674                continue;
    683675            } // switch
    … …  
    687679    psFree(line);
    688680
    689     return failedLines;
     681    return md;
    690682}
    691683
    … …  
    753745
    754746    // Add attributes to metadata
    755     psMetadataAdd(md, PS_LIST_TAIL, "htAtts", PS_META_HASH, NULL, htAtts);
     747    psMetadataAdd(md, PS_LIST_TAIL, "htAtts", PS_TYPE_PTR, PS_META_HASH, NULL, htAtts);
    756748
    757749    psFree(psTagName);
    … …  
    765757    psBool tempBool = false;
    766758    psS32 status = 0;
    767     psU64 lineNumber = 0;
     759    psU32 lineNumber = 0;
    768760    psF64 tempDbl = 0.0;
    769761    psS32 tempInt = 0.0;
    770     psElemType elemType;
     762    psElemType pType;
    771763    psMetadataType mdType;
    772764    char *fileName = NULL;
    … …  
    790782    metadataItem = psMetadataLookup(md, "htAtts");
    791783    PS_PTR_CHECK_NULL_GENERAL(metadataItem, return);
    792     PS_PTR_CHECK_NULL_GENERAL(metadataItem->items, return);
    793     psListSetIterator(metadataItem->items, PS_LIST_TAIL);
    794     metadataItem = (psMetadataItem*)psListGetCurrent(metadataItem->items);
    795     htAtts = (psHash*)metadataItem->data.V;
     784    PS_PTR_CHECK_NULL_GENERAL(metadataItem->data.list, return);
     785    psListSetIterator(metadataItem->data.list, PS_LIST_TAIL);
     786    metadataItem = (psMetadataItem*)psListGetCurrent(metadataItem->data.list);
     787    htAtts = (psHash*)metadataItem->data.list;
    796788    PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
    797789    fileName = (char*)input->filename;
    … …  
    811803        if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psString")) {
    812804            mdType = PS_META_STR;
    813             elemType = PS_TYPE_PTR;
     805            pType = PS_TYPE_PTR;
    814806        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psBool")) {
    815             mdType = PS_META_BOOL;
    816             elemType = PS_TYPE_U8;
     807            mdType = PS_META_PRIMITIVE;
     808            pType = PS_TYPE_U8;
    817809        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psS32")) {
    818             mdType = PS_META_S32;
    819             elemType = PS_TYPE_S32;
     810            mdType = PS_META_PRIMITIVE;
     811            pType = PS_TYPE_S32;
    820812        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF32")) {
    821             mdType = PS_META_F32;
    822             elemType = PS_TYPE_F32;
     813            mdType = PS_META_PRIMITIVE;
     814            pType = PS_TYPE_F32;
    823815        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF64")) {
    824             mdType = PS_META_F64;
    825             elemType = PS_TYPE_F64;
     816            mdType = PS_META_PRIMITIVE;
     817            pType = PS_TYPE_F64;
    826818        } else {
    827819            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TYPE_INVALID_LINE_FILE, strType, lineNumber,
    … …  
    847839        metadataItem = psMetadataLookup(md, strName);
    848840        if(metadataItem != NULL) {
    849             if(metadataItem->type != PS_META_ITEM_SET) {
     841            if(metadataItem->type != PS_META_LIST) {
    850842                if(overwrite) {
    851843                    psMetadataRemove(md, PS_LIST_UNKNOWN, strName);
    … …  
    861853    // Create metadata item and add to metadata
    862854    switch(mdType) {
    863     case PS_META_ITEM_SET:
    864         psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, NULL);
    865         break;
    866     case PS_META_BOOL:
    867         tempBool = parseBool((char*)strValue, &status);
    868         if(!status) {
    869             psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempBool);
    870         } else {
    871             status = 0;
    872             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    873                     lineNumber, fileName);
    874         }
    875         break;
    876     case PS_META_S32:
    877         tempInt = (psS32)parseValue((char*)strValue, &status);
    878         if(!status) {
    879             psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempInt);
    880         } else {
    881             status = 0;
    882             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    883                     lineNumber, fileName);
    884         }
    885         break;
    886     case PS_META_F32:
    887     case PS_META_F64:
    888         tempDbl = parseValue((char*)strValue, &status);
    889         if(!status) {
    890             psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempDbl);
    891         } else {
    892             status = 0;
    893             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    894                     lineNumber, fileName);
    895         }
     855    case PS_META_LIST:
     856        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, NULL);
    896857        break;
    897858    case PS_META_STR:
    898         psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, strValue);
     859        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, strValue);
     860        break;
     861    case PS_META_PRIMITIVE:
     862        switch(pType) {
     863        case PS_TYPE_BOOL:
     864            tempBool = parseBool((char*)strValue, &status);
     865            if(!status) {
     866                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempBool);
     867            } else {
     868                status = 0;
     869                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     870                        lineNumber, fileName);
     871            }
     872            break;
     873        case PS_TYPE_S32:
     874            tempInt = (psS32)parseValue((char*)strValue, &status);
     875            if(!status) {
     876                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempInt);
     877            } else {
     878                status = 0;
     879                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     880                        lineNumber, fileName);
     881            }
     882            break;
     883        case PS_TYPE_F32:
     884        case PS_TYPE_F64:
     885            tempDbl = parseValue((char*)strValue, &status);
     886            if(!status) {
     887                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempDbl);
     888            } else {
     889                status = 0;
     890                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     891                        lineNumber, fileName);
     892            }
     893            break;
     894        default:
     895            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, strType, lineNumber, fileName);
     896        } // End switch
    899897        break;
    900898    default:
    … …  
    902900    } // End switch
    903901
     902
    904903    return;
    905904}
    … …  
    910909    bool overwrite = false;
    911910    psS32 status = 0;
    912     psU64 lineNumber = 0;
    913     psElemType elemType;
     911    psU32 lineNumber = 0;
     912    psElemType pType;
    914913    psMetadataType mdType;
    915914    char *strName = NULL;
    … …  
    936935    tables = psMetadataLookup(md, "htAtts");
    937936    PS_PTR_CHECK_NULL_GENERAL(tables, return);
    938     PS_PTR_CHECK_NULL_GENERAL(tables->items, return);
    939     psListSetIterator(tables->items, PS_LIST_TAIL);
    940     table = (psMetadataItem*)psListGetCurrent(tables->items);
    941     htAtts = (psHash*)table->data.V;
     937    PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     938    psListSetIterator(tables->data.list, PS_LIST_TAIL);
     939    table = (psMetadataItem*)psListGetCurrent(tables->data.list);
     940    htAtts = (psHash*)table->data.list;
    942941    PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
    943942    fileName = (char*)input->filename;
    … …  
    957956        if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psString")) {
    958957            mdType = PS_META_STR;
    959             elemType = PS_TYPE_PTR;
     958            pType = PS_TYPE_PTR;
    960959        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psBool")) {
    961             mdType = PS_META_BOOL;
    962             elemType = PS_TYPE_U8;
     960            mdType = PS_META_PRIMITIVE;
     961            pType = PS_TYPE_U8;
    963962        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psS32")) {
    964             mdType = PS_META_S32;
    965             elemType = PS_TYPE_S32;
     963            mdType = PS_META_PRIMITIVE;
     964            pType = PS_TYPE_S32;
    966965        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF32")) {
    967             mdType = PS_META_F32;
    968             elemType = PS_TYPE_F32;
     966            mdType = PS_META_PRIMITIVE;
     967            pType = PS_TYPE_F32;
    969968        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF64")) {
    970             mdType = PS_META_F64;
    971             elemType = PS_TYPE_F64;
     969            mdType = PS_META_PRIMITIVE;
     970            pType = PS_TYPE_F64;
    972971        } else {
    973972            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TYPE_INVALID_LINE_FILE, strName, lineNumber,
    … …  
    994993        metadataItem = psMetadataLookup(md, strName);
    995994        if(metadataItem != NULL) {
    996             if(metadataItem->type != PS_META_ITEM_SET) {
     995            if(metadataItem->type != PS_META_LIST) {
    997996                if(overwrite) {
    998997                    psMetadataRemove(md, PS_LIST_UNKNOWN, strName);
    … …  
    10071006
    10081007    // Get value
    1009     vec = parseVector((char*)strValue, elemType, &status);
     1008    vec = parseVector((char*)strValue, pType, &status);
    10101009    if(!status) {
    1011         psMetadataAdd(md, PS_LIST_TAIL, strName+1, mdType, NULL, vec);
     1010        psMetadataAdd(md, PS_LIST_TAIL, strName+1, pType, mdType, NULL, vec);
    10121011    } else {
    10131012        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    … …  
    10381037    tables = psMetadataLookup(md, "htAtts");
    10391038    PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1040     PS_PTR_CHECK_NULL_GENERAL(tables->items, return);
    1041     psListSetIterator(tables->items, PS_LIST_TAIL);
    1042     table = (psMetadataItem*)psListGetCurrent(tables->items);
    1043     htAtts = (psHash*)table->data.V;
     1039    PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1040    psListSetIterator(tables->data.list, PS_LIST_TAIL);
     1041    table = (psMetadataItem*)psListGetCurrent(tables->data.list);
     1042    htAtts = (psHash*)table->data.list;
    10441043    PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
    10451044
    … …  
    10641063
    10651064    // Free temporary metadata item and its hash table
    1066     psListRemove(tables->items, PS_LIST_TAIL, table);
     1065    psListRemove(tables->data.list, PS_LIST_TAIL, table);
    10671066
    10681067    psFree(psEndTagName);
    … …  
    10711070}
    10721071
    1073 psS32 psMetadataParseConfigXml(psMetadata** md, const char *fileName)
     1072psMetadata*  psMetadataParseConfigXml(psMetadata* md, psU32 *nFail, const char *fileName, psBool overwrite)
    10741073{
    10751074    xmlSAXHandler saxHandler;
    … …  
    10771076
    10781077    // Error checks
    1079     PS_PTR_CHECK_NULL(fileName,-1);
     1078    PS_PTR_CHECK_NULL(fileName, NULL);
    10801079
    10811080    // Allocate metadata if necessary
    1082     if (*md == NULL) {
    1083         *md = psMetadataAlloc();
     1081    if (md == NULL) {
     1082        md = psMetadataAlloc();
    10841083    }
    10851084
    … …  
    11131112    saxHandler.externalSubset           = NULL;
    11141113    saxHandler.initialized              = 1;
    1115     saxHandler._private                 = *md;
     1114    saxHandler._private                 = md;
    11161115    saxHandler.startElementNs           = NULL;
    11171116    saxHandler.endElementNs             = NULL;
    … …  
    11211120    if (xmlSAXUserParseFile(&saxHandler, NULL, fileName)) {
    11221121        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED, fileName);
    1123         return -1;
     1122        return NULL;
    11241123    }
    11251124

  • trunk/psLib/src/collections/psMetadataIO.h

    r2529 r2607  
    99*  @author Ross Harman, MHPCC
    1010*
    11 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2004-11-30 01:24:32 $
     11*  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2004-12-03 23:14:46 $
    1313*
    1414*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5858 *  Loads pre-defined settings by parsing a configuration file into a psMetadata structure.
    5959 *
    60  *  @return psS32 : Number of lines that failed to be read.
     60 *  @return psMetadata* : Resulting metadata from read.
    6161 */
    62 psS32 psMetadataParseConfig(
    63     psMetadata** md,                   ///< Resulting metadata from read.
     62psMetadata* psMetadataParseConfig(
     63    psMetadata* md,                    ///< Resulting metadata from read.
     64    psU32 *nFail,                      ///< Number of failed lines.
    6465    const char *fileName,              ///< Name of file to read.
    6566    psBool overwrite                   ///< Allow overwrite of duplicate specifications.
    … …  
    7071 *  Loads pre-defined XML settings by parsing a configuration file into a psMetadata structure.
    7172 *
    72  *  @return psS32 : Number of lines that failed to be read.
     73 *  @return psMetadata* : Resulting metadata from read.
    7374 */
    74 psS32 psMetadataParseConfigXml(
    75     psMetadata** md,                   ///< Resulting metadata from read.
    76     const char *fileName               ///< Name of file to read.
     75
     76psMetadata*  psMetadataParseConfigXml(
     77    psMetadata* md,                    ///< Resulting metadata from read.
     78    psU32 *nFail,                      ///< Number of failed lines.
     79    const char *fileName,              ///< Name of file to read.
     80    psBool overwrite                   ///< Allow overwrite of duplicate specifications.
    7781);
    7882
Note: See TracChangeset for help on using the changeset viewer.