IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 28, 2005, 1:34:10 PM (21 years ago)
Author:
desonia
Message:

Changes to psMetadata to match latest SDRS.

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

Legend:

Unmodified
Added
Removed

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

    r3286 r3341  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-02-18 22:17:20 $
     14*  @version $Revision: 1.53 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-02-28 23:34:10 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    8080    psFree(metadataItem->name);
    8181    psFree(metadataItem->comment);
    82     if (type != PS_META_PRIMITIVE) {
     82    if (! PS_META_IS_PRIMITIVE(type)) {
    8383        psFree(metadataItem->data.V);
    8484    }
    … …  
    9898/*****************************************************************************/
    9999
    100 psMetadataItem* psMetadataItemAlloc(const char *name, psElemType pType, psMetadataType type,
     100psMetadataItem* psMetadataItemAlloc(const char *name, psMetadataType type,
    101101                                    const char *comment, ...)
    102102{
    … …  
    108108
    109109    // Call metadata item allocation
    110     metadataItem = psMetadataItemAllocV(name, pType, type, comment, argPtr);
     110    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
    111111
    112112    // Clean up stack after variable arguement has been used
    … …  
    116116}
    117117
    118 psMetadataItem* psMetadataItemAllocV(const char *name, psElemType pType, psMetadataType type,
     118#define METADATAITEM_ALLOC_TYPE(NAME,TYPE,METATYPE) \
     119psMetadataItem* psMetadataItemAlloc##NAME(const char* name, \
     120        const char* comment, \
     121        TYPE value) \
     122{ \
     123    return psMetadataItemAlloc(name, METATYPE, comment, value); \
     124}
     125
     126METADATAITEM_ALLOC_TYPE(Str,const char*,PS_META_STR)
     127METADATAITEM_ALLOC_TYPE(F32,psF32,PS_META_F32)
     128METADATAITEM_ALLOC_TYPE(F64,psF64,PS_META_F64)
     129METADATAITEM_ALLOC_TYPE(S32,psS32,PS_META_S32)
     130METADATAITEM_ALLOC_TYPE(Bool,psBool,PS_META_BOOL)
     131
     132psMetadataItem* psMetadataItemAllocV(const char *name, psMetadataType type,
    119133                                     const char *comment, va_list argPtr)
    120134{
    … …  
    145159    // Set metadata item type
    146160    metadataItem->type = type;
    147     metadataItem->pType = pType;
    148161
    149162    // Allocate and set metadata item name
    … …  
    153166    // Set metadata item value
    154167    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         }
     168    case PS_META_BOOL:
     169        metadataItem->data.B = (psBool)va_arg(argPtr, psS32);
     170        break;
     171    case PS_META_S32:
     172        metadataItem->data.S32 = (psS32)va_arg(argPtr, psS32);
     173        break;
     174    case PS_META_F32:
     175        metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64);
     176        break;
     177    case PS_META_F64:
     178        metadataItem->data.F64 = (psF64)va_arg(argPtr, psF64);
    174179        break;
    175180    case PS_META_STR:
    … …  
    186191    case PS_META_UNKNOWN:
    187192        // Copy of input data not performed due to variability of data types
    188         metadataItem->data.V = va_arg(argPtr, psPtr);
     193        metadataItem->data.V = psMemIncrRefCounter(va_arg(argPtr, psPtr));
    189194        break;
    190195    default:
    … …  
    256261
    257262            // Leaf node replaces another leaf. Make new folder node and add leaves.
    258             newFolderEntry = psMetadataItemAlloc(key, PS_TYPE_PTR, PS_META_LIST, NULL, NULL);
     263            newFolderEntry = psMetadataItemAlloc(key, PS_META_LIST, NULL, NULL);
    259264            newFolderEntry->data.list = psListAlloc(NULL);
    260265
    … …  
    328333}
    329334
    330 psBool psMetadataAdd(psMetadata *md, psS32 where, const char *name, psElemType pType,
     335psBool psMetadataAdd(psMetadata *md, psS32 where, const char *name,
    331336                     psMetadataType type, const char *comment, ...)
    332337{
    … …  
    335340
    336341    va_start(argPtr, comment);
    337     metadataItem = psMetadataItemAllocV(name, pType, type, comment, argPtr);
     342    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
    338343    va_end(argPtr);
    339344
    … …  
    348353    return true;
    349354}
     355
     356#define METADATA_ADD_TYPE(NAME,TYPE,METATYPE) \
     357psBool psMetadataAdd##NAME(psMetadata* md, psS32 where, const char* name, \
     358                           const char* comment, TYPE value) { \
     359    return psMetadataAdd(md,where,name, METATYPE,comment,value); \
     360}
     361
     362METADATA_ADD_TYPE(S32,psS32,PS_META_S32)
     363METADATA_ADD_TYPE(F32,psF32,PS_META_F32)
     364METADATA_ADD_TYPE(F64,psF64,PS_META_F64)
     365METADATA_ADD_TYPE(List,psList*,PS_META_LIST)
     366METADATA_ADD_TYPE(Str,const char*,PS_META_STR)
     367METADATA_ADD_TYPE(Vector,psVector*,PS_META_VEC)
     368METADATA_ADD_TYPE(Image,psImage*,PS_META_IMG)
     369METADATA_ADD_TYPE(Hash,psHash*,PS_META_HASH)
     370METADATA_ADD_TYPE(LookupTable,psLookupTable*,PS_META_LOOKUPTABLE)
     371METADATA_ADD_TYPE(Unknown,void*,PS_META_UNKNOWN)
    350372
    351373psBool psMetadataRemove(psMetadata *md, psS32 where, const char *key)
    … …  
    435457    }
    436458
    437     if(metadataItem->type == PS_META_PRIMITIVE && metadataItem->pType != PS_TYPE_PTR) {
     459    if(PS_META_IS_PRIMITIVE(metadataItem->type)) {
    438460        if (status) {
    439461            *status = false;
    440462        }
    441463        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    442                 PS_ERRORTEXT_psMetadata_METATYPE_MISMATCH,
    443                 metadataItem->pType,
    444                 PS_TYPE_PTR);
     464                PS_ERRORTEXT_psMetadata_METATYPE_INVALID,
     465                metadataItem->type);
    445466        return NULL;
    446467    } else {
    … …  
    467488    } \
    468489    \
    469     if (metadataItem->type == PS_META_PRIMITIVE) { \
    470         switch (metadataItem->pType) { \
    471         case PS_TYPE_S32: \
    472             value = (ps##TYPE)metadataItem->data.S32; \
    473             break; \
    474         case PS_TYPE_F32: \
    475             value = (ps##TYPE)metadataItem->data.F32; \
    476             break; \
    477         case PS_TYPE_F64: \
    478             value = (ps##TYPE)metadataItem->data.F64; \
    479             break; \
    480         case PS_TYPE_BOOL: \
    481             if (metadataItem->data.B) { \
    482                 value = 1; \
    483             } \
    484             break; \
    485         default: \
    486             /* if you get to this point, the value is not a number. */ \
    487             if (status) { \
    488                 *status = false; \
    489             } \
    490             break; \
     490    switch (metadataItem->type) { \
     491    case PS_META_S32: \
     492        value = (ps##TYPE)metadataItem->data.S32; \
     493        break; \
     494    case PS_META_F32: \
     495        value = (ps##TYPE)metadataItem->data.F32; \
     496        break; \
     497    case PS_META_F64: \
     498        value = (ps##TYPE)metadataItem->data.F64; \
     499        break; \
     500    case PS_META_BOOL: \
     501        if (metadataItem->data.B) { \
     502            value = 1; \
    491503        } \
    492     } else { \
     504        break; \
     505    default: \
     506        /* if you get to this point, the value is not a number. */ \
    493507        if (status) { \
    494508            *status = false; \
    495509        } \
     510        break; \
    496511    } \
    497512    \

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

    r3264 r3341  
    1111*  @author Ross Harman, MHPCC
    1212*
    13 *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2005-02-17 19:26:23 $
     13*  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     14*  @date $Date: 2005-02-28 23:34:10 $
    1515*
    1616*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include "psHash.h"
    2525#include "psList.h"
     26#include "psImage.h"
     27#include "psLookupTable.h"
    2628
    2729/// @addtogroup Metadata
    … …  
    3335 */
    3436typedef enum {
    35     PS_META_PRIMITIVE,                 ///< Primitive data.
     37    PS_META_S32,                       ///< Primitive data.
     38    PS_META_F32,                       ///< Primitive data.
     39    PS_META_F64,                       ///< Primitive data.
     40    PS_META_BOOL,                       ///< Primitive data.
    3641    PS_META_LIST,                      ///< List data (Stored as item.data.list).
    3742    PS_META_STR,                       ///< String data (Stored as item.data.V).
    … …  
    4752} psMetadataType;
    4853
     54#define PS_META_IS_PRIMITIVE(TYPE) \
     55(TYPE == PS_META_S32 || \
     56 TYPE == PS_META_F32 || \
     57 TYPE == PS_META_F64 || \
     58 TYPE == PS_META_BOOL)
     59
     60#define PS_META_PRIMITIVE_TYPE(METATYPE) ( \
     61        (METATYPE==PS_META_S32) ? PS_TYPE_S32 : \
     62        (METATYPE==PS_META_F32) ? PS_TYPE_F32 : \
     63        (METATYPE==PS_META_F64) ? PS_TYPE_F64 : \
     64        (METATYPE==PS_META_BOOL) ? PS_TYPE_BOOL : PS_TYPE_PTR )
     65
    4966/** Option flags for psMetadata functions
    5067 *
    … …  
    5572typedef enum {
    5673    PS_META_DEFAULT = 0,               ///< default behaviour (duplicate entry is an error)
    57     PS_META_REPLACE                    ///< allow entry to be replaced
     74    PS_META_REPLACE = 0x10000          ///< allow entry to be replaced
    5875} psMetadataFlags;
    5976
    … …  
    8299    char *name;                        ///< Name of metadata item.
    83100    psMetadataType type;               ///< Type of metadata item.
    84     psElemType pType;                  ///< Primitive data type
    85101    union {
    86102        psBool B;                      ///< boolean data
    … …  
    113129psMetadataItem* psMetadataItemAlloc(
    114130    const char *name,                  ///< Name of metadata item.
    115     psElemType pType,                  ///< Primitive type.
    116131    psMetadataType type,               ///< Type of metadata item.
    117132    const char *comment,               ///< Comment for metadata item.
    118133    ...                                ///< Arguments for name formatting and metadata item data.
     134);
     135
     136psMetadataItem* psMetadataItemAllocStr(
     137    const char* name,
     138    const char* comment,
     139    const char* value
     140);
     141
     142psMetadataItem* psMetadataItemAllocF32(
     143    const char* name,
     144    const char* comment,
     145    psF32 value
     146);
     147
     148psMetadataItem* psMetadataItemAllocF64(
     149    const char* name,
     150    const char* comment,
     151    psF64 value
     152);
     153
     154psMetadataItem* psMetadataItemAllocS32(
     155    const char* name,
     156    const char* comment,
     157    psS32 value
     158);
     159
     160psMetadataItem* psMetadataItemAllocBool(
     161    const char* name,
     162    const char* comment,
     163    psBool value
    119164);
    120165
    … …  
    137182psMetadataItem* psMetadataItemAllocV(
    138183    const char *name,                  ///< Name of metadata item.
    139     psElemType pType,                  ///< Primitive type.
    140184    psMetadataType type,               ///< Type of metadata item.
    141185    const char *comment,               ///< Comment for metadata item.
    … …  
    161205 */
    162206psBool psMetadataAddItem(
    163     psMetadata*  md,          ///< Metadata collection to insert metadat item.
    164     psMetadataItem*  item,    ///< Metadata item to be added.
    165     psS32 location            ///< Location to be added.
     207    psMetadata*  md,                   ///< Metadata collection to insert metadat item.
     208    psMetadataItem*  item,             ///< Metadata item to be added.
     209    psS32 location                     ///< Location to be added.
    166210);
    167211
    … …  
    173217 */
    174218psBool psMetadataAdd(
    175     psMetadata* md,           ///< Metadata collection to insert metadat item.
    176     psS32 where,              ///< Location to be added.
    177     const char *name,         ///< Name of metadata item.
    178     psElemType pType,         ///< Primitive type.
    179     psMetadataType type,      ///< Type of metadata item.
    180     const char *comment,      ///< Comment for metadata item.
    181     ...                       ///< Arguments for name formatting and metadata item data.
    182 );
     219    psMetadata* md,                    ///< Metadata collection to insert metadat item.
     220    psS32 where,                       ///< Location to be added.
     221    const char *name,                  ///< Name of metadata item.
     222    psMetadataType type,               ///< Type of metadata item.
     223    const char *comment,               ///< Comment for metadata item.
     224    ...                                ///< Arguments for name formatting and metadata item data.
     225);
     226
     227psBool psMetadataAddS32(psMetadata* md, psS32 where, const char* name,
     228                        const char* comment, psS32 value);
     229psBool psMetadataAddF32(psMetadata* md, psS32 where, const char* name,
     230                        const char* comment, psF32 value);
     231psBool psMetadataAddF64(psMetadata* md, psS32 where, const char* name,
     232                        const char* comment, psF64 value);
     233psBool psMetadataAddList(psMetadata* md, psS32 where, const char* name,
     234                         const char* comment, psList* value);
     235psBool psMetadataAddStr(psMetadata* md, psS32 where, const char* name,
     236                        const char* comment, const char* value);
     237psBool psMetadataAddVector(psMetadata* md, psS32 where, const char* name,
     238                           const char* comment, psVector* value);
     239psBool psMetadataAddImage(psMetadata* md, psS32 where, const char* name,
     240                          const char* comment, psImage* value);
     241psBool psMetadataAddHash(psMetadata* md, psS32 where, const char* name,
     242                         const char* comment, psHash* value);
     243psBool psMetadataAddLookupTable(psMetadata* md, psS32 where, const char* name,
     244                                const char* comment, psLookupTable* value);
     245psBool psMetadataAddUnknown(psMetadata* md, psS32 where, const char* name,
     246                            const char* comment, psPtr value);
     247
    183248
    184249/** Remove an item from metadata collection.

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

    r3264 r3341  
    99*  @author Ross Harman, MHPCC
    1010*
    11 *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2005-02-17 19:26:23 $
     11*  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2005-02-28 23:34:10 $
    1313*
    1414*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    101101/*****************************************************************************/
    102102
    103 static void p_saxEndElement(void *ctx, const xmlChar *tagName);
    104 static void p_psInitVectorXml(void *ctx, char *tagName);
    105 static void p_psInitMetadataItemXml(void *ctx, char *tagName);
    106 static void p_saxStartElement(void *ctx, const xmlChar *tagName, const xmlChar **atts);
     103static void saxEndElement(void *ctx, const xmlChar *tagName);
     104static void initVectorXml(void *ctx, char *tagName);
     105static void initMetadataItemXml(void *ctx, char *tagName);
     106static void saxStartElement(void *ctx, const xmlChar *tagName, const xmlChar **atts);
    107107
    108108/** Determines if a line is blank (whitespace only) or a commentline. It returns true if so. The input string
    … …  
    307307{
    308308    psMetadataType type;
    309     psElemType pType;
    310309    psBool success = true;
    311310
    … …  
    315314
    316315    type = metadataItem->type;
    317     pType = metadataItem->pType;
    318316
    319317    switch(type) {
    320     case PS_META_PRIMITIVE:
    321         switch(pType) {
    322         case PS_TYPE_BOOL:
    323             fprintf(fd, format, metadataItem->data.B);
    324             break;
    325         case PS_TYPE_S32:
    326             fprintf(fd,format, metadataItem->data.S32);
    327             break;
    328         case PS_TYPE_F32:
    329             fprintf(fd, format, metadataItem->data.F32);
    330             break;
    331         case PS_TYPE_F64:
    332             fprintf(fd, format, metadataItem->data.F64);
    333             break;
    334         default:
    335             psError(PS_ERR_BAD_PARAMETER_TYPE,true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, (int)pType);
    336             success = false;
    337         }
     318    case PS_META_BOOL:
     319        fprintf(fd, format, metadataItem->data.B);
     320        break;
     321    case PS_META_S32:
     322        fprintf(fd,format, metadataItem->data.S32);
     323        break;
     324    case PS_META_F32:
     325        fprintf(fd, format, metadataItem->data.F32);
     326        break;
     327    case PS_META_F64:
     328        fprintf(fd, format, metadataItem->data.F64);
    338329        break;
    339330    case PS_META_STR:
    … …  
    419410        switch (keyType) {
    420411        case 'I':
    421             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_S32, PS_META_PRIMITIVE,
     412            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_META_S32,
    422413                                    keyComment, atoi(keyValue));
    423414            break;
    424415        case 'F':
    425             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_F64, PS_META_PRIMITIVE,
     416            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_META_F64,
    426417                                    keyComment, atof(keyValue));
    427418            break;
    428419        case 'C':
    429             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_PTR, PS_META_STR, keyComment,
    430                                     keyValue);
     420            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_META_STR,
     421                                    keyComment, keyValue);
    431422            break;
    432423        case 'L':
    433424            tempBool = (keyValue[0] == 'T') ? 1 : 0;
    434             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_BOOL, PS_META_PRIMITIVE, keyComment,
    435                                     tempBool);
     425            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_META_BOOL,
     426                                    keyComment, tempBool);
    436427            break;
    437428        case 'U':
    … …  
    460451    char *strComment = NULL;
    461452    char *linePtr = NULL;
     453    psElemType vecType = PS_TYPE_PTR;
    462454    psS32 status = 0;
    463455    psU32 lineCount = 0;
    … …  
    467459    psVector *tempVec = NULL;
    468460    FILE *fp = NULL;
    469     psElemType pType;
    470461    psMetadataType mdType;
    471462
    … …  
    535526            } else if(!strncmp(strType, "*", 1)) {
    536527                mdType = PS_META_LIST;
    537                 pType = PS_TYPE_PTR;
    538528            } else if(!strncmp(strType, "STR", 3)) {
    539529                mdType = PS_META_STR;
    540                 pType = PS_TYPE_PTR;
    541             } else if(!strncmp(strType, "BOOL", 3)) {
    542                 mdType = PS_META_PRIMITIVE;
    543                 pType = PS_TYPE_BOOL;
     530            } else if(!strncmp(strType, "BOOL", 4)) {
     531                mdType = PS_META_BOOL;
    544532            } else if(!strncmp(strType, "S32", 3)) {
    545                 mdType = PS_META_PRIMITIVE;
    546                 pType = PS_TYPE_S32;
     533                mdType = PS_META_S32;
    547534            } else if(!strncmp(strType, "F32", 3)) {
    548                 mdType = PS_META_PRIMITIVE;
    549                 pType = PS_TYPE_F32;
     535                mdType = PS_META_F32;
    550536            } else if(!strncmp(strType, "F64", 3)) {
    551                 mdType = PS_META_PRIMITIVE;
    552                 pType = PS_TYPE_F64;
     537                mdType = PS_META_F64;
    553538            } else {
    554539                (*nFail)++;
    … …  
    559544
    560545            if(*strName == '@') {
     546                vecType = PS_META_PRIMITIVE_TYPE(mdType);
    561547                mdType = PS_META_VEC;
    562548            }
    … …  
    604590            switch (mdType) {
    605591            case PS_META_LIST:
    606                 psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, NULL);
     592                psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, NULL);
    607593                break;
    608594            case PS_META_STR:
    609                 psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, strValue);
     595                psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, strComment, strValue);
    610596                break;
    611597            case PS_META_VEC:
    612                 tempVec = parseVector(strValue, pType, &status);
     598                tempVec = parseVector(strValue, vecType, &status);
    613599                if(!status) {
    614                     psMetadataAdd(md, PS_LIST_TAIL, strName+1, pType, mdType, strComment, tempVec);
     600                    psMetadataAdd(md, PS_LIST_TAIL, strName+1, mdType, strComment, tempVec);
     601                } else {
     602                    status = 0;
     603                    (*nFail)++;
     604                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     605                            strType, lineCount, fileName);
     606                    continue;
     607                }
     608                psFree(tempVec);
     609                break;
     610            case PS_META_BOOL:
     611                tempBool = parseBool(strValue, &status);
     612                if(!status) {
     613                    psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, strComment, tempBool);
    615614                } else {
    616615                    status = 0;
    … …  
    621620                }
    622621                break;
    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:
     622            case PS_META_S32:
     623                tempInt = (psS32)parseValue(strValue, &status);
     624                if(!status) {
     625                    psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, strComment, tempInt);
     626                } else {
     627                    status = 0;
    664628                    (*nFail)++;
    665                     psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, mdType, lineCount,
     629                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     630                            strType, lineCount, fileName);
     631                    continue;
     632                }
     633                break;
     634            case PS_META_F32:
     635            case PS_META_F64:
     636                tempDbl = parseValue(strValue, &status);
     637                if(!status) {
     638                    psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, strComment, tempDbl);
     639                } else {
     640                    status = 0;
     641                    (*nFail)++;
     642                    psError(PS_ERR_IO, true,
     643                            PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType, lineCount,
    666644                            fileName);
    667645                    continue;
    668                 } // switch
     646                }
    669647                break;
    670648            default:
    … …  
    682660}
    683661
    684 static void p_saxStartElement(void *ctx, const xmlChar *tagName, const xmlChar **atts)
     662static void saxStartElement(void *ctx, const xmlChar *tagName, const xmlChar **atts)
    685663{
    686664    psU64 i = 0;
    … …  
    709687    // Metadata containter for housing element attributes used by other SAX events
    710688    htAtts = psHashAlloc(10);
     689
    711690
    712691    // Get tag name
    … …  
    745724
    746725    // Add attributes to metadata
    747     psMetadataAdd(md, PS_LIST_TAIL, "htAtts", PS_TYPE_PTR, PS_META_HASH, NULL, htAtts);
     726
     727    psMetadataAdd(md, PS_LIST_TAIL, "htAtts", PS_META_HASH, NULL, htAtts);
    748728
    749729    psFree(psTagName);
     730    psFree(htAtts);
    750731
    751732    return;
    752733}
    753734
    754 static void p_psInitMetadataItemXml(void *ctx, char *tagName)
     735static void initMetadataItemXml(void *ctx, char *tagName)
    755736{
    756737    psBool overwrite = false;
    … …  
    760741    psF64 tempDbl = 0.0;
    761742    psS32 tempInt = 0.0;
    762     psElemType pType = PS_TYPE_PTR;
    763     psMetadataType mdType = PS_META_PRIMITIVE;
     743    psMetadataType mdType = PS_META_UNKNOWN;
    764744    char *fileName = NULL;
    765745    char *strName = NULL;
    … …  
    802782        if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psString")) {
    803783            mdType = PS_META_STR;
    804             pType = PS_TYPE_PTR;
    805784        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psBool")) {
    806             mdType = PS_META_PRIMITIVE;
    807             pType = PS_TYPE_U8;
     785            mdType = PS_META_BOOL;
    808786        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psS32")) {
    809             mdType = PS_META_PRIMITIVE;
    810             pType = PS_TYPE_S32;
     787            mdType = PS_META_S32;
    811788        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF32")) {
    812             mdType = PS_META_PRIMITIVE;
    813             pType = PS_TYPE_F32;
     789            mdType = PS_META_F32;
    814790        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF64")) {
    815             mdType = PS_META_PRIMITIVE;
    816             pType = PS_TYPE_F64;
     791            mdType = PS_META_F64;
    817792        } else {
    818793            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TYPE_INVALID_LINE_FILE, strType, lineNumber,
    … …  
    853828    switch(mdType) {
    854829    case PS_META_LIST:
    855         psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, NULL);
     830        psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, NULL);
    856831        break;
    857832    case PS_META_STR:
    858         psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, strValue);
     833        psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, strValue);
    859834        break;
    860     case PS_META_PRIMITIVE:
    861         switch(pType) {
    862         case PS_TYPE_BOOL:
    863             tempBool = parseBool((char*)strValue, &status);
    864             if(!status) {
    865                 psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempBool);
    866             } else {
    867                 status = 0;
    868                 psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    869                         lineNumber, fileName);
    870             }
    871             break;
    872         case PS_TYPE_S32:
    873             tempInt = (psS32)parseValue((char*)strValue, &status);
    874             if(!status) {
    875                 psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempInt);
    876             } else {
    877                 status = 0;
    878                 psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    879                         lineNumber, fileName);
    880             }
    881             break;
    882         case PS_TYPE_F32:
    883         case PS_TYPE_F64:
    884             tempDbl = parseValue((char*)strValue, &status);
    885             if(!status) {
    886                 psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempDbl);
    887             } else {
    888                 status = 0;
    889                 psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    890                         lineNumber, fileName);
    891             }
    892             break;
    893         default:
    894             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, strType, lineNumber, fileName);
    895         } // End switch
     835    case PS_META_BOOL:
     836        tempBool = parseBool((char*)strValue, &status);
     837        if(!status) {
     838            psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempBool);
     839        } else {
     840            status = 0;
     841            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     842                    lineNumber, fileName);
     843        }
     844        break;
     845    case PS_META_S32:
     846        tempInt = (psS32)parseValue((char*)strValue, &status);
     847        if(!status) {
     848            psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempInt);
     849        } else {
     850            status = 0;
     851            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     852                    lineNumber, fileName);
     853        }
     854        break;
     855    case PS_META_F32:
     856    case PS_META_F64:
     857        tempDbl = parseValue((char*)strValue, &status);
     858        if(!status) {
     859            psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempDbl);
     860        } else {
     861            status = 0;
     862            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     863                    lineNumber, fileName);
     864        }
    896865        break;
    897866    default:
    … …  
    899868    } // End switch
    900869
    901 
    902870    return;
    903871}
    904872
    905873
    906 static void p_psInitVectorXml(void *ctx, char *tagName)
     874static void initVectorXml(void *ctx, char *tagName)
    907875{
    908876    bool overwrite = false;
    … …  
    910878    psU32 lineNumber = 0;
    911879    psElemType pType = PS_TYPE_PTR;
    912     psMetadataType mdType = PS_META_PRIMITIVE;
    913880    char *strName = NULL;
    914881    char *strType = NULL;
    … …  
    952919    strType = psHashLookup(htAtts, "psType");
    953920    if(strType!= NULL) {
    954         if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psString")) {
    955             mdType = PS_META_STR;
    956             pType = PS_TYPE_PTR;
    957         } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psBool")) {
    958             mdType = PS_META_PRIMITIVE;
     921        if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psBool")) {
    959922            pType = PS_TYPE_U8;
    960923        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psS32")) {
    961             mdType = PS_META_PRIMITIVE;
    962924            pType = PS_TYPE_S32;
    963925        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF32")) {
    964             mdType = PS_META_PRIMITIVE;
    965926            pType = PS_TYPE_F32;
    966927        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF64")) {
    967             mdType = PS_META_PRIMITIVE;
    968928            pType = PS_TYPE_F64;
    969929        } else {
    … …  
    1006966    vec = parseVector((char*)strValue, pType, &status);
    1007967    if(!status) {
    1008         psMetadataAdd(md, PS_LIST_TAIL, strName+1, pType, mdType, NULL, vec);
     968        psMetadataAdd(md, PS_LIST_TAIL, strName+1, PS_META_VEC, NULL, vec);
    1009969    } else {
    1010970        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    … …  
    1014974}
    1015975
    1016 static void p_saxEndElement(void *ctx, const xmlChar *tagName)
     976static void saxEndElement(void *ctx, const xmlChar *tagName)
    1017977{
    1018978    char *psStartTagName = NULL;
    … …  
    10521012    // Initialize psLib structs
    10531013    if(!strcmp(psEndTagName, "psMetadataItem")) {
    1054         p_psInitMetadataItemXml(ctx, psEndTagName);
     1014        initMetadataItemXml(ctx, psEndTagName);
    10551015    } else if(!strcmp(psEndTagName, "psVector")) {
    1056         p_psInitVectorXml(ctx, psEndTagName);
     1016        initVectorXml(ctx, psEndTagName);
    10571017    } else if(strcmp(psEndTagName, "psRoot")) {
    10581018        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TAG_UNKNOWN, psEndTagName);
    … …  
    10951055    saxHandler.startDocument            = NULL;
    10961056    saxHandler.endDocument              = NULL;
    1097     saxHandler.startElement             = p_saxStartElement;
    1098     saxHandler.endElement               = p_saxEndElement;
     1057    saxHandler.startElement             = saxStartElement;
     1058    saxHandler.endElement               = saxEndElement;
    10991059    saxHandler.reference                = NULL;
    11001060    saxHandler.characters               = NULL;
Note: See TracChangeset for help on using the changeset viewer.