/*! Get method for the 'm_iValuesTotal' member variable.    \return the total number of generic values stored in the collection so far*/int GenericValues::getValuesTotal( ){  return ( m_iValuesTotal );}/*! This method adds a new generic value to the collection and provides a    connection between a string name and the variable name of the generic value.    \param strName a string denoting the name associated with the variable of    the generic value which is added (the variable can be reached through this    name)    \param vAddress a (void) pointer to the actual variable itself    \param type the (generic) type of the variable which is added    \return a boolean indicating whether the generic value has been succesfully    added */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 );}/*! This (private) method returns a pointer to the GenericValueT object of which    the name associated with the variable matches the argument passed to the    method.    \param strName a string denoting the name associated with the variable of    the GenericValueT object to which a pointer should be returned    \return a pointer to the GenericValueT object of which the name associated    with the variable matches the argument; 0 when a GenericValueT object with a    variable associated with the given name does not exist */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 );}/*! This method determines the value of the variable of which the name    associated with it matches the first argument to the method. The value is    converted to a string which is put into the second argument (note that    enough memory must be allocated for this char*). This same string is also    returned by the method. This enables you to use the method as an argument    to a function such as 'strcpy'.    \param strName a string denoting the name associated with the variable of    which the value should be returned    \param strValue a string which after the method call will contain the value    of the variable of which the name associated with it matches the first    argument to the method    \return a string containing the value of the variable of which the name    associated with it matches the first argument to the method */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 );}/*! This method sets the variable of which the name associated with it matches    the first argument to the method to the value indicated by the second    argument. The value is always supplied as a string which is then converted    into the right type for the generic value in question.    \param strName a string denoting the name associated with the variable which    must be set    \param strValue a string denoting the value to which the variable indicated    by the first argument should be set    \return a boolean indicating whether the update was successful */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 right type  return ( bReturn );}/*! This method reads generic values from a file indicated by the first argument    to the method and stores them in the collection. In this file the names    associated with each value must be listed first followed by a separator and    then the value. The names associated with each value should match the string    names with which the corresponding generic value is added using    'addSetting'.    \param strFile a string denoting the name of the file from which the values    must be read    \param strSeparator a string representing the separator which is written    between name and value in the configuration file    \return a boolean indicating whether the values have been read correctly */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 );}/*! This method writes the generic values in the current collection to a file    indicated by the first argument to the method. The string name associated    with the value and the value itself are separated by a separator which is    specified as the second argument.    \param strFile a string denoting the name of the file to which the generic    values should be written    \param strSeparator a string representing the separator which should be    written between the name associated with each value and the value itself    \param bAppend a boolean indicating whether the values should be appended to    the given file (=true) or if current contents of the file should be    overwritten (=false)    \return a boolean indicating whether the values in the current collection    have been correctly written to the given file */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 );}/*! This display method writes all the generic values in the current collection    to the output stream indicated by the first argument to the method. The name    associated with each value and the value itself are separated by a separator    which is specified as the second argument.    \param out the output stream to which the current collection of generic    values should be written    \param strSeparator a string representing the separator which should be    written between the name associated with each value and the value itself */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;  int    i = 10;  char*  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 );}*/