---

GenericValues.cpp

Go to the documentation of this file.

/*
Copyright (c) 2000-2003, Jelle Kok, University of Amsterdam
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.

3. Neither the name of the University of Amsterdam nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "GenericValues.h"
#include "Parse.h"           // needed for 'gotoFirstNonSpace'
#include <stdio.h>           // needed for 'sprintf'
#include <stdlib.h>          // needed for 'free'
#include <string.h>          // needed for 'strdup'
#include <ctype.h>           // needed for 'isdigit'
#include <fstream>           // needed for 'ifstream'

/*****************************************************************************/
/*******************   CLASS GENERICVALUET   *********************************/
/*****************************************************************************/

GenericValueT::GenericValueT( const char *str, void *vAddr, GenericValueKind t)
{
  m_strName  = strdup( str ); // strdup needed to alloc right amount of memory
  m_vAddress = vAddr;
  m_type     = t;
}

GenericValueT::~GenericValueT( )
{
  if( m_strName )
    free( ( char * ) m_strName );
}

const char* GenericValueT::getName ( )
{
  return ( m_strName );
}

bool GenericValueT::setValue( const char *strValue )
{
  bool bReturn = true, b;

  // determine the generic type associated with this GenericValueT
  // object and apply the correct conversion of the string argument
  switch( m_type )
  {
    case GENERIC_VALUE_DOUBLE:
      *( double * ) m_vAddress = atof( strValue ? strValue : 0 );
      break;
    case GENERIC_VALUE_STRING:
      strcpy( ( char * ) m_vAddress, strValue );
      break;
    case GENERIC_VALUE_BOOLEAN:
      b = false;
      if( !strValue )
        ;
      else if( isdigit( strValue[ 0 ] ) )
        b = atoi( strValue ? strValue : 0 );
#ifdef WIN32
      else if( strcmp( strValue, "on"  ) == 0 ||
               strcmp( strValue, "true") == 0 ||
               strcmp( strValue, "yes" ) == 0 )
#else
      else if( strcasecmp( strValue, "on"  ) == 0 ||
               strcasecmp( strValue, "true") == 0 ||
               strcasecmp( strValue, "yes" ) == 0 )
#endif
        b = true;

      *( bool * ) m_vAddress = ( b == true ) ? true : false;
      break;
    case GENERIC_VALUE_INTEGER:
      *( int * ) m_vAddress = atoi( strValue ? strValue : 0 );
      break;
    default:
      bReturn = false;
  }

  return ( bReturn );
}

char* GenericValueT::getValue( char *strValue )
{
  // determine the generic type associated with this GenericValueT
  // object and apply the correct conversion into a string
  switch( m_type )
  {
    case GENERIC_VALUE_DOUBLE:
      sprintf( strValue, "%2f", *( double * ) m_vAddress );
      break;
    case GENERIC_VALUE_STRING:
      sprintf( strValue, "%s", ( char * ) m_vAddress );
      break;
    case GENERIC_VALUE_BOOLEAN:
      sprintf( strValue, "%d", *( int * ) m_vAddress );
      break;
    case GENERIC_VALUE_INTEGER:
      sprintf( strValue, "%d", *( int * ) m_vAddress );
      break;
    default:
      *strValue = '\0';
  }

  return ( strValue );
}

void GenericValueT::show( ostream& out, const char *strSeparator )
{
  // write the name associated with the variable in this GenericValueT
  // object followed by the separator to the specified output stream
  out << m_strName << strSeparator;

  // determine the generic type associated with this GenericValueT
  // object and write the correct value to the specified output stream
  switch( m_type )
  {
    case GENERIC_VALUE_DOUBLE:
      out << *( double * ) m_vAddress;
      break;
    case GENERIC_VALUE_STRING:
      out << ( char * ) m_vAddress;
      break;
    case GENERIC_VALUE_BOOLEAN:
      out << ( ( *( bool * ) m_vAddress == true ) ? "true" : "false");
      break;
    case GENERIC_VALUE_INTEGER:
      out << *( int * ) m_vAddress;
      break;
    default:
      break;
  }

  out << endl;
}


/*****************************************************************************/
/*******************   CLASS GENERICVALUES   *********************************/
/*****************************************************************************/

GenericValues::GenericValues( char *strName, int iMaxValues )
{
  m_iValuesTotal = 0;   // total number of values in collection is set to zero

  if( strName )       // set the name of the collection
    m_strClassName = strdup( strName );

  m_iMaxGenericValues = iMaxValues;

  // a GenericValues object is a collection of GenericValueT objects
  m_values = new GenericValueT*[ iMaxValues ];
}

GenericValues::~GenericValues( void )
{
  for( int i = 0 ; i < getValuesTotal( ) ; i++ )
    delete m_values[ i ];
  delete m_values;

  if( m_strClassName )
    free( m_strClassName );
}

char* GenericValues::getClassName( )
{
  return ( m_strClassName );
}

int GenericValues::getValuesTotal( )
{
  return ( m_iValuesTotal );
}

bool GenericValues::addSetting( const char *strName, void *vAddress,
                                                     GenericValueKind type )
{
  if( getValuePtr( strName ) )               // setting already installed
  {
    cerr << "Setting '" << strName << "' already installed." << endl;
    return false;
  }
  if( m_iValuesTotal == m_iMaxGenericValues )    // buffer is full
  {
    cerr << "GenericValues::addSetting buffer for " << m_strClassName <<
            " is full (cannot add '" << strName << "')" << endl;
    return false;
  }

  m_values[ m_iValuesTotal++ ] = new GenericValueT( strName, vAddress, type );

  return ( true );
}

GenericValueT* GenericValues::getValuePtr( const char *strName )
{
  GenericValueT *ptr = 0;

  // search through the collection for a GenericValueT object of which the name
  // associated with the variable matches the argument passed to the method
  for( int i = 0 ; i < getValuesTotal( ) ; i++ )
  {
    if( strcmp( m_values[ i ]->getName( ), strName ) == 0 )
    {
      ptr = m_values[ i ];
      break;
    }
  }

  return ( ptr );
}

char* GenericValues::getValue( const char *strName, char *strValue )
{
  GenericValueT *parptr;

  parptr = getValuePtr( strName );

  if( parptr )
    strValue = parptr->getValue( strValue );   // this method returns a string
  else
    strValue[ 0 ] = '\0';

  return ( strValue );
}

bool GenericValues::setValue( const char *strName, const char *strValue )
{
  bool bReturn = false;
  GenericValueT *parptr;

  parptr = getValuePtr( strName );

  if( parptr )
    bReturn = parptr->setValue( strValue ); // string is converted to its type

  return ( bReturn );
}

bool GenericValues::readValues( const char *strFile, const char *strSeparator )
{
  ifstream in( strFile );

  if( !in )
  {
    cerr << "(GenericValues::readValues) Could not open file '" <<
    strFile << "'" << endl;
    return ( false );
  }

  bool  bReturn = true;
  char  strLine[ 256 ], strName[ 100 ], strValue[ 100 ];
  char* c;
  int   iLineNr = 0;

  // read each line in the configuration file and store the values
  while( in.getline( strLine, sizeof( strLine ) ) )
  {
    iLineNr++;

    // skip comment lines and empty lines; " #" is for server.conf version 7.xx
    if( !( strLine[ 0 ] == '\n' ||
           strLine[ 0 ] == '#'  ||
           strLine[ 0 ] == '\0' ||
           ( strlen( strLine ) > 1 &&
             strLine[ 0 ] == ' ' &&
             strLine[ 1 ] == '#' ) ) )
    {
      // convert all characters belonging to the separator to spaces
      if( strSeparator && ( c = strstr( strLine, strSeparator ) ) != NULL )
        for( size_t i = 0; i < strlen( strSeparator ); i++ )
          *( c + i ) = ' ';

      // read the name and value on this line and store the value
      if( !( sscanf( strLine, "%s%s", strName, strValue ) == 2 &&
             setValue( strName, strValue ) ) )
      {
        bReturn = false;
        cerr << "(GenericValues::readValues) '" << strFile << "' linenr "
             << iLineNr << ",  error in '" << strLine << "'" << endl;
      }
    }
  }

  return ( bReturn );
}

bool GenericValues::saveValues( const char *strFile, const char *strSeparator,
                                bool bAppend )
{
  ofstream outf( strFile, ( bAppend == false ? ( ios::out )
                                             : ( ios::out | ios::app ) ) );

  if( !outf )
  {
    cerr << "Could not open file '" << strFile << "'" << endl;
    return ( false );
  }

  // values are written to file using 'show' (note that
  // output stream to write to is a file in this case)
  show( outf, strSeparator );

  return ( true );
}

void GenericValues::show( ostream& out, const char *strSeparator )
{
  for( int i = 0; i < getValuesTotal( ); i++ )
    m_values[ i ]->show( out, strSeparator );
}

/********************* TESTING PURPOSES **************************************/
/*
int main( void )
{
  GenericValues g("ServerSettings", 6);

  int    i = 10;
  char   c[256];
  sprintf( c, "hallo" );
  bool   b = true;
  double d = 10.14;

  cout << g.addSetting( "var1", &i, GENERIC_VALUE_INTEGER ) << endl;
  cout << g.addSetting( "var2", c, GENERIC_VALUE_STRING  ) << endl;
  cout << g.addSetting( "var3", &d, GENERIC_VALUE_DOUBLE  ) << endl;
  cout << g.addSetting( "var4", &b, GENERIC_VALUE_BOOLEAN ) << endl;
  g.show( cout, ":"  );

  g.setValue( "var1", "11"      );
  g.setValue( "var2", "hoi"     );
  g.setValue( "var3", "20.2342" );
  g.setValue( "var4", "false"   );
  g.show( cout, ":"  );

//  g.setIntegerValue( "var1", 22      );
//  g.setStringValue ( "var2", "hoi2"  );
//  g.setDoubleValue ( "var3", 30.2342 );
//  g.setBooleanValue( "var4", true    );
//  g.show( cout, ":"  );

//  g.readValues( "server.conf", ":" );
//  g.show( cout, ":"  );

  return ( 0 );
}

*/

---