kvpTest.c

Go to the documentation of this file.

/* kvpTest.c - Simple test program for key/value pair library */

/* G.J.Crone, University College London */

/*
 * Current CVS Tag:
 * $Header: /cvs/minoscvs/rep1/minossoft/OnlineUtil/kvplib/kvpTest.c,v 1.2 2004/03/05 16:26:54 rhatcher Exp $
 */
 
/* 
 * Modification History : DO NOT EDIT - MAINTAINED BY CVS 
 * $Log: kvpTest.c,v $
 * Revision 1.2  2004/03/05 16:26:54  rhatcher
 * synch with online CVS changes of 2004-03-04.
 *
 * Revision 1.6  2004/03/04 16:15:56  gjc
 * Grow internal buffer (by allocating larger buffer and copying data) as
 * necessary.
 *
 * Revision 1.5  2004/03/04 11:50:20  gjc
 * Added new function kvpQueryLength to return the number of elements in
 * an array.
 *
 * Revision 1.4  2002/06/14 12:21:32  gjc
 * include string.h for strlen prototype.
 *
 * Revision 1.3  2001/07/24 17:19:56  gjc
 * Added new function kvpGetStringArray
 *
 * Revision 1.2  2001/04/03 14:30:08  gjc
 * Return an error from kvpParse if the length field does not match the
 * length of the supplied values.
 * Ignore whitespace arounf key in kvpFindKey.
 *
 * Revision 1.1  2001/03/26 18:09:21  gjc
 * initial check in
 *
 *
 */ 

/*
DESCRIPTION
<Insert a description of the file/module here>
INCLUDE FILES: <place list of any relevant header files here>
*/

/* includes */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <math.h>
#include <string.h>

#include "keyValuePair.h"

/* defines */
#define MAX_STRINGS 10
#define MAX_STRING_LEN 100

/* typedefs */

/* globals */   

/* locals */

/* forward declarations */

int main (int argc, char* argv[])
{
   char record[1024] ;
   int nkeys ;
   int badtype ;
   char vtype[4] ;
   char key[80] ;
   int keysize ;
   int recordsize ;
   int nwritten ;
   char vString[200] ;
   int vsize ;
   double dVal ;
   int iVal ;
   int iarray[100] ;
   float farray[100] ;
   char sarray[MAX_STRINGS][MAX_STRING_LEN] ;
   int nentries ;
   int entry ;
   KvpErrorCode status ;
   char* tPtr ;

   printf ("Enter record : ") ;
   fgets (record, sizeof (record), stdin) ;
   recordsize = strlen (record) ;
   record[recordsize-1] = 0 ;

   if (record[0] != 0) {
      nkeys = kvpParse (record) ;
      if (nkeys >= 0) {
        printf ("record parsed into %d key value pairs\n", nkeys) ;
      }
      else {
        kvpPrintError (kvpError()) ;
        return (EXIT_FAILURE) ;
      }
   }

   printf ("***************** Enter additional keys *****\n") ;
   do {
      kvpDumpInternals();
      printf ("enter key : ") ;
      fgets (key, sizeof (key), stdin) ;
      keysize = strlen (key) ;
      key[keysize-1] = 0 ;

      if (key[0] != 0) {
         printf ("enter value : ") ;
         fgets (vString, sizeof (vString), stdin) ;
         vsize = strlen (vString) ;
         vString[vsize-1] = 0 ;

         do {
            printf ("enter value type s=string, i=int, f=float,"
                    " I=array of int : ") ;
            fgets (vtype, sizeof (vtype), stdin) ;
            badtype = 0 ;
            switch (vtype[0]) {
            case 's' :
               status = kvpSetString (key, vString) ;
               break ;
            case 'i' :
               iVal = strtol (vString, NULL, 0) ;
               status = kvpSetInt (key, iVal) ;
               break ;
            case 'I' :
               tPtr = vString ;
               nentries = 0 ;
               do {
                  iarray[nentries] = strtol (tPtr, &tPtr, 0) ;
                  if (*tPtr == ',') {
                     tPtr++ ;
                  }
                  nentries++ ;
               } while (*tPtr != 0) ;
               printf ("Adding %d element array of ints\n", nentries) ;
               status = kvpSetIntArray (key, iarray, nentries) ;
               break ;
            case 'f' :
               dVal = strtod (vString, NULL) ;
               status = kvpSetFloat (key, dVal) ;
               break ;
            case 'F' :
               tPtr = vString ;
               nentries = 0 ;
               do {
                  farray[nentries] = strtod (tPtr, &tPtr) ;
                  if (*tPtr == ',') {
                     tPtr++ ;
                  }
                  nentries++ ;
               } while (*tPtr != 0) ;
               printf ("Adding %d element array of floats\n", nentries) ;
               status = kvpSetFloatArray (key, farray, nentries) ;
               break ;
            default:
               badtype = 1 ;
            }
         } while (badtype) ;

         if (status == 0) {
            printf ("key inserted successfully\n") ;
         }
         else {
            kvpPrintError (kvpError()) ;
         }
      }
   } while (key[0] != 0) ;

   printf ("******************************************\n\n") ;

   nwritten = kvpWrite (1) ;
   if (nwritten <= 0) {
      perror ("write") ;
   }
   printf ("\n\n") ;

   printf ("************* Look up keys ****************\n") ;
   do {
      printf ("enter key : ") ;
      fgets (key, sizeof (key), stdin) ;
      keysize = strlen (key) ;
      key[keysize-1] = 0 ;

      if (key[0] != 0) {

         nentries = kvpQueryLength (key) ;
         if (nentries > 0) {
            printf ("Array of length %d found\n", nentries) ;
         }

         do {
            printf ("enter value type s=string, i=int, d=decimal, h=hex,"
                    " f=float, D=double\n"
                    "\tI=array of ints, F=array of floats : ") ;
            fgets (vtype, sizeof (vtype), stdin) ;
            badtype = 0 ;

            switch (vtype[0]) {
            case 's' :
               printf ("value=<%s>\n", kvpGetString (key)) ;
               break ;
            case 'i' :
               printf ("value=<%d>\n", kvpGetInt (key, -1)) ;
               break ;
            case 'd' :
               printf ("value=<%d>\n", kvpGetDec (key, -1)) ;
               break ;
            case 'h' :
               printf ("value=<%x>\n", kvpGetHex (key, -1)) ;
               break ;

            case 'S' :
               nentries = MAX_STRINGS ;
               status = kvpGetStringArray (key, sarray[0], MAX_STRING_LEN,
                                           &nentries) ;
              if (status == KVP_E_OK) {
                printf ("array length %d, values: ", nentries) ;
                for (entry = 0 ; entry < nentries ; entry++) {
                  printf ("  <%s>", sarray[entry]) ;
                }
                printf ("\n") ;
              }
              break ;

            case 'I' :
              nentries = sizeof (iarray) / sizeof (int) ;
              status = kvpGetIntArray (key, iarray, &nentries) ;
              if (status == KVP_E_OK) {
                printf ("array length %d, values: ", nentries) ;
                for (entry = 0 ; entry < nentries ; entry++) {
                  printf ("  %d", iarray[entry]) ;
                }
                printf ("\n") ;
              }
              break ;
            case 'f' :
               /*        fval = kvpGetFloat (key, HUGE) ;
                         printf ("value=<%g>\n", fval) ;*/
               printf ("value=<%g>\n", kvpGetFloat (key, HUGE)) ;
               break ;
            case 'D' :
               printf ("value=<%g>\n", kvpGetDouble (key, HUGE)) ;
               break ;
            case 'F' :
              nentries = sizeof (farray) / sizeof (float) ;
              status = kvpGetFloatArray (key, farray, &nentries) ;
              if (status == KVP_E_OK) {
                printf ("array length %d, values: ", nentries) ;
                for (entry = 0 ; entry < nentries ; entry++) {
                  printf ("  %g", farray[entry]) ;
                }
                printf ("\n") ;
              }
              break ;

            default:
               badtype = 1 ;
            }
         } while (badtype) ;

         kvpPrintError (kvpError ()) ;
      }
   } while (key[0] != 0) ;
   return (EXIT_SUCCESS) ;
}

---