PisaPhnxParv1.C

Go to the documentation of this file.

#include "PisaPhnxParv1.h"

ClassImp(PisaPhnxParv1)

ClassImp(PisaPhnxSubParv1)

//_____________________________________________________________________________
void 
split(const std::string& path, 
      std::vector<std::string>& paths,
      char sep)
{
  // Given a path e.g. /Cut##/OK/C#/V#, will return 
  // a vector of string with Cut#, 

  paths.clear();

  std::string str = path;

  if ( str.empty() )
    {
      return;
    }

  std::vector<size_t> sep_pos;

  if ( str[0] != sep ) 
    { 
      str.insert(str.begin(),sep);
    }

  if ( str[str.size()-1] != sep ) 
    {
      str.push_back(sep);
    }

  for (size_t i = 0 ; i < str.size() ; i++) 
    {
      if ( str[i] == sep ) 
        { 
          sep_pos.push_back(i);
        }
    }

  if ( sep_pos.size() > 0 ) 
    {
      for (size_t i = 0 ; i < sep_pos.size()-1 ; i++) 
        {
          paths.push_back(str.substr(sep_pos[i]+1,
                                     sep_pos[i+1]-sep_pos[i]-1));
        }
    }  
}

//_____________________________________________________________________________
std::string 
trim(const std::string& source, const std::string& ws)
{
  std::string str;

  for ( size_t j = 0; j < source.size(); ++j )
    {
      bool ok = true;
      for ( size_t i = 0; i < ws.size() && ok == true ; ++i )
        {
          if ( ws[i] == source[j] )
            {
              ok = false;
            }
        }
      if ( ok )
        {
          str += source[j];
        }
    }
  return str;
}


//_____________________________________________________________________________
void
PisaPhnxParv1::closeParameter(const std::string& subsystem,
                          const std::string& parameter,
                          const std::string& value)
{
  if (!parameter.empty())
    {
      bool isboolean = false;
      bool isinteger = false;
      bool isdouble = false;
      bool isstring = false;

      if ( value.find(".TRUE") < value.size() ||
           value.find(".FALSE.") < value.size() )
        {
          isboolean=true;
        }
      else if ( value.find('\'') < value.size() )
        {
          isstring=true;
        }
      else if ( value.find('.') < value.size() )
        {
          isdouble=true;
        }
      else
        {
          isinteger=true;
        }

      // Split the value field.
      std::vector<std::string> parts;
      split(value,parts,',');
      
#ifdef DEBUG
      std::cout << "subsystem:" << subsystem
                << " parameter:" << parameter;
      if ( isboolean ) std::cout << "(boolean)";
      if ( isinteger ) std::cout << "(integer)";
      if ( isstring ) std::cout << "(string)";
      if ( isdouble ) std::cout << "(double)";
#endif

      // Take care of multiplier qualifier '*'
      std::vector<std::string> mparts;

      for ( size_t i = 0; i < parts.size(); ++i )
        {   
          if ( parts[i].find('*') < parts[i].size() )
            {
              // Multiplicator sign found. Duplicate entries as needed.
              std::vector<std::string> tmp;
              split(parts[i],tmp,'*');
              assert(tmp.size()==2);
              int n = atoi(tmp[0].c_str());
              while ( n-- )
                {
                  mparts.push_back(tmp[1]);
                }
            }
          else
            {
              mparts.push_back(parts[i]);
            }
        }

      PisaPhnxSubParv1& par = fMap[subsystem];

      for ( size_t i = 0; i < mparts.size(); ++i )
        {     
          std::string value = mparts[i];

#ifdef DEBUG
          std::cout << " : " << value;
#endif
          if (isboolean)
            {
              std::transform(value.begin(), value.end(), value.begin(), 
                             (int(*)(int))std::toupper);

              if ( value.find("TRUE") < value.size() )
                {
                  par.appendBoolean(parameter.c_str(),true);
                }
              else if ( value.find("FALSE") < value.size() )
                {
                  par.appendBoolean(parameter.c_str(),false);
                }
              else
                {
                  assert(0==1);
                }
            }
          else if ( isinteger )
            {
              par.appendInt(parameter.c_str(),atoi(value.c_str()));
            }
          else if ( isdouble ) 
            {
              par.appendDouble(parameter.c_str(),atof(value.c_str()));
            }
          else if ( isstring )
            {
              assert(value.size()-2>0);
              par.appendString(parameter.c_str(),
                               value.substr(1,value.size()-2).c_str());
              // remove leading and trailing '
            }
          else
            {
              assert(0==1);
            }
        }
#ifdef DEBUG
      std::cout << std::endl;
#endif
    }
}

//_____________________________________________________________________________
PisaPhnxParv1::PisaPhnxParv1(const char* file)
{
  std::ifstream in(file);

  if (!in) throw;

  std::string line;
  std::string subsystem = "";
  std::string parameter = "";
  std::string value = "";

  while ( std::getline(in,line) )
    {
      if ( line[0] != ' ' && line[0] != '\t' )
        {
          // comment line
          continue;
        }

      if ( line.find('$') < line.size() )
        {
          if ( line.find("$end") < line.size() )
            {
              // end of subsystem. Close current parameter.
              closeParameter(subsystem,parameter,value);
              parameter = "";
            }
          subsystem = trim(line," \t"); // remove whitespaces
          subsystem = subsystem.substr(1,subsystem.size()-1); // remove leading $
          continue;
        }

      if ( line.find('=') < line.size() )
        {        
          // New parameter. First close the current one, if any.
          closeParameter(subsystem,parameter,value);
          
          std::vector<std::string> parts;
          split(line,parts,'=');
          parameter = trim(parts[0]," \t");
          value = trim(parts[1]," \t");
        }
      else
        {
          // continuation line of the same parameter.
          value += trim(line," \t");
        }
    }

  in.close();

}

//_____________________________________________________________________________
bool
PisaPhnxParv1::has(const char* subsystem) const
{
  return fMap.find(subsystem) != fMap.end();
}

//_____________________________________________________________________________
void
PisaPhnxParv1::print(std::ostream& os) const
{
  TMAP::const_iterator it;

  for ( it = fMap.begin(); it != fMap.end(); ++it )
    {
      os << std::string(80,'-') << std::endl;
      os << "Subsystem " << it->first << " parameters:" << std::endl;
      os << it->second << std::endl;
    }
}

//_____________________________________________________________________________
const PisaPhnxSubParv1*
PisaPhnxParv1::get(const char* subsystem) const
{
  if ( has(subsystem) )
    {
      return &fMap.find(subsystem)->second;
    }
  else
    {
      std::cerr << __FILE__ << ":" << __LINE__
                << "Do not know this subsystem=" 
                << subsystem
                << std::endl;
      return 0;
    }
}