kvplib/KeyRing.cc

Go to the documentation of this file.

#include <iostream>
#include <math.h>
#include "KeyRing.h"

KeyRing::KeyRing ()
{
   keyCount = 0 ;
}

KeyRing::KeyRing (char* buffer)
{
   char* key ;
   KeyType type ;
   int* ivalues ;
   float fval ;
   char* csval ;
   int size ;

   keyCount = kvpParse (buffer) ;
   for (int entry = 0 ; entry < keyCount ; entry++) {
      kvpGetEntry (entry, &key, &type, &size, &csval) ;
      switch (type) {
      case KT_INT:
         ivalues = new int[size] ;
         kvpGetIntArray (key, ivalues, &size) ;
         addKey (key, ivalues, size) ;
         delete [] ivalues ;
         break ;
      case KT_FLOAT:
         fval = kvpGetFloat (key, 0) ;
         addKey (key, fval) ;
         break ;
      case KT_STRING:
         addKey (key, csval) ;
         break ;
      case KT_INVALID:
         // Ignore it
         break;
      }
   }
}

KeyRing::~KeyRing ()
{
   for (KvMap::iterator kvIter = myMap.begin () ; kvIter != myMap.end () ;
        kvIter++) {
      delete (*kvIter).second ;
   }

}

void KeyRing::addKey (string key, int value)
{
   myMap.insert (KvMap::value_type (key, new IntArray (&value, 1))) ;
}
void KeyRing::addKey (const string key, const int* values, int size)
{
   myMap.insert (KvMap::value_type (key, new IntArray (values, size))) ;
}
void KeyRing::addKey (string key, float value)
{
   myMap.insert (KvMap::value_type (key, new FloatArray (&value, 1))) ;
}
void KeyRing::addKey (string key, string value)
{
   myMap.insert (KvMap::value_type (key, new StringValue (value))) ;
}

void KeyRing::dump ()
{
   IntArray* iarray ;
   FloatArray* farray ;
   StringValue* sval ;
   int* ivals ;
   float* fvals ;

   for (KvMap::iterator kvIter = myMap.begin () ; kvIter != myMap.end () ;
        kvIter++) {
      cout << "key : <" << (*kvIter).first << ">,  type : " ;
      switch ((*kvIter).second->type()) {
      case KT_INT:
         iarray = (IntArray*) (*kvIter).second ;
         cout << "int,  value :" ;
         ivals = iarray->value() ;
         for (int element = 0 ; element < iarray->size () ; element++) {
            cout << " " << ivals[element] ;
         }
         cout << endl ;
         break ;
      case KT_FLOAT:
         farray = (FloatArray*) (*kvIter).second ;
         cout << "float,  value : " ;
         fvals = farray->value() ;
         for (int element = 0 ; element < farray->size () ; element++) {
            cout << " " << fvals[element] ;
         }
         cout << endl ;
         break ;
      case KT_STRING:
         sval = (StringValue*) (*kvIter).second ;
         cout << "string,  value : <" << sval->value() << ">\n" ;
         break ;
      case KT_INVALID:
         // Ignore it
         break;
      }
   }
}

int KeyRing::intKey (string key)
{
   KvMap::iterator kvIter = myMap.find (key) ; 
   if (kvIter != myMap.end ()) {
      if ((*kvIter).second->type() == KT_INT) {
         IntArray* vptr = (IntArray*) (*kvIter).second ;
         return (vptr->value()[0]) ;
      }
      else {
         return (-2) ;
      }
   }
   else {
      return (-1) ;
   }
}

int KeyRing::intArray (const string key, int* array, int maxLength)
{
   KvMap::iterator kvIter = myMap.find (key) ; 
   if (kvIter != myMap.end ()) {
      if ((*kvIter).second->type() == KT_INT) {
         IntArray* vptr = (IntArray*) (*kvIter).second ;
         int length = vptr->size () ;
         if (length > maxLength) {
            length = maxLength ;
         }
         int* vals = vptr->value() ;
         for (int element = 0 ; element < length ; element++) {
            array[element] = vals[element] ;
         }
         return (length) ;
      }
   }
   return (0) ;
}

float KeyRing::floatKey (string key)
{
   KvMap::iterator kvIter = myMap.find (key) ; 
   if (kvIter != myMap.end ()) {
      if ((*kvIter).second->type() == KT_FLOAT) {
         FloatArray* vptr = (FloatArray*) (*kvIter).second ;
         return (vptr->value()[0]) ;
      }
      else {
         return (HUGE) ;
      }
   }
   else {
      return (HUGE) ;
   }
}
string KeyRing::stringKey (string key)
{
   KvMap::iterator kvIter = myMap.find (key) ; 
   if (kvIter != myMap.end ()) {
      if ((*kvIter).second->type() == KT_STRING) {
         StringValue* vptr = (StringValue*) (*kvIter).second ;
         return (vptr->value()) ;
      }
      else {
         return (0) ;
      }
   }
   else {
      return (0) ;
   }
}

void KeyRing::write (int stream)
{
   kvpReset () ;
   IntArray* ival ;
   FloatArray* fval ;
   StringValue* sval ;
   for (KvMap::iterator kvIter = myMap.begin () ; kvIter != myMap.end () ;
        kvIter++) {
      switch ((*kvIter).second->type()) {
      case KT_INT:
         ival = (IntArray*) (*kvIter).second ;
         kvpSetIntArray ((*kvIter).first.c_str(),
                         ival->value(), ival->size()) ;
         break ;
      case KT_FLOAT:
         fval = (FloatArray*) (*kvIter).second ;
         kvpSetFloatArray ((*kvIter).first.c_str(),
                           fval->value(), fval->size()) ;
         break ;
      case KT_STRING:
         sval = (StringValue*) (*kvIter).second ;
         kvpSetString ((*kvIter).first.c_str(), sval->value().c_str()) ;
         break ;
      case KT_INVALID:
         // Ignore it
         break;
      }
   }
   kvpWrite (stream) ;
}

---