IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4870


Ignore:
Timestamp:
Aug 24, 2005, 12:00:57 PM (21 years ago)
Author:
drobbin
Message:

Added functions psMetadataConfigFormat and psMetadataConfigWrite

Location:
trunk/psLib
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/psLib/src/types/psMetadata.c

    r4817 r4870  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.76 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-08-18 23:41:45 $
     14*  @version $Revision: 1.77 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-08-24 22:00:53 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    427427METADATA_ADD_TYPE(Array,psArray*,PS_META_ARRAY)
    428428
    429 psBool psMetadataRemove(psMetadata *md,
    430                         long where,
    431                         const char *key)
     429bool psMetadataRemove(psMetadata *md,
     430                      long where,
     431                      const char *key)
    432432{
    433433    PS_ASSERT_PTR_NON_NULL(md,NULL);
  • trunk/psLib/src/types/psMetadataConfig.c

    r4589 r4870  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-07-21 01:40:10 $
     12*  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-08-24 22:00:53 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    5858/** Maximum size of a string */
    5959#define MAX_STRING_LENGTH 256
     60#define MAXSTR 256
    6061
    6162
     
    11611162}
    11621163
     1164psString psMetadataConfigFormat(psMetadata *md)
     1165{
     1166    PS_ASSERT_PTR_NON_NULL(md, NULL);
     1167
     1168    psString newString = NULL;
     1169    psString newStr = NULL;
     1170    char mdString[2048];
     1171    psMetadataItem *item = NULL;
     1172    psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
     1173    psDataType type = PS_DATA_UNKNOWN;
     1174    //    int size = 0;
     1175    int i = 0;
     1176    char content[MAXSTR];
     1177    char buffer[MAXSTR];
     1178    char *buffer2;
     1179    strcpy(content, "\0");
     1180    strcpy(mdString, "\0");
     1181
     1182    while ( (item = psMetadataGetAndIncrement(iter)) ) {
     1183        type = item->type;
     1184        if ( type == 65537)
     1185            type = PS_DATA_STRING;
     1186        if ( type == 65538)
     1187            type = PS_DATA_VECTOR;
     1188        if ( type == 65547)
     1189            type = PS_DATA_METADATA;
     1190
     1191        switch (type) {
     1192        case PS_DATA_BOOL:
     1193            //            size = strlen(item->name);
     1194            snprintf(content, MAXSTR, "%s BOOL  ", item->name);
     1195            strncat(mdString, content, MAXSTR);
     1196            if ( item->data.B )
     1197                strncat(mdString, "TRUE", MAXSTR);
     1198            else
     1199                strncat(mdString, "FALSE", MAXSTR);
     1200            if ( item->comment != NULL ) {
     1201                //                size = strlen(item->comment);
     1202                snprintf(content, MAXSTR, " #%s \n", item->comment);
     1203                strncat(mdString, content, MAXSTR);
     1204            } else {
     1205                snprintf(content, MAXSTR, "\n");
     1206                strncat(mdString, content, MAXSTR);
     1207            }
     1208            break;
     1209        case PS_DATA_S32:
     1210            //            size = strlen(item->name);
     1211            snprintf(content, MAXSTR, "%s S32  ", item->name);
     1212            strncat(mdString, content, MAXSTR);
     1213            snprintf(content, MAXSTR, "%d ", item->data.S32);
     1214            strncat(mdString, content, MAXSTR);
     1215            if ( item->comment != NULL ) {
     1216                //                size = strlen(item->comment);
     1217                snprintf(content, MAXSTR, " #%s \n", item->comment);
     1218                strncat(mdString, content, MAXSTR);
     1219            } else {
     1220                snprintf(content, MAXSTR, "\n");
     1221                strncat(mdString, content, MAXSTR);
     1222            }
     1223            break;
     1224        case PS_DATA_F32:
     1225            //            size = strlen(item->name);
     1226            snprintf(content, MAXSTR, "%s F32  ", item->name);
     1227            strncat(mdString, content, MAXSTR);
     1228            snprintf(content, MAXSTR, "%f ", item->data.F32);
     1229            strncat(mdString, content, MAXSTR);
     1230            if ( item->comment != NULL ) {
     1231                //                size = strlen(item->comment);
     1232                snprintf(content, MAXSTR, " #%s \n", item->comment);
     1233                strncat(mdString, content, MAXSTR);
     1234            } else {
     1235                snprintf(content, MAXSTR, "\n");
     1236                strncat(mdString, content, MAXSTR);
     1237            }
     1238            break;
     1239        case PS_DATA_F64:
     1240            //            size = strlen(item->name);
     1241            snprintf(content, MAXSTR, "%s F64  ", item->name);
     1242            strncat(mdString, content, MAXSTR);
     1243            snprintf(content, MAXSTR, "%f ", item->data.F64);
     1244            strncat(mdString, content, MAXSTR);
     1245            if ( item->comment != NULL ) {
     1246                //                size = strlen(item->comment);
     1247                snprintf(content, MAXSTR, " #%s \n", item->comment);
     1248                strncat(mdString, content, MAXSTR);
     1249            } else {
     1250                snprintf(content, MAXSTR, "\n");
     1251                strncat(mdString, content, MAXSTR);
     1252            }
     1253            break;
     1254        case PS_DATA_STRING:
     1255            //            size = strlen(item->name);
     1256            snprintf(content, MAXSTR, "%s STR  ", item->name);
     1257            strncat(mdString, content, MAXSTR);
     1258            //            size = strlen(((char *)(item->data.V)));
     1259            snprintf(content, MAXSTR, "%s ", ((char *)(item->data.V)));
     1260            strncat(mdString, content, MAXSTR);
     1261            if ( item->comment != NULL ) {
     1262                //                size = strlen(item->comment);
     1263                snprintf(content, MAXSTR, " #%s \n", item->comment);
     1264                strncat(mdString, content, MAXSTR);
     1265            } else {
     1266                snprintf(content, MAXSTR, "\n");
     1267                strncat(mdString, content, MAXSTR);
     1268            }
     1269            break;
     1270        case PS_DATA_METADATA:
     1271            snprintf(content, MAXSTR, "\n%s  METADATA  ", item->name);
     1272            strncat(mdString, content, MAXSTR);
     1273
     1274            newStr = psMetadataConfigFormat(item->data.md);
     1275            strncpy(buffer, (char *)newStr, MAXSTR);
     1276            buffer2 = strtok(buffer, "\n");
     1277            while( buffer2 != NULL ) {
     1278                snprintf(content, MAXSTR, "\n   %s", buffer2);
     1279                strncat(mdString, content, MAXSTR);
     1280                buffer2 = strtok(NULL, "\n");
     1281            }
     1282            if ( item->comment != NULL ) {
     1283                snprintf(content, MAXSTR, "\nEND   #%s\n\n", item->comment);
     1284                strncat(mdString, content, MAXSTR);
     1285            } else {
     1286                snprintf(content, MAXSTR, "\nEND\n\n");
     1287                strncat(mdString, content, MAXSTR);
     1288            }
     1289            psFree(newStr);
     1290            break;
     1291        case PS_DATA_VECTOR:
     1292            //            size = strlen(item->name);
     1293            snprintf(content, MAXSTR, "@%s ", item->name);
     1294            strncat(mdString, content, MAXSTR);
     1295            type = ((psVector*)(item->data.V))->type.type;
     1296            switch (type) {
     1297            case PS_DATA_S32:
     1298                strncat(mdString, "S32 ", MAXSTR);
     1299                for (i = 0; ((psVector*)(item->data.V))->data.S32[i] != 0; i++) {
     1300                    snprintf(content, MAXSTR, "%d",
     1301                             ((psVector*)(item->data.V))->data.S32[i]);
     1302                    if ( ((psVector*)(item->data.V))->data.S32[i+1] != 0 ) {
     1303                        strncat(content, ", ", MAXSTR);
     1304                    }
     1305                    strncat(mdString, content, MAXSTR);
     1306                }
     1307                break;
     1308            case PS_DATA_F32:
     1309                strncat(mdString, "F32 ", MAXSTR);
     1310                for (i = 0; ((psVector*)(item->data.V))->data.F32[i] != 0; i++) {
     1311                    snprintf(content, MAXSTR, "%f",
     1312                             ((psVector*)(item->data.V))->data.F32[i]);
     1313                    if ( ((psVector*)(item->data.V))->data.F32[i+1] != 0 ) {
     1314                        strncat(content, ", ", MAXSTR);
     1315                    }
     1316                    strncat(mdString, content, MAXSTR);
     1317                }
     1318                break;
     1319            case PS_DATA_F64:
     1320                strncat(mdString, "F64 ", MAXSTR);
     1321                for (i = 0; ((psVector*)(item->data.V))->data.F64[i] != 0; i++) {
     1322                    snprintf(content, MAXSTR, "%lf",
     1323                             ((psVector*)(item->data.V))->data.F64[i]);
     1324                    if ( ((psVector*)(item->data.V))->data.F64[i+1] != 0 ) {
     1325                        strncat(content, ", ", MAXSTR);
     1326                    }
     1327                    strncat(mdString, content, MAXSTR);
     1328                }
     1329                break;
     1330            case PS_DATA_UNKNOWN:
     1331            default:
     1332                psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     1333                        PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
     1334                psFree(iter);
     1335                return NULL;
     1336            }
     1337            if ( item->comment != NULL ) {
     1338                //                size = strlen(item->comment);
     1339                snprintf(content, MAXSTR, " #%s \n", item->comment);
     1340                strncat(mdString, content, MAXSTR);
     1341            } else {
     1342                snprintf(content, MAXSTR, "\n");
     1343                strncat(mdString, content, MAXSTR);
     1344            }
     1345            break;
     1346        case PS_DATA_UNKNOWN:
     1347        default:
     1348            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     1349                    PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
     1350            psFree(iter);
     1351            return NULL;
     1352        }
     1353    }
     1354    newString = psStringNCopy(mdString, 2048);
     1355    psFree(iter);
     1356    return newString;
     1357}
     1358
     1359bool psMetadataConfigWrite(psMetadata *md,
     1360                           const char *filename)
     1361{
     1362    psString fileString = NULL;
     1363    FILE *file;
     1364    file = fopen(filename, "w");
     1365    fileString = psMetadataConfigFormat(md);
     1366    fprintf(file, "%s", fileString);
     1367    fclose(file);
     1368    psFree(fileString);
     1369    return true;
     1370}
     1371
  • trunk/psLib/src/types/psMetadataConfig.h

    r4589 r4870  
    1010 *  @author Robert DeSonia, MHPCC
    1111 *
    12  *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-07-21 01:40:10 $
     12 *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-08-24 22:00:53 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    8686);
    8787
     88/** Converts a psMetadata structure (including any nested psMetadata) into a
     89 *  configuration file formatted string.
     90 *
     91 *  A NULL shall be returned on error.
     92 *  @return psString:       a Configuration File formatted string.
     93 */
     94psString psMetadataConfigFormat(
     95    psMetadata *md                     ///< The metadata to convert
     96);
     97
     98/** Converts a psMetadata structure (including any nested psMetadata) into a
     99 *  configuration file formatted string that is written out to filename.
     100 *
     101 *  @return bool:       True if successful, otherwise false.
     102 */
     103bool psMetadataConfigWrite(
     104    psMetadata *md,                    ///< The metadata to convert
     105    const char *filename               ///< Name of file to write
     106);
     107
    88108/// @}
    89109
  • trunk/psLib/test/types/tst_psMetadataIO.c

    r4547 r4870  
    1313 *  @author  Eric Van Alst, MHPCC
    1414 *
    15  *  @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
    16  *  @date  $Date: 2005-07-13 02:47:01 $
     15 *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
     16 *  @date  $Date: 2005-08-24 22:00:57 $
    1717 *
    1818 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    2929static psS32 testMetadataParseConfig3(void);
    3030static psS32 testMetadataParseConfig4(void);
     31static psS32 testMetadataPrint(void);
    3132
    3233testDescription tests[] = {
     
    3637                              {testMetadataParseConfig3,000,"psMetadataConfigParse",0,false},
    3738                              {testMetadataParseConfig4,000,"psMetadataConfigParse",0,false},
     39                              {testMetadataPrint,000,"psMetadataPrint",0,false},
    3840                              {NULL}
    3941                          };
     
    4850static psBool checkItemType(psMetadataItem* mdItem, psS32 expectedType, char* configFile);
    4951static psBool checkItemComment(psMetadataItem* mdItem, char* expectedComment, char* configFile);
     52static psMetadata *setupMeta(void);
    5053
    5154#define ERROR_TOL  0.0001
     
    236239        0, 0, 0, 24
    237240    };
     241
     242static psMetadata *setupMeta(void)
     243{
     244    psMetadata *md = NULL;
     245    md = psMetadataAlloc();
     246
     247    psMetadataAddBool(md, PS_LIST_TAIL, "item1", "I am a boolean", true);
     248    psMetadataAddS32(md, PS_LIST_TAIL, "item2", "I am a integer", 55);
     249    psMetadataAddF32(md, PS_LIST_TAIL, "item3", "I am a float", 3.14);
     250    psMetadataAddF64(md, PS_LIST_TAIL, "item4", "I am a double", 6.28);
     251    psMetadataAddStr(md, PS_LIST_TAIL, "item5", "I am a string", "GNIRTS");
     252
     253    return md;
     254}
    238255
    239256static void writeMetadata(psMetadata* metadata, char* indentStr)
     
    10201037}
    10211038
     1039psS32 testMetadataPrint(void)
     1040{
     1041    psMetadata *meta = NULL;
     1042    meta = setupMeta();
     1043    psMetadataPrint(meta, 0);
     1044    psFree(meta);
     1045    return 0;
     1046}
  • trunk/psLib/test/types/tst_psMetadata_07.c

    r4856 r4870  
    88*     Test C - Get and Increment a psMetadataIterator
    99*     Test D - Get and Decrement a psMetadataIterator
     10*     Test E - psMetadataConfigWrite (also tests psMetadataConfigFormat)
    1011*
    1112*  @author  David Robbins, MHPCC
    1213*
    13 *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
    14 *  @date  $Date: 2005-08-23 02:48:31 $
     14*  @version $Revision: 1.5 $  $Name: not supported by cvs2svn $
     15*  @date  $Date: 2005-08-24 22:00:57 $
    1516*
    1617*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     
    2021#include "pslib_strict.h"
    2122#include "psTest.h"
    22 #include "psMetadata.h"
     23//#include "psMetadata.h"
    2324
    24 static psS32 testMetaIter00(void);
     25static psS32 testMetaIter(void);
     26static psS32 testMetaWrite(void);
    2527
    2628testDescription tests[] = {
    27                               {testMetaIter00, 0, "Test psMetadataIterator fxns", 0, false},
     29                              {testMetaIter, 0, "Test psMetadataIterator fxns", 0, false},
     30                              {testMetaWrite, 0, "Test psMetadataConfigWrite", 0, false},
    2831                              {NULL}
    2932                          };
     
    3437{
    3538    psMetadata *md = NULL;
     39    psVector *vec = NULL;
     40    psMetadata *newMD = NULL;
     41    int i = 0;
    3642    md = psMetadataAlloc();
    37 
     43    newMD = psMetadataAlloc();
     44    vec = psVectorAlloc(60, PS_DATA_S32);
     45    for (i = 0; i < 5; i++) {
     46        vec->data.S32[i] = i+1;
     47    }
    3848    psMetadataAddBool(md, PS_LIST_TAIL, "item1", "I am a boolean", true);
    3949    psMetadataAddS32(md, PS_LIST_TAIL, "item2", "I am a integer", 55);
     
    4151    psMetadataAddF64(md, PS_LIST_TAIL, "item4", "I am a double", 6.28);
    4252    psMetadataAddStr(md, PS_LIST_TAIL, "item5", "I am a string", "GNIRTS");
     53    psMetadataAddVector(md, PS_LIST_TAIL, "vector6", "I am a vector", vec);
    4354
     55    psMetadataAddS32(newMD, PS_LIST_TAIL, "ITEM01", "I AM INT", 666);
     56    psMetadata *newestMD = NULL;
     57    newestMD = psMetadataAlloc();
     58    psMetadataAddVector(newestMD, PS_LIST_TAIL, "VECTORNEW", "Newest VECTOR", vec);
     59    psMetadataAddStr(newestMD, PS_LIST_TAIL, "cell", "I am a p-Star", "pStArRs");
     60    psMetadataAddMetadata(newMD, PS_LIST_TAIL, "META NEW", "I AM Newest METADATA", newestMD);
     61    psMetadataAddF32(newMD, PS_LIST_TAIL, "ITEM02", "I AM FLOAT", 666.6);
     62    psMetadataAddF64(newMD, PS_LIST_TAIL, "ITEM03", "I AM DOUBLE", 666.666);
     63
     64    psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", "I am a metadata", newMD);
     65
     66    psFree(newestMD);
     67    psFree(vec);
     68    psFree(newMD);
    4469    return md;
    4570}
     
    4772int main(int argc, char* argv[])
    4873{
    49 
    5074    psLogSetLevel( PS_LOG_INFO );
    51 
    5275    if( !runTestSuite(stderr,"psMetadata_07",tests,argc,argv)) {
    5376        return 1;
    5477    }
    55 
    56 
    57     // Test A - Read an XML config file
    58     //    printPositiveTestHeader(stdout, "psMetadata", "Test A - Read an XML config file");
    59     /*
    60         int res = 0;
    61         psU32 nFail = 0;
    62         psMetadata *md = NULL;
    63         md = psMetadataConfigParseXml(md, &nFail, XML_CONFIG_FILE, true);
    64         if (nFail != 0) {
    65             printf("psMetadataConfigParseXml returned error %d\n", res);
    66         }
    67 
    68         psFree(md);
    69     */
    70     //    printFooter(stdout, "psMetadata", "Test A - Read an XML config file", true);
    71     /*
    72         // Test B - Free data
    73         printPositiveTestHeader(stdout, "psMetadata", "Test B - Free data");
    74         psMemCheckLeaks(0, NULL, stdout, false);
    75         psS32 nBad = psMemCheckCorruption(0);
    76         if(nBad) {
    77             printf("ERROR: Found %d bad memory blocks\n", nBad);
    78         }
    79         printFooter(stdout, "psMetadata", "Test B - Free data", true);
    80     */
    8178    return 0;
    8279}
    8380
    8481//Set a psMetadataIterator //
    85 static psS32 testMetaIter00(void)
     82static psS32 testMetaIter(void)
    8683{
    8784    psMetadata *metadata = NULL;
     
    116113    }
    117114    printFooter(stdout, "psMetadata", "Test D - Get and Decrement Iterator", true);
    118     //    psFree(item1);
    119     //    psFree(item2);
    120     //    psFree(item3);
    121115    psFree(iter);
    122116    psFree(metadata);
    123117    return 0;
    124118}
     119
     120static psS32 testMetaWrite(void)
     121{
     122    psMetadata *newMD = NULL;
     123    newMD = setupMeta();
     124    printPositiveTestHeader(stdout, "psMetadata", "Test E - psMetadataConfigWrite");
     125    if ( !psMetadataConfigWrite(newMD, "mdcfgwrt.out") ) {
     126        fprintf(stderr, "Failed test point E - Failed to write metadata to file. \n");
     127    }
     128
     129    printFooter(stdout, "psMetadata", "Test E - psMetadataConfigWrite", true);
     130    psFree(newMD);
     131    return 0;
     132}
  • trunk/psLib/test/types/verified/tst_psMetadataIO.stderr

    r4589 r4870  
    116116---> TESTPOINT PASSED (psMetadataConfigParse{psMetadataConfigParse} | tst_psMetadataIO.c)
    117117
     118/***************************** TESTPOINT ******************************************\
     119*             TestFile: tst_psMetadataIO.c                                         *
     120*            TestPoint: psMetadataConfigParse{psMetadataPrint}                     *
     121*             TestType: Positive                                                   *
     122\**********************************************************************************/
     123
     124
     125---> TESTPOINT PASSED (psMetadataConfigParse{psMetadataPrint} | tst_psMetadataIO.c)
     126
  • trunk/psLib/test/types/verified/tst_psMetadataIO.stdout

    r4547 r4870  
    221221    c                         STR                                          z
    222222END
     223item1 (I am a boolean): True
     224item2 (I am a integer): 55
     225item3 (I am a float): 3.140000
     226item4 (I am a double): 6.280000
     227item5 (I am a string): GNIRTS
  • trunk/psLib/test/types/verified/tst_psMetadata_07.stdout

    r4856 r4870  
    3535---> TESTPOINT PASSED (psMetadata{Test D - Get and Decrement Iterator} | tst_psMetadata_07.c)
    3636
     37/***************************** TESTPOINT ******************************************\
     38*             TestFile: tst_psMetadata_07.c                                        *
     39*            TestPoint: psMetadata{Test E - psMetadataConfigWrite}                 *
     40*             TestType: Positive                                                   *
     41\**********************************************************************************/
     42
     43
     44---> TESTPOINT PASSED (psMetadata{Test E - psMetadataConfigWrite} | tst_psMetadata_07.c)
     45
Note: See TracChangeset for help on using the changeset viewer.