Changeset 5136 for trunk/psLib/src

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

Files:

• astro/psTime.c (modified) (2 diffs)
• db/psDB.c (modified) (11 diffs)
• db/psDB.h (modified) (4 diffs)
• fits/psFits.c (modified) (24 diffs)
• sys/psType.h (modified) (3 diffs)
• types/psMetadata.c (modified) (25 diffs)
• types/psMetadata.h (modified) (2 diffs)
• types/psMetadataConfig.c (modified) (20 diffs)
• xml/psXML.c (modified) (2 diffs)

trunk/psLib/src/astro/psTime.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.71 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-21 02:11:16 $
+ *  @version $Revision: 1.72 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-26 21:13:12 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -397 +397 @@
             if(metadataNamesPtr != NULL) {
                 psMetadataAdd(timeMetadata, PS_LIST_TAIL, strcat(metadataTableNames[j], "Table"),
-                              PS_META_LOOKUPTABLE, NULL, table);
+                              PS_DATA_LOOKUPTABLE, NULL, table);
                 foundTable = true;
             } else if(foundTable==false && j==numTables-1) {

trunk/psLib/src/db/psDB.c

@@ -12 +12 @@
  *  @author Joshua Hoblitt
  *
- *  @version $Revision: 1.42 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-08-27 01:33:40 $
+ *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-26 21:13:16 $
  *
  *  Copyright 2005 Joshua Hoblitt, University of Hawaii
@@ -501 +501 @@
 
             // copy field data and convert NULLs to the appropriate NaN value
-            if (pType == PS_META_STR) {
+            if (pType == PS_DATA_STRING) {
                 psMetadataAddStr(md, PS_LIST_TAIL, field[i].name, 0, "", data);
-            } else if (pType == PS_META_S32) {
+            } else if (pType == PS_DATA_S32) {
                 psMetadataAddS32(md, PS_LIST_TAIL, field[i].name, 0, "", atoll(data));
-            } else if (pType == PS_META_F32) {
+            } else if (pType == PS_DATA_F32) {
                 psMetadataAddF32(md, PS_LIST_TAIL, field[i].name, 0, "", atof(data));
-            } else if (pType == PS_META_F64) {
+            } else if (pType == PS_DATA_F64) {
                 psMetadataAddF64(md, PS_LIST_TAIL, field[i].name, 0, "", atof(data));
-            } else if (pType == PS_META_BOOL) {
+            } else if (pType == PS_DATA_BOOL) {
                 psMetadataAdd(md, PS_LIST_TAIL, field[i].name, pType, "", atoi(data));
             } else {
@@ -710 +710 @@
         // column as an psArray of strings; otherwise fetch the column as a
         // psVector.
-        if (pType == PS_META_STR) {
-            // PS_META_UNKNOWN -> PS_META_ARRAY ?
+        if (pType == PS_DATA_STRING) {
+            // PS_DATA_UNKNOWN -> PS_DATA_ARRAY ?
             column = psDBSelectColumn(dbh, tableName, field[i].name, 0);
             psMetadataAddArray(table, PS_LIST_TAIL, field[i].name, 0, "", column);
@@ -946 +946 @@
                               ? (my_bool *)&isNull
                               : NULL;
-        } else if (item->type == PS_META_STR) {
+        } else if (item->type == PS_DATA_STRING) {
             // convert NaNs to NULL and set the buffer_length for strings
 
@@ -957 +957 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_TYPE , true,
-                    "FIXME: Only type of PS_TYPE_S32 (PS_META_S32), "
-                    "PS_TYPE_F32 (PS_META_F32), PS_TYPE_F64 (PS_META_F64), "
-                    "PS_TYPE_BOOL (PS_META_BOOL), "
-                    "and PS_META_STR are supported.");
+                    "FIXME: Only type of PS_TYPE_S32 (PS_DATA_S32), "
+                    "PS_TYPE_F32 (PS_DATA_F32), PS_TYPE_F64 (PS_DATA_F64), "
+                    "PS_TYPE_BOOL (PS_DATA_BOOL), "
+                    "and PS_DATA_STRING are supported.");
 
             psFree(cursor);
@@ -1002 +1002 @@
     // find column name and type
     while ((item = psListGetAndIncrement(cursor))) {
-        if ((item->type == PS_META_S32)  || (item->type == PS_META_F32) || (item->type == PS_META_F64) ||
+        if ((item->type == PS_DATA_S32)  || (item->type == PS_DATA_F32) || (item->type == PS_DATA_F64) ||
                 (item->type == PS_TYPE_S32)  || (item->type == PS_TYPE_F32) || (item->type == PS_TYPE_F64) ||
-                (item->type == PS_TYPE_BOOL) || (item->type == PS_META_BOOL)) {
+                (item->type == PS_TYPE_BOOL) || (item->type == PS_DATA_BOOL)) {
             // + column name + _ + column type
             colType = psDBPTypeToSQL(item->type);
             psStringAppend(&query, "%s %s", item->name, colType);
             psFree(colType);
-        } else if (item->type == PS_META_STR) {
+        } else if (item->type == PS_DATA_STRING) {
             // + column name + _ + varchar( + length + )
             psStringAppend(&query, "%s VARCHAR(%s)", item->name, item->data.V);
         } else {
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    "FIXME: Only type of PS_META_S32, PS_META_F32, PS_META_F64, PS_META_BOOL, "
-                    "and PS_META_STR are supported, (not %d).", item->type);
+                    "FIXME: Only type of PS_DATA_S32, PS_DATA_F32, PS_DATA_F64, PS_DATA_BOOL, "
+                    "and PS_DATA_STRING are supported, (not %d).", item->type);
 
             psFree(query);
@@ -1243 +1243 @@
     while ((item = psListGetAndIncrement(cursor))) {
         // item->data must be a string
-        if ((item->type == PS_META_S32) || (item->type == PS_TYPE_S32)) {
+        if ((item->type == PS_DATA_S32) || (item->type == PS_TYPE_S32)) {
             psStringAppend(&query, "%s=%d", item->name, (int)(item->data.S32));
-        } else if ((item->type == PS_META_F32) || (item->type == PS_TYPE_F32)) {
+        } else if ((item->type == PS_DATA_F32) || (item->type == PS_TYPE_F32)) {
             psStringAppend(&query, "%s=%g", item->name, (double)(item->data.F32));
-        } else if ((item->type == PS_META_F64) || (item->type == PS_TYPE_F64)) {
+        } else if ((item->type == PS_DATA_F64) || (item->type == PS_TYPE_F64)) {
             psStringAppend(&query, "%s=%g", item->name, (double)(item->data.F64));
-        } else if ((item->type == PS_META_BOOL) || (item->type == PS_TYPE_BOOL)) {
+        } else if ((item->type == PS_DATA_BOOL) || (item->type == PS_TYPE_BOOL)) {
             psStringAppend(&query, "%s=%d", item->name, (int)(item->data.B));
-        } else if (item->type == PS_META_STR) {
+        } else if (item->type == PS_DATA_STRING) {
             // + column name + _ + like + _ + ' + value + '
             if (*(char *)item->data.V == '\0') {
@@ -1264 +1264 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    "Only types PS_META_S32, PS_META_F32, PS_META_F64, PS_META_BOOL, PS_META_STR are supported");
+                    "Only types PS_DATA_S32, PS_DATA_F32, PS_DATA_F64, PS_DATA_BOOL, PS_DATA_STRING are supported");
 
             psFree(cursor);
@@ -1440 +1440 @@
         psDBAddToLookupTable(lookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
         psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,"TINYINT");
-        psDBAddToLookupTable(lookupTable, PS_META_STR, "VARCHAR");
+        psDBAddToLookupTable(lookupTable, PS_DATA_STRING, "VARCHAR");
     }
 
@@ -1483 +1483 @@
 
         // Add BLOB & TEXT reverse mappings
-        value = psDBIntToString((psU64)PS_META_STR);
+        value = psDBIntToString((psU64)PS_DATA_STRING);
         psHashAdd(lookupTable, "BLOB",    value);
         psHashAdd(lookupTable, "TEXT",    value);
@@ -1584 +1584 @@
         // psDBAddVoidToLookupTable(lookupTable, PS_TYPE_PTR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
 
-        psDBAddVoidToLookupTable(lookupTable, PS_META_STR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_VEC,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_IMG,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_HASH,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_LOOKUPTABLE,
+        psDBAddVoidToLookupTable(lookupTable, PS_DATA_STRING,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(lookupTable, PS_DATA_VECTOR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(lookupTable, PS_DATA_IMAGE,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(lookupTable, PS_DATA_HASH,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(lookupTable, PS_DATA_LOOKUPTABLE,
                                  psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_JPEG,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_PNG,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_ASTROM, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_META_UNKNOWN,psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_JPEG,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_PNG,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_ASTROM, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(lookupTable, PS_DATA_UNKNOWN,psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     }
 

trunk/psLib/src/db/psDB.h

@@ -10 +10 @@
  *  @author Joshua Hoblitt
  *
- *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-26 20:00:57 $
+ *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-26 21:13:16 $
  *
  *  Copyright 2005 Joshua Hoblitt, University of Hawaii
@@ -104 +104 @@
  * type is give by the psMetadataItem.type and psMetadataItem.ptype entries.  A
  * lookup table should be used to convert from PSLib types into MySQL
- * compatible SQL data types.  For example, a PS_META_STR would map to an SQL99
- * varchar.  If the value of type is PS_META_STR then the psMetadataItem.data
+ * compatible SQL data types.  For example, a PS_DATA_STRING would map to an SQL99
+ * varchar.  If the value of type is PS_DATA_STRING then the psMetadataItem.data
  * element is set to a string with the length for the field written as a text
  * string.  The value of the psMetadataItem.data element is unused for the
- * PS_META_PRIMITIVE types.  Other psMetadata types beyond PS_META_STR and
+ * PS_META_PRIMITIVE types.  Other psMetadata types beyond PS_DATA_STRING and
  * PS_META_PRIMITIVE are not allowed in a table definition.
  *
@@ -170 +170 @@
  * values, one per row.
  *
- * Currently, the "where" specification only supports the PS_META_STR type.
+ * Currently, the "where" specification only supports the PS_DATA_STRING type.
  * The string value can be a SQL match pattern, e.g. "%foo%", or an empty
  * string, e.g. "", to match NULL field values.
@@ -189 +189 @@
  * The "row" specification uses the psMetadataItem name as the column name.
  * The field values may be specified in any order.  psMetadata types beyond
- * PS_META_STR and PS_META_PRIMITIVE are not supported.  If fields are
+ * PS_DATA_STRING and PS_META_PRIMITIVE are not supported.  If fields are
  * specified in "row" that do not exist in "tableName", the insert will fail.
  *

trunk/psLib/src/fits/psFits.c

@@ -1 @@
-/** @file  psFits.c
+/** @file  psFits.cr
  *
  *  @brief Contains Fits I/O routines
@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-22 23:19:38 $
+ *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-26 21:13:22 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -156 +156 @@
 }
 
-static bool convertMetadataTypeToBinaryTForm(psMetadataType type, char** fitsType)
+static bool convertMetadataTypeToBinaryTForm(psDataType type, char** fitsType)
 {
     switch (type) {
-    case PS_META_BOOL:
+    case PS_DATA_BOOL:
         *fitsType = psStringCopy("1L");
         break;
-    case PS_META_S32:
+    case PS_DATA_S32:
         *fitsType = psStringCopy("1J");
         break;
-    case PS_META_F32:
+    case PS_DATA_F32:
         *fitsType = psStringCopy("1E");
         break;
-    case PS_META_F64:
+    case PS_DATA_F64:
         *fitsType = psStringCopy("1D");
         break;
-    case PS_META_STR:
+    case PS_DATA_STRING:
         *fitsType = psStringCopy("1A");
         break;
@@ -510 +510 @@
                                         PS_LIST_TAIL,
                                         keyName,
-                                        PS_META_S32 | PS_META_DUPLICATE_OK,
+                                        PS_DATA_S32 | PS_META_DUPLICATE_OK,
                                         keyComment,
                                         atoi(keyValue));
@@ -520 +520 @@
                                         PS_LIST_TAIL,
                                         keyName,
-                                        PS_META_F64 | PS_META_DUPLICATE_OK,
+                                        PS_DATA_F64 | PS_META_DUPLICATE_OK,
                                         keyComment,
                                         atof(keyValue));
@@ -531 +531 @@
                                             PS_LIST_TAIL,
                                             keyName,
-                                            PS_META_STR | PS_META_DUPLICATE_OK,
+                                            PS_DATA_STRING | PS_META_DUPLICATE_OK,
                                             keyComment,
                                             keyValue+1);
@@ -538 +538 @@
                                             PS_LIST_TAIL,
                                             keyName,
-                                            PS_META_STR | PS_META_DUPLICATE_OK,
+                                            PS_DATA_STRING | PS_META_DUPLICATE_OK,
                                             keyComment,
                                             keyValue);
@@ -548 +548 @@
                                         PS_LIST_TAIL,
                                         keyName,
-                                        PS_META_BOOL | PS_META_DUPLICATE_OK,
+                                        PS_DATA_BOOL | PS_META_DUPLICATE_OK,
                                         keyComment,
                                         tempBool);
@@ -1053 +1053 @@
     while ( (item=psListGetAndIncrement(iter)) != NULL ) {
         switch (item->type) {
-        case PS_META_BOOL: {
+        case PS_DATA_BOOL: {
                 int value = item->data.B;
                 fits_update_key(fits->fd,
@@ -1063 +1063 @@
                 break;
             }
-        case PS_META_S32:
+        case PS_DATA_S32:
             fits_update_key(fits->fd,
                             TINT,
@@ -1071 +1071 @@
                             &status);
             break;
-        case PS_META_F32:
+        case PS_DATA_F32:
             fits_update_key(fits->fd,
                             TFLOAT,
@@ -1079 +1079 @@
                             &status);
             break;
-        case PS_META_F64:
+        case PS_DATA_F64:
             fits_update_key(fits->fd,
                             TDOUBLE,
@@ -1087 +1087 @@
                             &status);
             break;
-        case PS_META_STR:
+        case PS_DATA_STRING:
             fits_update_key(fits->fd,
                             TSTRING,
@@ -1192 +1192 @@
                         col, name, typecode, repeat, (double)value); \
                 psMetadataAdd(data,PS_LIST_TAIL, name, \
-                              PS_META_##TYPE, \
+                              PS_DATA_##TYPE, \
                               "", (ps##TYPE)value); \
                 break; \
@@ -1214 +1214 @@
                     if (anynul == 0) {
                         psMetadataAdd(data,PS_LIST_TAIL, name,
-                                      PS_META_STR,
+                                      PS_DATA_STRING,
                                       "", value);
                     }
@@ -1494 +1494 @@
                                    PS_LIST_HEAD,true);
             while ( (item=psListGetAndIncrement(iter)) != NULL) {
-                if (PS_META_IS_PRIMITIVE(item->type) || item->type == PS_META_STR) {
+                if (PS_DATA_IS_PRIMITIVE(item->type) || item->type == PS_DATA_STRING) {
                     bool found = false;
                     psMetadataItem* fItem = NULL;
@@ -1506 +1506 @@
                     if (! found) {
                         psArrayAdd(columns, columns->nalloc, item);
-                    } else if (item->type == PS_META_STR &&
+                    } else if (item->type == PS_DATA_STRING &&
                                strlen(fItem->data.V) > strlen(item->data.V)) {
                         // got to keep the longest string value as to know what size to create the table column
@@ -1567 +1567 @@
         int row;
         item = columns->data[n];
-        if (PS_META_IS_PRIMITIVE(item->type)) {
+        if (PS_DATA_IS_PRIMITIVE(item->type)) {
             psVector* col = NULL;
             psArray* colArray = NULL;
             switch (item->type) {
-            case PS_META_S32:
+            case PS_DATA_S32:
                 col = psVectorAlloc(table->n, PS_TYPE_S32);
                 for (row = 0; row < table->n; row++) {
@@ -1587 +1587 @@
                 break;
 
-            case PS_META_F32:
+            case PS_DATA_F32:
                 col = psVectorAlloc(table->n, PS_TYPE_F32);
                 for (row = 0; row < table->n; row++) {
@@ -1603 +1603 @@
                 break;
 
-            case PS_META_F64:
+            case PS_DATA_F64:
                 col = psVectorAlloc(table->n, PS_TYPE_F64);
                 for (row = 0; row < table->n; row++) {
@@ -1619 +1619 @@
                 break;
 
-            case PS_META_BOOL:
+            case PS_DATA_BOOL:
                 col = psVectorAlloc(table->n, PS_TYPE_BOOL);
                 for (row = 0; row < table->n; row++) {
@@ -1635 +1635 @@
                 break;
 
-            case PS_META_STR:
+            case PS_DATA_STRING:
                 colArray = psArrayAlloc(table->n);
                 for (row = 0; row < table->n; row++) {
@@ -1656 +1656 @@
             }
             psFree(col);
-        } else if (item->type == PS_META_STR) {
+        } else if (item->type == PS_DATA_STRING) {
             psArray* col = psArrayAlloc(table->n);
             for (row = 0; row < table->n; row++) {
@@ -1716 +1716 @@
 
     while ( (item=psMetadataGetAndIncrement(iter)) != NULL) {
-        if (PS_META_IS_PRIMITIVE(item->type)) {
-            // operating on primitive data type, i.e., not a complex object
+        if (PS_DATA_IS_PRIMITIVE(item->type) || item->type == PS_DATA_STRING) {
+            // operating on primitive data type or string, i.e., not a complex object
             int colnum = 0;
 
             if ( fits_get_colnum(fits->fd, CASESEN, item->name, &colnum, &status) == 0) {
                 // cooresponding column found in table
-                int dataType = 0;
-                convertPsTypeToFits(item->type, NULL, NULL, &dataType);
+                int dataType = TSTRING; // assume string unless it is a primative type
+                if (PS_DATA_IS_PRIMITIVE(item->type)) {
+                    convertPsTypeToFits(item->type, NULL, NULL, &dataType);
+                }
 
                 if (fits_write_col(fits->fd, dataType, colnum, row+1, 1, 1, &item->data,&status) != 0) {

trunk/psLib/src/sys/psType.h

@@ -10 +10 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-15 21:22:22 $
+*  @version $Revision: 1.41 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-26 21:13:25 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -105 +105 @@
     PS_DATA_ARRAY,                     ///< psArray
     PS_DATA_BITSET,                    ///< psBitSet
-    //    PS_DATA_CELL,                      ///< psCell
-    //    PS_DATA_CHIP,                      ///< psChip
+    PS_DATA_CELL,                      ///< psCell
+    PS_DATA_CHIP,                      ///< psChip
     PS_DATA_CUBE,                      ///< psCube
     PS_DATA_FITS,                      ///< psFits
@@ -127 +127 @@
     PS_DATA_POLYNOMIAL4D,              ///< psPolynomial4D
     PS_DATA_PROJECTION,                ///< psProjection
-    //    PS_DATA_READOUT,                   ///< psReadout
-    //    PS_DATA_REGION,                    ///< psRegion
+    PS_DATA_READOUT,                   ///< psReadout
+    PS_DATA_REGION,                    ///< psRegion
     PS_DATA_SCALAR,                    ///< psScalar
     PS_DATA_SPHERE,                    ///< psSphere

trunk/psLib/src/types/psMetadata.c

@@ -12 +12 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.84 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-22 02:32:00 $
+ *  @version $Revision: 1.85 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-26 21:13:26 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -75 +75 @@
 {
 
-    if (existing != NULL && existing->type == PS_META_MULTI) {
+    if (existing != NULL && existing->type == PS_DATA_METADATA_MULTI) {
         return existing;
     }
@@ -83 +83 @@
 
     psMetadataItem* item = psMetadataItemAlloc(key,
-                           PS_META_MULTI,
+                           PS_DATA_METADATA_MULTI,
                            "",
                            newList);
@@ -113 +113 @@
     psMemDecrRefCounter(metadataItem->comment);
 
-    if(!PS_META_IS_PRIMITIVE(type)) {
+    if(!PS_DATA_IS_PRIMITIVE(type)) {
         psFree(metadataItem->data.V);
     }
@@ -178 +178 @@
 }
 
-METADATAITEM_ALLOC_TYPE(Str,const char*,PS_META_STR)
-METADATAITEM_ALLOC_TYPE(F32,psF32,PS_META_F32)
-METADATAITEM_ALLOC_TYPE(F64,psF64,PS_META_F64)
-METADATAITEM_ALLOC_TYPE(S32,psS32,PS_META_S32)
-METADATAITEM_ALLOC_TYPE(Bool,psBool,PS_META_BOOL)
+METADATAITEM_ALLOC_TYPE(Str,const char*,PS_DATA_STRING)
+METADATAITEM_ALLOC_TYPE(F32,psF32,PS_DATA_F32)
+METADATAITEM_ALLOC_TYPE(F64,psF64,PS_DATA_F64)
+METADATAITEM_ALLOC_TYPE(S32,psS32,PS_DATA_S32)
+METADATAITEM_ALLOC_TYPE(Bool,psBool,PS_DATA_BOOL)
 
 psMetadataItem* psMetadataItemAllocV(const char *name,
@@ -217 +217 @@
     // Allocate and set metadata item name
     metadataItem->name = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH);
-    vsprintf(metadataItem->name, name, argPtr);
+    vsnprintf(metadataItem->name, MAX_STRING_LENGTH, name, argPtr);
 
     // Set metadata item value
     switch(metadataItem->type) {
-    case PS_META_BOOL:
+    case PS_DATA_BOOL:
         metadataItem->data.B = (psBool)va_arg(argPtr, psS32);
         break;
-    case PS_META_S32:
+    case PS_DATA_S32:
         metadataItem->data.S32 = (psS32)va_arg(argPtr, psS32);
         break;
-    case PS_META_F32:
+    case PS_DATA_F32:
         metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64);
         break;
-    case PS_META_F64:
+    case PS_DATA_F64:
         metadataItem->data.F64 = (psF64)va_arg(argPtr, psF64);
         break;
-    case PS_META_STR:
+    case PS_DATA_STRING:
         // Perform copy of input strings
         metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH);
         break;
-    case PS_META_LIST:
-    case PS_META_VEC:
-    case PS_META_HASH:
-    case PS_META_LOOKUPTABLE:
-    case PS_META_JPEG:
-    case PS_META_PNG:
-    case PS_META_ASTROM:
-    case PS_META_UNKNOWN:
-    case PS_META_META:
-    case PS_META_MULTI:
-    case PS_META_ARRAY:
-    case PS_META_TIME:
+    case     PS_DATA_ARRAY:                     ///< psArray
+    case     PS_DATA_BITSET:                    ///< psBitSet
+    case     PS_DATA_CELL:                      ///< psCell
+    case     PS_DATA_CHIP:                      ///< psChip
+    case     PS_DATA_CUBE:                      ///< psCube
+    case     PS_DATA_FITS:                      ///< psFits
+    case     PS_DATA_HASH:                      ///< psHash
+    case     PS_DATA_HISTOGRAM:                 ///< psHistogram
+    case     PS_DATA_IMAGE:                     ///< psImage
+    case     PS_DATA_KERNEL:                    ///< psKernel
+    case     PS_DATA_LIST:                      ///< psList
+    case     PS_DATA_LOOKUPTABLE:               ///< psLookupTable
+    case     PS_DATA_METADATA:                  ///< psMetadata
+    case     PS_DATA_METADATAITEM:              ///< psMetadataItem
+    case     PS_DATA_MINIMIZATION:              ///< psMinimization
+    case     PS_DATA_PIXELS:                    ///< psPixels
+    case     PS_DATA_PLANE:                     ///< psPlane
+    case     PS_DATA_PLANEDISTORT:              ///< psPlaneDistort
+    case     PS_DATA_PLANETRANSFORM:            ///< psPlaneTransform
+    case     PS_DATA_POLYNOMIAL1D:              ///< psPolynomial1D
+    case     PS_DATA_POLYNOMIAL2D:              ///< psPolynomial2D
+    case     PS_DATA_POLYNOMIAL3D:              ///< psPolynomial3D
+    case     PS_DATA_POLYNOMIAL4D:              ///< psPolynomial4D
+    case     PS_DATA_PROJECTION:                ///< psProjection
+    case     PS_DATA_READOUT:                   ///< psReadout
+    case     PS_DATA_REGION:                    ///< psRegion
+    case     PS_DATA_SCALAR:                    ///< psScalar
+    case     PS_DATA_SPHERE:                    ///< psSphere
+    case     PS_DATA_SPHEREROT:                 ///< psSphereTransform
+    case     PS_DATA_SPLINE1D:                  ///< psSpline1D
+    case     PS_DATA_STATS:                     ///< psStats
+    case     PS_DATA_TIME:                      ///< psTime
+    case     PS_DATA_VECTOR:                    ///< psVector
+    case     PS_DATA_METADATA_MULTI:
         // Copy of input data not performed due to variability of data types
         metadataItem->data.V = psMemIncrRefCounter(va_arg(argPtr, psPtr));
@@ -313 +335 @@
     existingEntry = (psMetadataItem*)psHashLookup(mdTable, key);
 
-    if (item->type == PS_META_MULTI) {
-        // the incoming entry is PS_META_MULTI
-
-        // force the hash entry to be PS_META_MULTI
+    if (item->type == PS_DATA_METADATA_MULTI) {
+        // the incoming entry is PS_DATA_METADATA_MULTI
+
+        // force the hash entry to be PS_DATA_METADATA_MULTI
         existingEntry = makeMetaMulti(mdTable,key,existingEntry);
 
@@ -335 +357 @@
     // how the item is added to the hash depends on prior existence, flags, etc.
     if(existingEntry != NULL) { // prior existence
-        if (existingEntry->type == PS_META_MULTI || (flags & PS_META_DUPLICATE_OK) != 0) {
+        if (existingEntry->type == PS_DATA_METADATA_MULTI || (flags & PS_META_DUPLICATE_OK) != 0) {
             // duplicate entries allowed - add another entry.
 
-            // make sure the existing entry is PS_META_MULTI
+            // make sure the existing entry is PS_DATA_METADATA_MULTI
             existingEntry = makeMetaMulti(mdTable,key,existingEntry);
 
@@ -429 +451 @@
 }
 
-METADATA_ADD_TYPE(Bool,psBool,PS_META_BOOL)
-METADATA_ADD_TYPE(S32,psS32,PS_META_S32)
-METADATA_ADD_TYPE(F32,psF32,PS_META_F32)
-METADATA_ADD_TYPE(F64,psF64,PS_META_F64)
-METADATA_ADD_TYPE(List,psList*,PS_META_LIST)
-METADATA_ADD_TYPE(Str,const char*,PS_META_STR)
-METADATA_ADD_TYPE(Vector,psVector*,PS_META_VEC)
-METADATA_ADD_TYPE(Image,psImage*,PS_META_IMG)
-METADATA_ADD_TYPE(Hash,psHash*,PS_META_HASH)
-METADATA_ADD_TYPE(LookupTable,psLookupTable*,PS_META_LOOKUPTABLE)
-METADATA_ADD_TYPE(Unknown,void*,PS_META_UNKNOWN)
-METADATA_ADD_TYPE(Metadata,psMetadata*,PS_META_META)
-METADATA_ADD_TYPE(Array,psArray*,PS_META_ARRAY)
-METADATA_ADD_TYPE(Time,psTime*,PS_META_TIME)
+METADATA_ADD_TYPE(Bool,psBool,PS_DATA_BOOL)
+METADATA_ADD_TYPE(S32,psS32,PS_DATA_S32)
+METADATA_ADD_TYPE(F32,psF32,PS_DATA_F32)
+METADATA_ADD_TYPE(F64,psF64,PS_DATA_F64)
+METADATA_ADD_TYPE(List,psList*,PS_DATA_LIST)
+METADATA_ADD_TYPE(Str,const char*,PS_DATA_STRING)
+METADATA_ADD_TYPE(Vector,psVector*,PS_DATA_VECTOR)
+METADATA_ADD_TYPE(Image,psImage*,PS_DATA_IMAGE)
+METADATA_ADD_TYPE(Hash,psHash*,PS_DATA_HASH)
+METADATA_ADD_TYPE(LookupTable,psLookupTable*,PS_DATA_LOOKUPTABLE)
+METADATA_ADD_TYPE(Unknown,void*,PS_DATA_UNKNOWN)
+METADATA_ADD_TYPE(Metadata,psMetadata*,PS_DATA_METADATA)
+METADATA_ADD_TYPE(Array,psArray*,PS_DATA_ARRAY)
+METADATA_ADD_TYPE(Time,psTime*,PS_DATA_TIME)
 
 bool psMetadataRemove(psMetadata *md,
@@ -464 +486 @@
             return false;
         }
-        if (entry->type == PS_META_MULTI) {
+        if (entry->type == PS_DATA_METADATA_MULTI) {
             psMetadataItem* listItem;
             psListIterator* iter = psListIteratorAlloc(
@@ -499 +521 @@
         }
 
-        if (tableItem->type == PS_META_MULTI) {
+        if (tableItem->type == PS_DATA_METADATA_MULTI) {
             // multiple entries with same key, remove just the specified one
             psListRemoveData(tableItem->data.list, entry);
@@ -548 +570 @@
         return NULL;
     }
-    if (metadataItem->type == PS_META_MULTI) {
+    if (metadataItem->type == PS_DATA_METADATA_MULTI) {
         // if multiple keys found, use the first.
         metadataItem = (psMetadataItem*)((metadataItem->data.list)->head);
     }
 
-    if(PS_META_IS_PRIMITIVE(metadataItem->type)) {
+    if(PS_DATA_IS_PRIMITIVE(metadataItem->type)) {
         if (status) {
             *status = false;
@@ -583 +605 @@
         return 0; \
     } \
-    if (metadataItem->type == PS_META_MULTI) { \
+    if (metadataItem->type == PS_DATA_METADATA_MULTI) { \
         /* if multiple keys found, use the first. */ \
         metadataItem = (psMetadataItem*)((metadataItem->data.list)->head); \
@@ -589 +611 @@
     \
     switch (metadataItem->type) { \
-    case PS_META_S32: \
+    case PS_DATA_S32: \
         value = (ps##TYPE)metadataItem->data.S32; \
         break; \
-    case PS_META_F32: \
+    case PS_DATA_F32: \
         value = (ps##TYPE)metadataItem->data.F32; \
         break; \
-    case PS_META_F64: \
+    case PS_DATA_F64: \
         value = (ps##TYPE)metadataItem->data.F64; \
         break; \
-    case PS_META_BOOL: \
+    case PS_DATA_BOOL: \
         if (metadataItem->data.B) { \
             value = 1; \
@@ -793 +815 @@
             psError(PS_ERR_IO, true, "Couldn't find %s in the metadata.\n");
         }
-    } else if (item->type != PS_META_META) {
+    } else if (item->type != PS_DATA_METADATA) {
         // The value at the key isn't metadata
         if (status) {
             *status = false;
         } else {
-            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_META_META, as expected.\n");
+            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_DATA_META, as expected.\n");
         }
         value = NULL;
@@ -825 +847 @@
             psError(PS_ERR_IO, true, "Couldn't find %s in the metadata.\n");
         }
-    } else if (item->type != PS_META_STR) {
+    } else if (item->type != PS_DATA_STRING) {
         // The value at the key isn't of the desired type
         if (status) {
             *status = false;
         } else {
-            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_META_STR, as expected.\n");
+            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_DATA_STRING, as expected.\n");
         }
         value = NULL;
@@ -860 +882 @@
         printf(": ");
         switch (item->type) {
-        case PS_META_STR:
+        case PS_DATA_STRING:
             printf("%s", (char*)(item->data.V));
             break;
-        case PS_META_BOOL:
+        case PS_DATA_BOOL:
             if (item->data.B) {
                 printf("True");
@@ -870 +892 @@
             }
             break;
-        case PS_META_S32:
+        case PS_DATA_S32:
             printf("%d", item->data.S32);
             break;
-        case PS_META_F32:
+        case PS_DATA_F32:
             printf("%f", item->data.F32);
             break;
-        case PS_META_F64:
+        case PS_DATA_F64:
             printf("%f", item->data.F64);
             break;
-        case PS_META_META:
+        case PS_DATA_METADATA:
             printf("\n");
             psMetadataPrint(item->data.V, level + 1);
@@ -981 +1003 @@
     {
         // Only doing a representative set of types
-    case PS_META_S32:
+    case PS_DATA_S32:
         newItem = psMetadataItemAlloc(item->name, item->type, item->comment, atoi(argv[argnum]));
         psArgumentRemove(argnum, argc, argv);
         break;
-    case PS_META_F32:
+    case PS_DATA_F32:
         newItem = psMetadataItemAlloc(item->name, item->type, item->comment, atof(argv[argnum]));
         psArgumentRemove(argnum, argc, argv);
         break;
-    case PS_META_BOOL:
+    case PS_DATA_BOOL:
         // Turn option on; no optional argument to remove
         newItem = psMetadataItemAlloc(item->name, item->type, item->comment, true);
         break;
         // XXX: Include the other numerical types
-    case PS_META_STR: {
+    case PS_DATA_STRING: {
             //psString string = psStringCopy(argv[argnum]); // Get the argument into PS memory management
             //psFree(string);
@@ -1032 +1054 @@
         if (argItem) {
             psArgumentRemove(i, argc, argv); // Remove the switch
-            if (argItem->type != PS_META_MULTI) {
-                if (argItem->type != PS_META_BOOL && *argc < i + 1) {
+            if (argItem->type != PS_DATA_METADATA_MULTI) {
+                if (argItem->type != PS_DATA_BOOL && *argc < i + 1) {
                     psError(PS_ERR_IO, true, "Required argument for %s is missing.\n", argItem->name);
                     // XXX: Cleanup before returning
@@ -1100 +1122 @@
         switch (oldItem->type) {
             // Only doing a representative set of types
-        case PS_META_S32:
+        case PS_DATA_S32:
             oldItem->data.S32 = newItem->data.S32;
             break;
-        case PS_META_F32:
+        case PS_DATA_F32:
             oldItem->data.F32 = newItem->data.F32;
             break;
-        case PS_META_BOOL:
+        case PS_DATA_BOOL:
             oldItem->data.B = newItem->data.B;
             break;
             // XXX: Include the other numerical types
-        case PS_META_STR:
+        case PS_DATA_STRING:
             psFree(oldItem->data.V);
             oldItem->data.V = psMemIncrRefCounter(newItem->data.V);
             break;
-        case PS_META_MULTI: {
+        case PS_DATA_METADATA_MULTI: {
                 psList *newMulti = psMemIncrRefCounter(newItem->data.V); // The new list of MULTI
                 psList *oldMulti = oldItem->data.V; // The old list of MULTI
@@ -1128 +1150 @@
                     switch (oldMultiItem->type) {
                         // Only doing a representative set of types
-                    case PS_META_S32:
+                    case PS_DATA_S32:
                         oldItem->data.S32 = newItem->data.S32;
                         break;
-                    case PS_META_F32:
+                    case PS_DATA_F32:
                         oldItem->data.F32 = newItem->data.F32;
                         break;
                         // XXX: Include the other numerical types
-                    case PS_META_STR:
+                    case PS_DATA_STRING:
                         psFree(oldItem->data.V);
                         oldItem->data.V = psMemIncrRefCounter(newItem->data.V);
@@ -1166 +1188 @@
     switch (arg->type) {
         // Only doing a representative set of types
-    case PS_META_S32:
+    case PS_DATA_S32:
         return arg->data.S32 >= 0 ? (int)log10f((float)arg->data.S32) + 1 :
                (int)log10f(-(float)arg->data.S32) + 2;
         // XXX: Other numerical types
-    case PS_META_F32:
+    case PS_DATA_F32:
         return arg->data.F32 >= 0 ? 12 : 13; // -d.dddddde?dd
-    case PS_META_F64:
+    case PS_DATA_F64:
         return arg->data.F64 >= 0 ? 12 : 13; // -d.dddddde?dd
-    case PS_META_BOOL:
+    case PS_DATA_BOOL:
         return arg->data.B ? 4 : 5;
-    case PS_META_STR:
+    case PS_DATA_STRING:
         return strlen(arg->data.V);
     default:
@@ -1231 +1253 @@
         switch (argItem->type) {
             // Only doing a representative set of types
-        case PS_META_S32:
+        case PS_DATA_S32:
             printf("%d", argItem->data.S32);
             break;
             // XXX: Other numerical types
-        case PS_META_F32:
+        case PS_DATA_F32:
             printf("%.6e", argItem->data.F32);
             break;
-        case PS_META_F64:
+        case PS_DATA_F64:
             printf("%.6e", argItem->data.F64);
             break;
-        case PS_META_BOOL:
+        case PS_DATA_BOOL:
             if (argItem->data.B) {
                 printf("TRUE");
@@ -1248 +1270 @@
             }
             break;
-        case PS_META_STR:
+        case PS_DATA_STRING:
             printf("%s", (char*)(argItem->data.V));
             break;

trunk/psLib/src/types/psMetadata.h

@@ -11 +11 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-15 21:22:22 $
+*  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-26 21:13:26 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -32 +32 @@
 /// @{
 
-/** Metadata item type.
- *
- * Enumeration for maintaining metadata item types.
- */
-typedef enum {
-    PS_META_S32 = PS_TYPE_S32,         ///< psS32 primitive data.
-    PS_META_F32 = PS_TYPE_F32,         ///< psF32 primitive data.
-    PS_META_F64 = PS_TYPE_F64,         ///< psF64 primitive data.
-    PS_META_BOOL = PS_TYPE_BOOL,       ///< psBool primitive data.
-    PS_META_LIST = 0x10000,            ///< List data (Stored as item.data.list).
-    PS_META_STR,                       ///< String data (Stored as item.data.V).
-    PS_META_VEC,                       ///< Vector data (Stored as item.data.V).
-    PS_META_IMG,                       ///< Image data (Stored as item.data.V).
-    PS_META_HASH,                      ///< Hash data (Stored as item.data.V).
-    PS_META_LOOKUPTABLE,               ///< Lookup table data (Stored as item.data.V).
-    PS_META_JPEG,                      ///< JPEG data (Stored as item.data.V).
-    PS_META_PNG,                       ///< PNG data (Stored as item.data.V).
-    PS_META_ASTROM,                    ///< Astrometric coefficients (Stored as item.data.V).
-    PS_META_UNKNOWN,                   ///< Other data (Stored as item.data.V).
-    PS_META_MULTI,                     ///< Used internally, do not create an metadata item of this type.
-    PS_META_META = PS_DATA_METADATA,   ///< Metadata data (Stored as item.data.md).
-    PS_META_ARRAY,                     ///< Array data (Stored as item.data.V).
-    PS_META_TIME                       ///< psTime data (Stored as item.data.V).
-} psMetadataType;
-#define PS_META_IS_PRIMITIVE(TYPE) \
-(TYPE == PS_META_S32 || \
- TYPE == PS_META_F32 || \
- TYPE == PS_META_F64 || \
- TYPE == PS_META_BOOL)
-
-#define PS_META_PRIMITIVE_TYPE(METATYPE) ( \
-        (METATYPE==PS_META_S32) ? PS_TYPE_S32 : \
-        (METATYPE==PS_META_F32) ? PS_TYPE_F32 : \
-        (METATYPE==PS_META_F64) ? PS_TYPE_F64 : \
-        (METATYPE==PS_META_BOOL) ? PS_TYPE_BOOL : 0 )
+#define PS_DATA_IS_PRIMITIVE(TYPE) \
+(TYPE == PS_DATA_S32 || \
+ TYPE == PS_DATA_F32 || \
+ TYPE == PS_DATA_F64 || \
+ TYPE == PS_DATA_BOOL)
+
+#define PS_DATA_PRIMITIVE_TYPE(DATATYPE) ( \
+        (DATATYPE==PS_DATA_S32 || DATATYPE==PS_DATA_F32 || \
+         DATATYPE==PS_DATA_F64 || DATATYPE==PS_DATA_BOOL) ? DATATYPE : 0)
+
 
 /** Option flags for psMetadata functions

trunk/psLib/src/types/psMetadataConfig.c

@@ -10 +10 @@
 *  @author Eric Van Alst, MHPCC
 *
-*  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-23 02:39:06 $
+*  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-26 21:13:26 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -411 +411 @@
                          const psMetadataItem* item)
 {
-    psMetadataType type;
+    psDataType type;
     psBool success = true;
 
@@ -436 +436 @@
     #define METADATAITEM_NUMERIC_CAST(FORMAT_TYPE) { \
         switch(type) { \
-        case PS_META_BOOL: \
+        case PS_DATA_BOOL: \
             fprintf(fd, format, (FORMAT_TYPE) item->data.B); \
             break; \
-        case PS_META_S32: \
+        case PS_DATA_S32: \
             fprintf(fd,format,(FORMAT_TYPE)  item->data.S32); \
             break; \
-        case PS_META_F32: \
+        case PS_DATA_F32: \
             fprintf(fd, format,(FORMAT_TYPE)  item->data.F32); \
             break; \
-        case PS_META_F64: \
+        case PS_DATA_F64: \
             fprintf(fd, format,(FORMAT_TYPE) item->data.F64); \
             break; \
@@ -478 +478 @@
         break;
     case 's':
-        if (type == PS_META_STR) {
+        if (type == PS_DATA_STRING) {
             fprintf(fd,format,(char*)item->data.V);
         } else {
@@ -573 +573 @@
         case 'I':
             success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
-                                    PS_META_S32 | PS_META_DUPLICATE_OK,
+                                    PS_DATA_S32 | PS_META_DUPLICATE_OK,
                                     keyComment, atoi(keyValue));
             break;
         case 'F':
             success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
-                                    PS_META_F64 | PS_META_DUPLICATE_OK,
+                                    PS_DATA_F64 | PS_META_DUPLICATE_OK,
                                     keyComment, atof(keyValue));
             break;
         case 'C':
             success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
-                                    PS_META_STR | PS_META_DUPLICATE_OK,
+                                    PS_DATA_STRING | PS_META_DUPLICATE_OK,
                                     keyComment, keyValue);
             break;
@@ -589 +589 @@
             tempBool = (keyValue[0] == 'T') ? 1 : 0;
             success = psMetadataAdd(output, PS_LIST_TAIL, keyName,
-                                    PS_META_BOOL | PS_META_DUPLICATE_OK,
+                                    PS_DATA_BOOL | PS_META_DUPLICATE_OK,
                                     keyComment, tempBool);
             break;
@@ -734 +734 @@
     psBool               returnValue   = true;
     psBool               addStatus     = false;
-    psMetadataType       mdType        = PS_META_UNKNOWN;
+    psDataType           mdType        = PS_DATA_UNKNOWN;
     psElemType           vectorType    = PS_TYPE_S8;
     char*                strType       = NULL;
@@ -769 +769 @@
         // Check if the keyName specifies a vector and if so use strType token to find vector type
         if(*keyName == '@') {
-            mdType = PS_META_VEC;
+            mdType = PS_DATA_VECTOR;
             // Get the type of vector
             if(!strncmp(strType, "U8", 2)) {
@@ -798 +798 @@
             }
         } else if(!strncmp(strType, "STR", 3)) {
-            mdType = PS_META_STR;
+            mdType = PS_DATA_STRING;
         } else if(!strncmp(strType, "BOOL", 4)) {
-            mdType = PS_META_BOOL;
+            mdType = PS_DATA_BOOL;
         } else if(!strncmp(strType, "S32", 3)) {
-            mdType = PS_META_S32;
+            mdType = PS_DATA_S32;
         } else if(!strncmp(strType, "F32", 3)) {
-            mdType = PS_META_F32;
+            mdType = PS_DATA_F32;
         } else if(!strncmp(strType, "F64", 3)) {
-            mdType = PS_META_F64;
+            mdType = PS_DATA_F64;
         } else if(!strncmp(strType, "MULTI", 5)) {
-            mdType = PS_META_MULTI;
+            mdType = PS_DATA_METADATA_MULTI;
         } else if(!strncmp(strType, "METADATA", 8)) {
-            mdType = PS_META_META;
+            mdType = PS_DATA_METADATA;
         } else if( !strncmp(strType, "PS_TIME_UTC", 12) || !strncmp(strType, "PS_TIME_TAI", 12)
                    || !strncmp(strType, "PS_TIME_UT1", 12) || !strncmp(strType, "PS_TIME_TT", 12)) {
-            mdType = PS_META_TIME;
+            mdType = PS_DATA_TIME;
         } else {
             // Search through user types
@@ -824 +824 @@
                         // Add metadata item
                         md = ((p_psParseLevelInfo*)(levelArray->data[*level]))->metadata;
-                        addStatus = psMetadataAdd(md,PS_LIST_TAIL,keyName,PS_META_META | flags,"",tempMeta);
+                        addStatus = psMetadataAdd(md,PS_LIST_TAIL,keyName,PS_DATA_METADATA | flags,"",tempMeta);
                         // Check for add failure
                         if (! addStatus) {
@@ -858 +858 @@
 
     // If type is not MULTI or META then get the value and comment
-    if((mdType != PS_META_MULTI) && (mdType != PS_META_META)) {
+    if((mdType != PS_DATA_METADATA_MULTI) && (mdType != PS_DATA_METADATA)) {
         // Get the metadata item value if there is one.
         status = 0;
@@ -893 +893 @@
     nonUniqueKeys = ((p_psParseLevelInfo*)(levelArray->data[*level]))->nonUniqueKeyArray;
     switch(mdType) {
-    case PS_META_STR:
+    case PS_DATA_STRING:
         addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
                                   mdType | flags,
                                   strComment, strValue);
         break;
-    case PS_META_BOOL:
+    case PS_DATA_BOOL:
         tempBool = parseBool(strValue, &status);
         if(!status) {
@@ -910 +910 @@
         }
         break;
-    case PS_META_F32:
-    case PS_META_F64:
+    case PS_DATA_F32:
+    case PS_DATA_F64:
         tempDbl = parseValue(strValue, &status);
         if(!status) {
@@ -924 +924 @@
         }
         break;
-    case PS_META_S32:
+    case PS_DATA_S32:
         tempInt = (psS32)parseValue(strValue, &status);
         if(!status) {
@@ -936 +936 @@
         }
         break;
-    case PS_META_TIME:
+    case PS_DATA_TIME:
         if( !strncmp(strType, "PS_TIME_UTC", 12) )
             timeType = PS_TIME_UTC;
@@ -957 +957 @@
         psFree(mTime);
         break;
-    case PS_META_VEC:
+    case PS_DATA_VECTOR:
         tempVec = parseVector(strValue, vectorType, &status);
         if(!status) {
@@ -970 +970 @@
         psFree(tempVec);
         break;
-    case PS_META_MULTI:
+    case PS_DATA_METADATA_MULTI:
         // Add key to non-unique array of keys
         // Check for duplicate MULTI lines
@@ -987 +987 @@
         psFree(tempStr);
         break;
-    case PS_META_META:
+    case PS_DATA_METADATA:
         // Create next level info
         nextLevelInfo = p_psParseLevelInfoAlloc();
@@ -1120 +1120 @@
                 addStatus = psMetadataAdd(upperLevelInfo->metadata,
                                           PS_LIST_TAIL,lowerLevelInfo->name,
-                                          PS_META_META | flags,
+                                          PS_DATA_METADATA | flags,
                                           "",
                                           lowerLevelInfo->metadata);
@@ -1242 +1242 @@
     while ( (item = psMetadataGetAndIncrement(iter)) ) {
         type = item->type;
-        if ( type == PS_META_STR)
+        if ( type == PS_DATA_STRING)
             type = PS_DATA_STRING;
-        if ( type == PS_META_VEC)
+        if ( type == PS_DATA_VECTOR)
             type = PS_DATA_VECTOR;
-        if ( type == PS_META_TIME)
+        if ( type == PS_DATA_TIME)
             type = PS_DATA_TIME;
-        if ( item->type == PS_META_META)
+        if ( item->type == PS_DATA_METADATA)
             type = PS_DATA_METADATA;
 

trunk/psLib/src/xml/psXML.c

@@ -10 +10 @@
 *  @author David Robbins, MHPCC
 *
-*  @version $Revision: 1.42 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-15 21:22:22 $
+*  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-26 21:13:28 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -68 +68 @@
     while ( item != NULL ) {
         type = item->type;
-        if ( type == PS_META_STR)
-            type = PS_DATA_STRING;
-        if ( type == PS_META_VEC)
-            type = PS_DATA_VECTOR;
-        if ( type == PS_META_TIME)
-            type = PS_DATA_TIME;
         switch (type) {
         case PS_DATA_BOOL: