---

config_processor.cc

/*
*  Name:         config_processor.cc
*  Author:       Rafael Jesus Alcantara Perez
*  Contributor:  Francisco Vides Fernandez
*  Summary:      Config processor
*  Date:         $Date: 2003/04/14 00:18:35 $
*  Revision:     $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <cstdlib>
#include <fstream>
#include <mpcl/system/all.hh>
#include <mpcl/text/regex/matcher.hh>
#include <mpcl/text/string.hh>
#include <mpcl/util/prefs/config_processor.hh>
#include <sstream>


//
//  C O N S T R U C T O R S
//

void mpcl::util::prefs::TConfigProcessor::
addOption (const TString& rkyNAME, const TString& rkySHORTCUT)
{

  using text::Format;

  TString                         yFullName;
  TString                         yShortcut (rkySHORTCUT);
  TOptionVector::const_iterator   I (tOptionVector.begin());

  if ( yCurrentNameSpace.empty() )
  {
    yFullName = rkyNAME;
  }
  else
  {
    yFullName = yCurrentNameSpace + "." + rkyNAME;
  }
  yFullName.lowercase();
  for (; ( I != tOptionVector.end() ) ;++I)
  {
    if ( I->name() == yFullName )
    {
      TString   yMessage (Format ("option name '%s' already defined", yFullName.c_str()));

      throw TOptionAlreadyDefinedException (yMessage, __FILE__, __LINE__);
    }
    if ( I->shortcut() == yShortcut )
    {
      TString   yMessage (Format ("option shortcut '%s' already defined", yShortcut.c_str()));

      throw TOptionAlreadyDefinedException (yMessage, __FILE__, __LINE__);
    }
  }
  tOptionVector.push_back (TOption (yFullName, yShortcut));
  gOptionsProcessed = false;
  
}  // addOption()
  

void mpcl::util::prefs::TConfigProcessor::
addOption ( const TString& rkyNAME     ,
            const TString& rkySHORTCUT ,
            const TString& rkyVALUE    )
{

  using text::Format;

  TString                         yFullName;
  TString                         yShortcut (rkySHORTCUT);
  TOptionVector::const_iterator   I (tOptionVector.begin());

  if ( yCurrentNameSpace.empty() )
  {
    yFullName = rkyNAME;
  }
  else
  {
    yFullName = yCurrentNameSpace + "." + rkyNAME;
  }
  yFullName.lowercase();
  for (; ( I != tOptionVector.end() ) ;++I)
  {
    if ( I->name() == yFullName )
    {
      TString   yMessage (Format ("option name '%s' already defined", yFullName.c_str()));

      throw TOptionAlreadyDefinedException (yMessage, __FILE__, __LINE__);
    }
    if ( I->shortcut() == yShortcut )
    {
      TString   yMessage (Format ("option shortcut '%s' already defined", yShortcut.c_str()));

      throw TOptionAlreadyDefinedException (yMessage, __FILE__, __LINE__);
    }
  }
  tOptionVector.push_back (TOption (yFullName, yShortcut, rkyVALUE));
  gOptionsProcessed = false;
  
}  // addOption()


void mpcl::util::prefs::TConfigProcessor::
addEnvironmentVariable (const char* pkcENVIRONMENT_NAME, bool gREQUIRED)
  throw (TVariableNotFoundException)
{

  using std::getenv;
  using text::Format;

  if ( !pkcENVIRONMENT_NAME )
  {
    throw TVariableNotFoundException ("null environment name", __FILE__, __LINE__);
  }
  else
  {
    const char*   pkcEnvironmentValue = getenv (pkcENVIRONMENT_NAME);
    
    if ( pkcEnvironmentValue )
    {
      tEnvironmentVariableMap.bind (pkcENVIRONMENT_NAME, pkcEnvironmentValue);
    }
    else
    {
      if ( gREQUIRED )
      {
        TString   yMessage;
        
        yMessage = Format ("environment variable '%s' has null value", pkcENVIRONMENT_NAME);
        throw TVariableNotFoundException (yMessage, __FILE__, __LINE__);
      }
      else
      {
        tEnvironmentVariableMap.bind (pkcENVIRONMENT_NAME, "");
      }
    }
  }
  
}  // addEnvironmentVariable()


void mpcl::util::prefs::TConfigProcessor::
processConfigFile (void)
{

  using text::Format;

  if ( gInputConfigFile )
  {
    std::basic_ifstream<char>   tConfigFileIfstream (yConfigFileName.c_str());

    if ( !tConfigFileIfstream.is_open() )
    {
      TString   yMessage;
      
      yMessage = Format ("couldn't open file '%s'", yConfigFileName.c_str());
      throw TFileErrorException (yMessage, __FILE__, __LINE__);
    }
    
    //
    //  Load parameter values from configuration file.
    //
    read (tConfigFileIfstream);
  }
  
}  // processConfigFile()


void mpcl::util::prefs::TConfigProcessor::
processCommandLine (void)
{

  using text::regex::TMatcher;

  if ( iParametersCount )
  {
    TString    yOptionName;
    TString    yOptionShortcut;
    TString    yOptionValue;
    TMatcher   tMatcher;
    
    for (register int J = 1; ( J < iParametersCount ) ;++J)
    {
      std::basic_istringstream<char_type>   tCurrentOption (ppkcParametersList [J]);
      
      yOptionName.erase();
      yOptionShortcut.erase();
      yOptionValue.erase();
      
      //
      //  Warning:  There should exists better support
      //            from TMatcher.
      //

      //
      //  Scan option.
      //
      tMatcher.setInput (tCurrentOption);
      if ( tMatcher.scan ("--%s=%t", &yOptionName, &yOptionValue, NULL) )
      {
        updateOptionWithName (yOptionName, yOptionValue).setCmdLinePresence();
      }
      else if ( tMatcher.scan ("-%s=%t", &yOptionShortcut, &yOptionValue, NULL) )
      {
        updateOptionWithShortcut (yOptionShortcut, yOptionValue).setCmdLinePresence();
      }
      else if ( tMatcher.scan ("--%s", &yOptionName, NULL) )
      {
        optionWithName (yOptionName).setCmdLinePresence();
      }
      else if ( tMatcher.scan ("-%s", &yOptionShortcut, NULL) )
      {
        optionWithName (nameForShortcut (yOptionShortcut)).setCmdLinePresence();
      }
      else
      {
        //
        //  Add to "tCommandLineArgumentsArray" all the arguments 
        //  (not options) passed to the user of the instance.
        //
        tCommandLineArgumentsArray.push_back (ppkcParametersList [J]);
      }
    }
  }
  
}  // processCommandLine()


void mpcl::util::prefs::TConfigProcessor::
read (std::basic_istream<char_type, traits_type>& rtSOURCE_ISTREAM)
{

  using text::regex::TMatcher;

  TString    yOptionName;
  TString    yOptionValue;
  TMatcher   tMatcher (rtSOURCE_ISTREAM);
  int        iLineNumber = 1;
  
  //
  //  Parses every option (removing comments).
  //
  while ( rtSOURCE_ISTREAM.good() )
  {
    //
    //  Removes preceding comments and spaces.
    //
    while ( tMatcher.scan ("[[:space:]]*#%t\n", NULL) ) { ++iLineNumber; }
    while ( tMatcher.scan ("[[:space:]]*\n",    NULL) ) { ++iLineNumber; }

    //
    //  Scan option.
    //
    if ( !tMatcher.scan ( "[[:space:]]*%s[[:blank:]]*=[[:blank:]]*%t[[:blank:]]*\n" ,
                          &yOptionName                                              ,
                          &yOptionValue                                             ,
                          NULL                                                      ) )
    {
      if ( rtSOURCE_ISTREAM.peek() == EOF )
      {
        break;
      }
      else
      {
        throw TParseErrorException (NULL, yConfigFileName, iLineNumber);
      }
    }
    else
    {
      TString   yOptionNameSpace;

      ++iLineNumber;
      yOptionName.lowercase();
      yOptionNameSpace = nameSpace (yOptionName);
      if ( yOptionNameSpace.empty() )
      {
        updateOptionWithName (yOptionName, yOptionValue);
      }
      else
      {
        //
        //  If the name space is in the  valid name space set,  then it inserts
        //  the option, else it simply ignores it.
        //
        if ( tValidNameSpaceSet.find (yOptionNameSpace) != tValidNameSpaceSet.end() )
        {
          updateOptionWithName (yOptionName, yOptionValue);
        }
      }
    }
  }
  
}  // read()


mpcl::util::prefs::TOption& mpcl::util::prefs::TConfigProcessor::
updateOptionWithName ( const TString& rkyNAME  ,
                       const TString& rkyVALUE )
{

  using std::vector;
  using text::Format;

  bool                            gFound = false;
  TOptionVector::iterator         I      = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd  = tOptionVector.end();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->name() == rkyNAME )
    {
      I->addValue (rkyVALUE);
      gFound = true;
      break;
    }
  }
  if ( !gFound )
  {
    TString   yMessage;
    
    yMessage = Format ("option '%s' not found", rkyNAME.c_str());
    throw TVariableNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return *I;

}  // updateOptionWithName()


mpcl::util::prefs::TOption& mpcl::util::prefs::TConfigProcessor::
updateOptionWithShortcut ( const TString& rkySHORTCUT ,
                           const TString& rkyVALUE    )
{

  using std::vector;
  using text::Format;
  
  bool                            gFound = false;
  TOptionVector::iterator         I      = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd  = tOptionVector.end();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->shortcut() == rkySHORTCUT )
    {
      I->addValue (rkyVALUE);
      gFound = true;
      break;
    }
  }
  if ( !gFound )
  {
    TString   yMessage;
    
    yMessage = Format ("option '%s' not found", rkySHORTCUT.c_str());
    throw TVariableNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return *I;

}  // updateOptionWithShortcut()


//
//  S E L E C T O R S
//

unsigned int mpcl::util::prefs::TConfigProcessor::longestOptionLength() const
{

  using std::vector;

  unsigned int                    uiRet;
  TOptionVector::const_iterator   I     = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd = tOptionVector.end();

  for (uiRet = I->name().length(); I != ktEnd ;++I)
  {
    if ( uiRet < I->name().length() )
    {
      uiRet = I->name().length();
    }
  }  
  return uiRet;

}  // longestOptionLength()


mpcl::text::TString mpcl::util::prefs::TConfigProcessor::
nameForShortcut (const TString& rkySHORTCUT) const
{
  
  using std::vector;

  TString                         yResultName;
  TOptionVector::const_iterator   I     = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd = tOptionVector.end();
  
  for (; I != ktEnd ;++I)
  {
    if ( I->shortcut() == rkySHORTCUT )
    {
      yResultName = I->name();
      break;
    }
  }
  return yResultName;
  
}  // nameForShortCut()


mpcl::text::TString mpcl::util::prefs::TConfigProcessor::nameSpace (const TString& rkyNAME) const
{

  TString              yNameSpace;
  TString::size_type   zPosition = rkyNAME.rfind ('.');

  if ( zPosition != TString::npos )
  {
    yNameSpace = rkyNAME.substr (0, zPosition);
  }
  return yNameSpace;

}  // nameSpace()


const mpcl::util::prefs::TOption& mpcl::util::prefs::TConfigProcessor::operator [] (const char* pkcNAME) const
  throw (TVariableNotFoundException)
{
  
  using std::vector;
  using text::Format;

  TOptionVector::const_iterator   I     = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd = tOptionVector.end();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->name() == pkcNAME )
    {
      break;
    } 
  }
  if ( I == ktEnd )
  {
    TString   yMessage;
    
    yMessage = Format ("option '%s' not found", pkcNAME);
    throw TVariableNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return *I;
  
}  // operator []()


mpcl::util::prefs::TOption& mpcl::util::prefs::TConfigProcessor::
operator [] (const char* pkcNAME)
  throw (TVariableNotFoundException)
{
  
  using text::Format;

  TOptionVector::iterator         I     = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd = tOptionVector.end();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->name() == pkcNAME )
    {
      break;
    } 
  }
  if ( I == ktEnd )
  {
    TString   yMessage;
    
    yMessage = Format ("option '%s' not found", pkcNAME);
    throw TVariableNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return *I;
  
}  // operator []()


mpcl::text::TString mpcl::util::prefs::TConfigProcessor::
formatUsageString (void) const
{

  using std::vector;
  
  int                             iCurrentPadding;
  TString                         yPadding;
  TString                         yRet;
  TOptionVector::const_iterator   I             = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd         = tOptionVector.end();
  const int                       kiPaddingSize = longestOptionLength() + _kuiMinPadding;  

  yRet += yUsageHeader + '\n';
  do
  {
    iCurrentPadding = kiPaddingSize - I->name().length();
    yPadding.assign (iCurrentPadding, ' ');
    yRet += "  -" + I->shortcut() + ", --" + I->name() + yPadding + I->help() + '\n';
    I++;
  } while ( I != ktEnd );
  yRet += '\n';
  return yRet;

}  // formatUsageString()


const mpcl::text::TString mpcl::util::prefs::TConfigProcessor::
programFileName (void) const
{

  using system::tSystem;

  TString   yProgramFileName;
  
  if ( ppkcParametersList )
  {
    size_type   zSeparatorOffset;
    
    yProgramFileName = ppkcParametersList [0];
    zSeparatorOffset = yProgramFileName.rfind (tSystem.getDirectorySeparator());
    if ( TString::npos != zSeparatorOffset )
    {
      yProgramFileName = yProgramFileName.substr (zSeparatorOffset + 1);
    }
  }
  return yProgramFileName;
  
}  // programFileName()


void mpcl::util::prefs::TConfigProcessor::saveConfigFile (void) const
  throw (TFileErrorException)
{

  using std::ofstream;
  using text::Format;

  ofstream   tConfigFileOfstream;
  
  tConfigFileOfstream.open (yConfigFileName.c_str());
  if ( tConfigFileOfstream.is_open() )
  {
    write (tConfigFileOfstream);
  }
  else
  {
    TString   yMessage;
    
    yMessage = Format ("couldn't write file '%s'", yConfigFileName.c_str());
    throw TFileErrorException (yMessage, __FILE__, __LINE__);
  }
  tConfigFileOfstream.close();
  
}  // saveConfigFile()


mpcl::text::TString mpcl::util::prefs::TConfigProcessor::
shortcutForName (const TString& rkyNAME) const
{
  
  using std::vector;

  TString                         yResultName;
  TOptionVector::const_iterator   I     = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd = tOptionVector.end();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->name() == rkyNAME )
    {
      yResultName = I->shortcut();
      break;
    }
  }
  return yResultName;
  
}  // shortCutForName()


void mpcl::util::prefs::TConfigProcessor::
write (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const
{

  using std::vector;

  TOptionVector::const_iterator   I     = tOptionVector.begin();
  TOptionVector::const_iterator   ktEnd = tOptionVector.end();

  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->isParameterAble() )
    {
      rtTARGET_OSTREAM << *I;
    }
  }
  
}  // write()

---