IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 5136 for trunk/psLib/src/types


Ignore:
Timestamp:
Sep 26, 2005, 11:13:36 AM (21 years ago)
Author:
desonia
Message:

changed PS_META* datatypes to more generic PS_DATA* datatypes.

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

Legend:

Unmodified
Added
Removed

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

    r5089 r5136  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.84 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-09-22 02:32:00 $
     14 *  @version $Revision: 1.85 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-09-26 21:13:26 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7575{
    7676
    77     if (existing != NULL && existing->type == PS_META_MULTI) {
     77    if (existing != NULL && existing->type == PS_DATA_METADATA_MULTI) {
    7878        return existing;
    7979    }
    … …  
    8383
    8484    psMetadataItem* item = psMetadataItemAlloc(key,
    85                            PS_META_MULTI,
     85                           PS_DATA_METADATA_MULTI,
    8686                           "",
    8787                           newList);
    … …  
    113113    psMemDecrRefCounter(metadataItem->comment);
    114114
    115     if(!PS_META_IS_PRIMITIVE(type)) {
     115    if(!PS_DATA_IS_PRIMITIVE(type)) {
    116116        psFree(metadataItem->data.V);
    117117    }
    … …  
    178178}
    179179
    180 METADATAITEM_ALLOC_TYPE(Str,const char*,PS_META_STR)
    181 METADATAITEM_ALLOC_TYPE(F32,psF32,PS_META_F32)
    182 METADATAITEM_ALLOC_TYPE(F64,psF64,PS_META_F64)
    183 METADATAITEM_ALLOC_TYPE(S32,psS32,PS_META_S32)
    184 METADATAITEM_ALLOC_TYPE(Bool,psBool,PS_META_BOOL)
     180METADATAITEM_ALLOC_TYPE(Str,const char*,PS_DATA_STRING)
     181METADATAITEM_ALLOC_TYPE(F32,psF32,PS_DATA_F32)
     182METADATAITEM_ALLOC_TYPE(F64,psF64,PS_DATA_F64)
     183METADATAITEM_ALLOC_TYPE(S32,psS32,PS_DATA_S32)
     184METADATAITEM_ALLOC_TYPE(Bool,psBool,PS_DATA_BOOL)
    185185
    186186psMetadataItem* psMetadataItemAllocV(const char *name,
    … …  
    217217    // Allocate and set metadata item name
    218218    metadataItem->name = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH);
    219     vsprintf(metadataItem->name, name, argPtr);
     219    vsnprintf(metadataItem->name, MAX_STRING_LENGTH, name, argPtr);
    220220
    221221    // Set metadata item value
    222222    switch(metadataItem->type) {
    223     case PS_META_BOOL:
     223    case PS_DATA_BOOL:
    224224        metadataItem->data.B = (psBool)va_arg(argPtr, psS32);
    225225        break;
    226     case PS_META_S32:
     226    case PS_DATA_S32:
    227227        metadataItem->data.S32 = (psS32)va_arg(argPtr, psS32);
    228228        break;
    229     case PS_META_F32:
     229    case PS_DATA_F32:
    230230        metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64);
    231231        break;
    232     case PS_META_F64:
     232    case PS_DATA_F64:
    233233        metadataItem->data.F64 = (psF64)va_arg(argPtr, psF64);
    234234        break;
    235     case PS_META_STR:
     235    case PS_DATA_STRING:
    236236        // Perform copy of input strings
    237237        metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH);
    238238        break;
    239     case PS_META_LIST:
    240     case PS_META_VEC:
    241     case PS_META_HASH:
    242     case PS_META_LOOKUPTABLE:
    243     case PS_META_JPEG:
    244     case PS_META_PNG:
    245     case PS_META_ASTROM:
    246     case PS_META_UNKNOWN:
    247     case PS_META_META:
    248     case PS_META_MULTI:
    249     case PS_META_ARRAY:
    250     case PS_META_TIME:
     239    case     PS_DATA_ARRAY:                     ///< psArray
     240    case     PS_DATA_BITSET:                    ///< psBitSet
     241    case     PS_DATA_CELL:                      ///< psCell
     242    case     PS_DATA_CHIP:                      ///< psChip
     243    case     PS_DATA_CUBE:                      ///< psCube
     244    case     PS_DATA_FITS:                      ///< psFits
     245    case     PS_DATA_HASH:                      ///< psHash
     246    case     PS_DATA_HISTOGRAM:                 ///< psHistogram
     247    case     PS_DATA_IMAGE:                     ///< psImage
     248    case     PS_DATA_KERNEL:                    ///< psKernel
     249    case     PS_DATA_LIST:                      ///< psList
     250    case     PS_DATA_LOOKUPTABLE:               ///< psLookupTable
     251    case     PS_DATA_METADATA:                  ///< psMetadata
     252    case     PS_DATA_METADATAITEM:              ///< psMetadataItem
     253    case     PS_DATA_MINIMIZATION:              ///< psMinimization
     254    case     PS_DATA_PIXELS:                    ///< psPixels
     255    case     PS_DATA_PLANE:                     ///< psPlane
     256    case     PS_DATA_PLANEDISTORT:              ///< psPlaneDistort
     257    case     PS_DATA_PLANETRANSFORM:            ///< psPlaneTransform
     258    case     PS_DATA_POLYNOMIAL1D:              ///< psPolynomial1D
     259    case     PS_DATA_POLYNOMIAL2D:              ///< psPolynomial2D
     260    case     PS_DATA_POLYNOMIAL3D:              ///< psPolynomial3D
     261    case     PS_DATA_POLYNOMIAL4D:              ///< psPolynomial4D
     262    case     PS_DATA_PROJECTION:                ///< psProjection
     263    case     PS_DATA_READOUT:                   ///< psReadout
     264    case     PS_DATA_REGION:                    ///< psRegion
     265    case     PS_DATA_SCALAR:                    ///< psScalar
     266    case     PS_DATA_SPHERE:                    ///< psSphere
     267    case     PS_DATA_SPHEREROT:                 ///< psSphereTransform
     268    case     PS_DATA_SPLINE1D:                  ///< psSpline1D
     269    case     PS_DATA_STATS:                     ///< psStats
     270    case     PS_DATA_TIME:                      ///< psTime
     271    case     PS_DATA_VECTOR:                    ///< psVector
     272    case     PS_DATA_METADATA_MULTI:
    251273        // Copy of input data not performed due to variability of data types
    252274        metadataItem->data.V = psMemIncrRefCounter(va_arg(argPtr, psPtr));
    … …  
    313335    existingEntry = (psMetadataItem*)psHashLookup(mdTable, key);
    314336
    315     if (item->type == PS_META_MULTI) {
    316         // the incoming entry is PS_META_MULTI
    317 
    318         // force the hash entry to be PS_META_MULTI
     337    if (item->type == PS_DATA_METADATA_MULTI) {
     338        // the incoming entry is PS_DATA_METADATA_MULTI
     339
     340        // force the hash entry to be PS_DATA_METADATA_MULTI
    319341        existingEntry = makeMetaMulti(mdTable,key,existingEntry);
    320342
    … …  
    335357    // how the item is added to the hash depends on prior existence, flags, etc.
    336358    if(existingEntry != NULL) { // prior existence
    337         if (existingEntry->type == PS_META_MULTI || (flags & PS_META_DUPLICATE_OK) != 0) {
     359        if (existingEntry->type == PS_DATA_METADATA_MULTI || (flags & PS_META_DUPLICATE_OK) != 0) {
    338360            // duplicate entries allowed - add another entry.
    339361
    340             // make sure the existing entry is PS_META_MULTI
     362            // make sure the existing entry is PS_DATA_METADATA_MULTI
    341363            existingEntry = makeMetaMulti(mdTable,key,existingEntry);
    342364
    … …  
    429451}
    430452
    431 METADATA_ADD_TYPE(Bool,psBool,PS_META_BOOL)
    432 METADATA_ADD_TYPE(S32,psS32,PS_META_S32)
    433 METADATA_ADD_TYPE(F32,psF32,PS_META_F32)
    434 METADATA_ADD_TYPE(F64,psF64,PS_META_F64)
    435 METADATA_ADD_TYPE(List,psList*,PS_META_LIST)
    436 METADATA_ADD_TYPE(Str,const char*,PS_META_STR)
    437 METADATA_ADD_TYPE(Vector,psVector*,PS_META_VEC)
    438 METADATA_ADD_TYPE(Image,psImage*,PS_META_IMG)
    439 METADATA_ADD_TYPE(Hash,psHash*,PS_META_HASH)
    440 METADATA_ADD_TYPE(LookupTable,psLookupTable*,PS_META_LOOKUPTABLE)
    441 METADATA_ADD_TYPE(Unknown,void*,PS_META_UNKNOWN)
    442 METADATA_ADD_TYPE(Metadata,psMetadata*,PS_META_META)
    443 METADATA_ADD_TYPE(Array,psArray*,PS_META_ARRAY)
    444 METADATA_ADD_TYPE(Time,psTime*,PS_META_TIME)
     453METADATA_ADD_TYPE(Bool,psBool,PS_DATA_BOOL)
     454METADATA_ADD_TYPE(S32,psS32,PS_DATA_S32)
     455METADATA_ADD_TYPE(F32,psF32,PS_DATA_F32)
     456METADATA_ADD_TYPE(F64,psF64,PS_DATA_F64)
     457METADATA_ADD_TYPE(List,psList*,PS_DATA_LIST)
     458METADATA_ADD_TYPE(Str,const char*,PS_DATA_STRING)
     459METADATA_ADD_TYPE(Vector,psVector*,PS_DATA_VECTOR)
     460METADATA_ADD_TYPE(Image,psImage*,PS_DATA_IMAGE)
     461METADATA_ADD_TYPE(Hash,psHash*,PS_DATA_HASH)
     462METADATA_ADD_TYPE(LookupTable,psLookupTable*,PS_DATA_LOOKUPTABLE)
     463METADATA_ADD_TYPE(Unknown,void*,PS_DATA_UNKNOWN)
     464METADATA_ADD_TYPE(Metadata,psMetadata*,PS_DATA_METADATA)
     465METADATA_ADD_TYPE(Array,psArray*,PS_DATA_ARRAY)
     466METADATA_ADD_TYPE(Time,psTime*,PS_DATA_TIME)
    445467
    446468bool psMetadataRemove(psMetadata *md,
    … …  
    464486            return false;
    465487        }
    466         if (entry->type == PS_META_MULTI) {
     488        if (entry->type == PS_DATA_METADATA_MULTI) {
    467489            psMetadataItem* listItem;
    468490            psListIterator* iter = psListIteratorAlloc(
    … …  
    499521        }
    500522
    501         if (tableItem->type == PS_META_MULTI) {
     523        if (tableItem->type == PS_DATA_METADATA_MULTI) {
    502524            // multiple entries with same key, remove just the specified one
    503525            psListRemoveData(tableItem->data.list, entry);
    … …  
    548570        return NULL;
    549571    }
    550     if (metadataItem->type == PS_META_MULTI) {
     572    if (metadataItem->type == PS_DATA_METADATA_MULTI) {
    551573        // if multiple keys found, use the first.
    552574        metadataItem = (psMetadataItem*)((metadataItem->data.list)->head);
    553575    }
    554576
    555     if(PS_META_IS_PRIMITIVE(metadataItem->type)) {
     577    if(PS_DATA_IS_PRIMITIVE(metadataItem->type)) {
    556578        if (status) {
    557579            *status = false;
    … …  
    583605        return 0; \
    584606    } \
    585     if (metadataItem->type == PS_META_MULTI) { \
     607    if (metadataItem->type == PS_DATA_METADATA_MULTI) { \
    586608        /* if multiple keys found, use the first. */ \
    587609        metadataItem = (psMetadataItem*)((metadataItem->data.list)->head); \
    … …  
    589611    \
    590612    switch (metadataItem->type) { \
    591     case PS_META_S32: \
     613    case PS_DATA_S32: \
    592614        value = (ps##TYPE)metadataItem->data.S32; \
    593615        break; \
    594     case PS_META_F32: \
     616    case PS_DATA_F32: \
    595617        value = (ps##TYPE)metadataItem->data.F32; \
    596618        break; \
    597     case PS_META_F64: \
     619    case PS_DATA_F64: \
    598620        value = (ps##TYPE)metadataItem->data.F64; \
    599621        break; \
    600     case PS_META_BOOL: \
     622    case PS_DATA_BOOL: \
    601623        if (metadataItem->data.B) { \
    602624            value = 1; \
    … …  
    793815            psError(PS_ERR_IO, true, "Couldn't find %s in the metadata.\n");
    794816        }
    795     } else if (item->type != PS_META_META) {
     817    } else if (item->type != PS_DATA_METADATA) {
    796818        // The value at the key isn't metadata
    797819        if (status) {
    798820            *status = false;
    799821        } else {
    800             psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_META_META, as expected.\n");
     822            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_DATA_META, as expected.\n");
    801823        }
    802824        value = NULL;
    … …  
    825847            psError(PS_ERR_IO, true, "Couldn't find %s in the metadata.\n");
    826848        }
    827     } else if (item->type != PS_META_STR) {
     849    } else if (item->type != PS_DATA_STRING) {
    828850        // The value at the key isn't of the desired type
    829851        if (status) {
    830852            *status = false;
    831853        } else {
    832             psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_META_STR, as expected.\n");
     854            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_DATA_STRING, as expected.\n");
    833855        }
    834856        value = NULL;
    … …  
    860882        printf(": ");
    861883        switch (item->type) {
    862         case PS_META_STR:
     884        case PS_DATA_STRING:
    863885            printf("%s", (char*)(item->data.V));
    864886            break;
    865         case PS_META_BOOL:
     887        case PS_DATA_BOOL:
    866888            if (item->data.B) {
    867889                printf("True");
    … …  
    870892            }
    871893            break;
    872         case PS_META_S32:
     894        case PS_DATA_S32:
    873895            printf("%d", item->data.S32);
    874896            break;
    875         case PS_META_F32:
     897        case PS_DATA_F32:
    876898            printf("%f", item->data.F32);
    877899            break;
    878         case PS_META_F64:
     900        case PS_DATA_F64:
    879901            printf("%f", item->data.F64);
    880902            break;
    881         case PS_META_META:
     903        case PS_DATA_METADATA:
    882904            printf("\n");
    883905            psMetadataPrint(item->data.V, level + 1);
    … …  
    9811003    {
    9821004        // Only doing a representative set of types
    983     case PS_META_S32:
     1005    case PS_DATA_S32:
    9841006        newItem = psMetadataItemAlloc(item->name, item->type, item->comment, atoi(argv[argnum]));
    9851007        psArgumentRemove(argnum, argc, argv);
    9861008        break;
    987     case PS_META_F32:
     1009    case PS_DATA_F32:
    9881010        newItem = psMetadataItemAlloc(item->name, item->type, item->comment, atof(argv[argnum]));
    9891011        psArgumentRemove(argnum, argc, argv);
    9901012        break;
    991     case PS_META_BOOL:
     1013    case PS_DATA_BOOL:
    9921014        // Turn option on; no optional argument to remove
    9931015        newItem = psMetadataItemAlloc(item->name, item->type, item->comment, true);
    9941016        break;
    9951017        // XXX: Include the other numerical types
    996     case PS_META_STR: {
     1018    case PS_DATA_STRING: {
    9971019            //psString string = psStringCopy(argv[argnum]); // Get the argument into PS memory management
    9981020            //psFree(string);
    … …  
    10321054        if (argItem) {
    10331055            psArgumentRemove(i, argc, argv); // Remove the switch
    1034             if (argItem->type != PS_META_MULTI) {
    1035                 if (argItem->type != PS_META_BOOL && *argc < i + 1) {
     1056            if (argItem->type != PS_DATA_METADATA_MULTI) {
     1057                if (argItem->type != PS_DATA_BOOL && *argc < i + 1) {
    10361058                    psError(PS_ERR_IO, true, "Required argument for %s is missing.\n", argItem->name);
    10371059                    // XXX: Cleanup before returning
    … …  
    11001122        switch (oldItem->type) {
    11011123            // Only doing a representative set of types
    1102         case PS_META_S32:
     1124        case PS_DATA_S32:
    11031125            oldItem->data.S32 = newItem->data.S32;
    11041126            break;
    1105         case PS_META_F32:
     1127        case PS_DATA_F32:
    11061128            oldItem->data.F32 = newItem->data.F32;
    11071129            break;
    1108         case PS_META_BOOL:
     1130        case PS_DATA_BOOL:
    11091131            oldItem->data.B = newItem->data.B;
    11101132            break;
    11111133            // XXX: Include the other numerical types
    1112         case PS_META_STR:
     1134        case PS_DATA_STRING:
    11131135            psFree(oldItem->data.V);
    11141136            oldItem->data.V = psMemIncrRefCounter(newItem->data.V);
    11151137            break;
    1116         case PS_META_MULTI: {
     1138        case PS_DATA_METADATA_MULTI: {
    11171139                psList *newMulti = psMemIncrRefCounter(newItem->data.V); // The new list of MULTI
    11181140                psList *oldMulti = oldItem->data.V; // The old list of MULTI
    … …  
    11281150                    switch (oldMultiItem->type) {
    11291151                        // Only doing a representative set of types
    1130                     case PS_META_S32:
     1152                    case PS_DATA_S32:
    11311153                        oldItem->data.S32 = newItem->data.S32;
    11321154                        break;
    1133                     case PS_META_F32:
     1155                    case PS_DATA_F32:
    11341156                        oldItem->data.F32 = newItem->data.F32;
    11351157                        break;
    11361158                        // XXX: Include the other numerical types
    1137                     case PS_META_STR:
     1159                    case PS_DATA_STRING:
    11381160                        psFree(oldItem->data.V);
    11391161                        oldItem->data.V = psMemIncrRefCounter(newItem->data.V);
    … …  
    11661188    switch (arg->type) {
    11671189        // Only doing a representative set of types
    1168     case PS_META_S32:
     1190    case PS_DATA_S32:
    11691191        return arg->data.S32 >= 0 ? (int)log10f((float)arg->data.S32) + 1 :
    11701192               (int)log10f(-(float)arg->data.S32) + 2;
    11711193        // XXX: Other numerical types
    1172     case PS_META_F32:
     1194    case PS_DATA_F32:
    11731195        return arg->data.F32 >= 0 ? 12 : 13; // -d.dddddde?dd
    1174     case PS_META_F64:
     1196    case PS_DATA_F64:
    11751197        return arg->data.F64 >= 0 ? 12 : 13; // -d.dddddde?dd
    1176     case PS_META_BOOL:
     1198    case PS_DATA_BOOL:
    11771199        return arg->data.B ? 4 : 5;
    1178     case PS_META_STR:
     1200    case PS_DATA_STRING:
    11791201        return strlen(arg->data.V);
    11801202    default:
    … …  
    12311253        switch (argItem->type) {
    12321254            // Only doing a representative set of types
    1233         case PS_META_S32:
     1255        case PS_DATA_S32:
    12341256            printf("%d", argItem->data.S32);
    12351257            break;
    12361258            // XXX: Other numerical types
    1237         case PS_META_F32:
     1259        case PS_DATA_F32:
    12381260            printf("%.6e", argItem->data.F32);
    12391261            break;
    1240         case PS_META_F64:
     1262        case PS_DATA_F64:
    12411263            printf("%.6e", argItem->data.F64);
    12421264            break;
    1243         case PS_META_BOOL:
     1265        case PS_DATA_BOOL:
    12441266            if (argItem->data.B) {
    12451267                printf("TRUE");
    … …  
    12481270            }
    12491271            break;
    1250         case PS_META_STR:
     1272        case PS_DATA_STRING:
    12511273            printf("%s", (char*)(argItem->data.V));
    12521274            break;

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

    r5057 r5136  
    1111*  @author Ross Harman, MHPCC
    1212*
    13 *  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2005-09-15 21:22:22 $
     13*  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
     14*  @date $Date: 2005-09-26 21:13:26 $
    1515*
    1616*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3232/// @{
    3333
    34 /** Metadata item type.
    35  *
    36  * Enumeration for maintaining metadata item types.
    37  */
    38 typedef enum {
    39     PS_META_S32 = PS_TYPE_S32,         ///< psS32 primitive data.
    40     PS_META_F32 = PS_TYPE_F32,         ///< psF32 primitive data.
    41     PS_META_F64 = PS_TYPE_F64,         ///< psF64 primitive data.
    42     PS_META_BOOL = PS_TYPE_BOOL,       ///< psBool primitive data.
    43     PS_META_LIST = 0x10000,            ///< List data (Stored as item.data.list).
    44     PS_META_STR,                       ///< String data (Stored as item.data.V).
    45     PS_META_VEC,                       ///< Vector data (Stored as item.data.V).
    46     PS_META_IMG,                       ///< Image data (Stored as item.data.V).
    47     PS_META_HASH,                      ///< Hash data (Stored as item.data.V).
    48     PS_META_LOOKUPTABLE,               ///< Lookup table data (Stored as item.data.V).
    49     PS_META_JPEG,                      ///< JPEG data (Stored as item.data.V).
    50     PS_META_PNG,                       ///< PNG data (Stored as item.data.V).
    51     PS_META_ASTROM,                    ///< Astrometric coefficients (Stored as item.data.V).
    52     PS_META_UNKNOWN,                   ///< Other data (Stored as item.data.V).
    53     PS_META_MULTI,                     ///< Used internally, do not create an metadata item of this type.
    54     PS_META_META = PS_DATA_METADATA,   ///< Metadata data (Stored as item.data.md).
    55     PS_META_ARRAY,                     ///< Array data (Stored as item.data.V).
    56     PS_META_TIME                       ///< psTime data (Stored as item.data.V).
    57 } psMetadataType;
    58 #define PS_META_IS_PRIMITIVE(TYPE) \
    59 (TYPE == PS_META_S32 || \
    60  TYPE == PS_META_F32 || \
    61  TYPE == PS_META_F64 || \
    62  TYPE == PS_META_BOOL)
    63 
    64 #define PS_META_PRIMITIVE_TYPE(METATYPE) ( \
    65         (METATYPE==PS_META_S32) ? PS_TYPE_S32 : \
    66         (METATYPE==PS_META_F32) ? PS_TYPE_F32 : \
    67         (METATYPE==PS_META_F64) ? PS_TYPE_F64 : \
    68         (METATYPE==PS_META_BOOL) ? PS_TYPE_BOOL : 0 )
     34#define PS_DATA_IS_PRIMITIVE(TYPE) \
     35(TYPE == PS_DATA_S32 || \
     36 TYPE == PS_DATA_F32 || \
     37 TYPE == PS_DATA_F64 || \
     38 TYPE == PS_DATA_BOOL)
     39
     40#define PS_DATA_PRIMITIVE_TYPE(DATATYPE) ( \
     41        (DATATYPE==PS_DATA_S32 || DATATYPE==PS_DATA_F32 || \
     42         DATATYPE==PS_DATA_F64 || DATATYPE==PS_DATA_BOOL) ? DATATYPE : 0)
     43
    6944
    7045/** Option flags for psMetadata functions

  • trunk/psLib/src/types/psMetadataConfig.c

    r5103 r5136  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-09-23 02:39:06 $
     12*  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-09-26 21:13:26 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    411411                         const psMetadataItem* item)
    412412{
    413     psMetadataType type;
     413    psDataType type;
    414414    psBool success = true;
    415415
    … …  
    436436    #define METADATAITEM_NUMERIC_CAST(FORMAT_TYPE) { \
    437437        switch(type) { \
    438         case PS_META_BOOL: \
     438        case PS_DATA_BOOL: \
    439439            fprintf(fd, format, (FORMAT_TYPE) item->data.B); \
    440440            break; \
    441         case PS_META_S32: \
     441        case PS_DATA_S32: \
    442442            fprintf(fd,format,(FORMAT_TYPE)  item->data.S32); \
    443443            break; \
    444         case PS_META_F32: \
     444        case PS_DATA_F32: \
    445445            fprintf(fd, format,(FORMAT_TYPE)  item->data.F32); \
    446446            break; \
    447         case PS_META_F64: \
     447        case PS_DATA_F64: \
    448448            fprintf(fd, format,(FORMAT_TYPE) item->data.F64); \
    449449            break; \
    … …  
    478478        break;
    479479    case 's':
    480         if (type == PS_META_STR) {
     480        if (type == PS_DATA_STRING) {
    481481            fprintf(fd,format,(char*)item->data.V);
    482482        } else {
    … …  
    573573        case 'I':
    574574            success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
    575                                     PS_META_S32 | PS_META_DUPLICATE_OK,
     575                                    PS_DATA_S32 | PS_META_DUPLICATE_OK,
    576576                                    keyComment, atoi(keyValue));
    577577            break;
    578578        case 'F':
    579579            success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
    580                                     PS_META_F64 | PS_META_DUPLICATE_OK,
     580                                    PS_DATA_F64 | PS_META_DUPLICATE_OK,
    581581                                    keyComment, atof(keyValue));
    582582            break;
    583583        case 'C':
    584584            success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
    585                                     PS_META_STR | PS_META_DUPLICATE_OK,
     585                                    PS_DATA_STRING | PS_META_DUPLICATE_OK,
    586586                                    keyComment, keyValue);
    587587            break;
    … …  
    589589            tempBool = (keyValue[0] == 'T') ? 1 : 0;
    590590            success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
    591                                     PS_META_BOOL | PS_META_DUPLICATE_OK,
     591                                    PS_DATA_BOOL | PS_META_DUPLICATE_OK,
    592592                                    keyComment, tempBool);
    593593            break;
    … …  
    734734    psBool               returnValue   = true;
    735735    psBool               addStatus     = false;
    736     psMetadataType       mdType        = PS_META_UNKNOWN;
     736    psDataType           mdType        = PS_DATA_UNKNOWN;
    737737    psElemType           vectorType    = PS_TYPE_S8;
    738738    char*                strType       = NULL;
    … …  
    769769        // Check if the keyName specifies a vector and if so use strType token to find vector type
    770770        if(*keyName == '@') {
    771             mdType = PS_META_VEC;
     771            mdType = PS_DATA_VECTOR;
    772772            // Get the type of vector
    773773            if(!strncmp(strType, "U8", 2)) {
    … …  
    798798            }
    799799        } else if(!strncmp(strType, "STR", 3)) {
    800             mdType = PS_META_STR;
     800            mdType = PS_DATA_STRING;
    801801        } else if(!strncmp(strType, "BOOL", 4)) {
    802             mdType = PS_META_BOOL;
     802            mdType = PS_DATA_BOOL;
    803803        } else if(!strncmp(strType, "S32", 3)) {
    804             mdType = PS_META_S32;
     804            mdType = PS_DATA_S32;
    805805        } else if(!strncmp(strType, "F32", 3)) {
    806             mdType = PS_META_F32;
     806            mdType = PS_DATA_F32;
    807807        } else if(!strncmp(strType, "F64", 3)) {
    808             mdType = PS_META_F64;
     808            mdType = PS_DATA_F64;
    809809        } else if(!strncmp(strType, "MULTI", 5)) {
    810             mdType = PS_META_MULTI;
     810            mdType = PS_DATA_METADATA_MULTI;
    811811        } else if(!strncmp(strType, "METADATA", 8)) {
    812             mdType = PS_META_META;
     812            mdType = PS_DATA_METADATA;
    813813        } else if( !strncmp(strType, "PS_TIME_UTC", 12) || !strncmp(strType, "PS_TIME_TAI", 12)
    814814                   || !strncmp(strType, "PS_TIME_UT1", 12) || !strncmp(strType, "PS_TIME_TT", 12)) {
    815             mdType = PS_META_TIME;
     815            mdType = PS_DATA_TIME;
    816816        } else {
    817817            // Search through user types
    … …  
    824824                        // Add metadata item
    825825                        md = ((p_psParseLevelInfo*)(levelArray->data[*level]))->metadata;
    826                         addStatus = psMetadataAdd(md,PS_LIST_TAIL,keyName,PS_META_META | flags,"",tempMeta);
     826                        addStatus = psMetadataAdd(md,PS_LIST_TAIL,keyName,PS_DATA_METADATA | flags,"",tempMeta);
    827827                        // Check for add failure
    828828                        if (! addStatus) {
    … …  
    858858
    859859    // If type is not MULTI or META then get the value and comment
    860     if((mdType != PS_META_MULTI) && (mdType != PS_META_META)) {
     860    if((mdType != PS_DATA_METADATA_MULTI) && (mdType != PS_DATA_METADATA)) {
    861861        // Get the metadata item value if there is one.
    862862        status = 0;
    … …  
    893893    nonUniqueKeys = ((p_psParseLevelInfo*)(levelArray->data[*level]))->nonUniqueKeyArray;
    894894    switch(mdType) {
    895     case PS_META_STR:
     895    case PS_DATA_STRING:
    896896        addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    897897                                  mdType | flags,
    898898                                  strComment, strValue);
    899899        break;
    900     case PS_META_BOOL:
     900    case PS_DATA_BOOL:
    901901        tempBool = parseBool(strValue, &status);
    902902        if(!status) {
    … …  
    910910        }
    911911        break;
    912     case PS_META_F32:
    913     case PS_META_F64:
     912    case PS_DATA_F32:
     913    case PS_DATA_F64:
    914914        tempDbl = parseValue(strValue, &status);
    915915        if(!status) {
    … …  
    924924        }
    925925        break;
    926     case PS_META_S32:
     926    case PS_DATA_S32:
    927927        tempInt = (psS32)parseValue(strValue, &status);
    928928        if(!status) {
    … …  
    936936        }
    937937        break;
    938     case PS_META_TIME:
     938    case PS_DATA_TIME:
    939939        if( !strncmp(strType, "PS_TIME_UTC", 12) )
    940940            timeType = PS_TIME_UTC;
    … …  
    957957        psFree(mTime);
    958958        break;
    959     case PS_META_VEC:
     959    case PS_DATA_VECTOR:
    960960        tempVec = parseVector(strValue, vectorType, &status);
    961961        if(!status) {
    … …  
    970970        psFree(tempVec);
    971971        break;
    972     case PS_META_MULTI:
     972    case PS_DATA_METADATA_MULTI:
    973973        // Add key to non-unique array of keys
    974974        // Check for duplicate MULTI lines
    … …  
    987987        psFree(tempStr);
    988988        break;
    989     case PS_META_META:
     989    case PS_DATA_METADATA:
    990990        // Create next level info
    991991        nextLevelInfo = p_psParseLevelInfoAlloc();
    … …  
    11201120                addStatus = psMetadataAdd(upperLevelInfo->metadata,
    11211121                                          PS_LIST_TAIL,lowerLevelInfo->name,
    1122                                           PS_META_META | flags,
     1122                                          PS_DATA_METADATA | flags,
    11231123                                          "",
    11241124                                          lowerLevelInfo->metadata);
    … …  
    12421242    while ( (item = psMetadataGetAndIncrement(iter)) ) {
    12431243        type = item->type;
    1244         if ( type == PS_META_STR)
     1244        if ( type == PS_DATA_STRING)
    12451245            type = PS_DATA_STRING;
    1246         if ( type == PS_META_VEC)
     1246        if ( type == PS_DATA_VECTOR)
    12471247            type = PS_DATA_VECTOR;
    1248         if ( type == PS_META_TIME)
     1248        if ( type == PS_DATA_TIME)
    12491249            type = PS_DATA_TIME;
    1250         if ( item->type == PS_META_META)
     1250        if ( item->type == PS_DATA_METADATA)
    12511251            type = PS_DATA_METADATA;
    12521252
Note: See TracChangeset for help on using the changeset viewer.