JobCommand.cxx

Go to the documentation of this file.

// $Id: JobCommand.cxx,v 1.24 2009/07/24 07:52:19 nwest Exp $
//
// Convert text strings to command paths and options and provide easy
// access to the command path and options to clients
//
// messier@huhepl.harvard.edu
#include <cstdlib> // atoi(), atof(), strtod()

#include "JobControl/JobCommand.h"
#include "MessageService/MsgService.h"
#include "Registry/Registry.h"

CVSID("$Id: JobCommand.cxx,v 1.24 2009/07/24 07:52:19 nwest Exp $");

//......................................................................

ostream& operator<<(ostream& os, const JobCommand& jc) 
{
  vector<string>::const_iterator itrend(jc.fCmdList.end());
  vector<string>::const_iterator itr;
  bool ifirst = true;
  for (itr = jc.fCmdList.begin(); itr!= itrend; ++itr) {
    if (ifirst) { os << (*itr); ifirst = false; }
    else os << "/" << (*itr);
  }
  itrend = jc.fOptList.end();
  for (itr = jc.fOptList.begin(); itr!= itrend; ++itr) {
    os << " " << (*itr);
  }
  return os;
}

//......................................................................

JobCommand::JobCommand() 
{
//======================================================================
// Purpose: Create an empty command
//======================================================================
  // Flag these as empty
  fItrCmdList = fCmdList.end();
  fItrOptList = fOptList.end();
}

//......................................................................

JobCommand::JobCommand(const char *cmd) 
{
  this->Parse(cmd);
}

//......................................................................

void JobCommand::Parse(const char *cmd) 
{
//======================================================================
// Purpose: Parse a command line
//
// For example the command:
//
// /Path/Module/Set a 10
//
// Has fCmdList = {"Path","Module","Set"} and
//     fOptList = {"a", "10"}
//
// Any command starting as "#" is taken to be a comment. Also,
// standard C and C++ commenting styles are supported. However,
// multi-line comments are *not* supported.
//======================================================================
  int len;       // Number of characters in the command
  bool procCmd;  // Are we working on the command?
  bool procOpt;  // Are we handling options?
  bool inQuotes; // Are we inside a quoted string?
  bool expectSpecial; // Expect a special character?
  string word;   // The current word in the command line
  // MsgStream& msgDebug = MSGSTREAM("JobC",Msg::kDebug); // Debug stream
  
  word          = "";
  len           = strlen(cmd);
  procCmd       = true;
  procOpt       = false;
  inQuotes      = false;
  expectSpecial = false;
  // msgDebug << "Parse: ";
  for (int i=0; i<len; ++i) {
    // If we've been told not to treat this character as a token, just
    // and it to the word
    if (expectSpecial) {
      word += cmd[i];
      expectSpecial = false;
      continue; // next character
    }

    // See if we have a \ which flags that the next character is not a token
    if (cmd[i] == '\\') {
      expectSpecial = true;
      continue; // next character;
    }

    // Check if we are entering/leaving a quoted passage
    if (cmd[i] == '"' || cmd[i] == '\'') {
      inQuotes = !inQuotes;
      continue; // next character
    }
    if (inQuotes) {
      // Use every character inside quotes
      word += cmd[i];
      continue; // next character
    }

    // Skip extra white space
    if (i>0 && cmd[i]==' ' && cmd[i-1]==' ') {
      continue; // next character
    }

    // Check for command separator
    if (procCmd && cmd[i] == '/') {
      // Place the previous word (if there is one) in the command list
      if (word.length()>0) fCmdList.push_back(word);
      // msgDebug << '/' << word;
      word = "";
      continue; // next character
    }

    // White space is used to separate commands from options and
    // options from each other
    if (cmd[i] == ' ' || cmd[i] == '=') {
      if (procCmd) {
        // Place the previous work in the command list
        // msgDebug << '/' << word;
        if (word.length()>0) fCmdList.push_back(word);
        word = "";
        // Switch from processing commands to options
        procCmd = false;
        procOpt = true;
      }
      else if (procOpt) {
        // msgDebug << '|' << word;
        if (word.length()>0) fOptList.push_back(word);
        word = "";
      }
      continue; // next character
    }
    
    // Character triggered no special action -- add it to word
    word += cmd[i];
  } // End loop over characters


  if (procCmd) {
    // msgDebug << '/' << word;
    if (word.length()) fCmdList.push_back(word);
  }
  if (procOpt) {
    // msgDebug << '|' << word;
    if (word.length()) fOptList.push_back(word);
  }
  // msgDebug << "\n";

  // Point the iterators at the begining of the lists
  fItrCmdList = fCmdList.begin();
  fItrOptList = fOptList.begin();
}

//......................................................................

JobCommand::~JobCommand() {}

//......................................................................

bool JobCommand::HaveCmd() const
{
//======================================================================
// Purpose: Are there parts of the command that need processing?
//
// Returns: true  - there are more parts of the command to parse
//          false - there are no more parts of the command to parse
//======================================================================
  if (fItrCmdList == fCmdList.end()) return false;
  return true;
}

//......................................................................

bool JobCommand::HaveOpt() const
{
//======================================================================
// Purpose: Are there options that need processing?
//
// Returns: true  - options remain, 
//          false - no more options left
//======================================================================
  if (fItrOptList == fOptList.end()) return false;
  return true;
}

//......................................................................

const char *JobCommand::PopCmd()
{
//======================================================================
// Purpose: Return the current option parameter as a character string
//
// Returns: A pointer to the start of the option character string
//          If the list of options has been exhausted this returns ""
//======================================================================
  if (this->HaveCmd()) {
    const char *val = 0;
    val = (*fItrCmdList).c_str();
    ++fItrCmdList;
    return val;
  }
  return 0;
}

//......................................................................

const char *JobCommand::PushCmd()
{
//======================================================================
// Purpose: Return the current option parameter as a character string
//
// Returns: A pointer to the start of the option character string
//          If the list of options has been exhausted this returns ""
//======================================================================
  if (fItrCmdList != fCmdList.begin()) {
    const char *val = 0;
    --fItrCmdList;
    val = (*fItrCmdList).c_str();
    return val;
  }
  return 0;
}

const char *JobCommand::PushOpt()
{
//======================================================================
// Purpose: Return the current option parameter as a character string
//
// Returns: A pointer to the start of the option character string
//          If the list of options has been exhausted this returns ""
//======================================================================
  if (fItrOptList != fOptList.begin()) {
    const char *val = 0;
    --fItrOptList;
    val = (*fItrOptList).c_str();
    return val;
  }
  return 0;
}

//......................................................................

const char *JobCommand::PopOpt()
{
//======================================================================
// Purpose: Return the current option parameter as a character string
//
// Returns: A pointer to the start of the option character string
//          If the list of options has been exhausted this returns ""
//======================================================================
  if (this->HaveOpt()) {
    const char *val = 0;
    val = (*fItrOptList).c_str();
    ++fItrOptList;
    return val;
  }
  return 0;
}

//......................................................................

int JobCommand::PopIntOpt()
{
//======================================================================
// Purpose: Return the current option parameter as an integer number
//          and advance the counter.
//
// Returns: The current option interpreted as an integer number
//          If the list of options has been exhausted this returns 0
//======================================================================
  if (this->HaveOpt()) {
    int val;
    val = atoi((*fItrOptList).c_str());
    ++fItrOptList;
    return val;
  }
  return 0;
}

//......................................................................

double JobCommand::PopFloatOpt()
{
//======================================================================
// Purpose: Return the current option parameter as a floating point
//          number and advance the counter.
//
// Returns: The current option interpreted as a floating point number
//          If the list of options has been exhausted this returns 0.0
//======================================================================
  if (this->HaveOpt()) {
    double val = 0.0;
    val = atof((*fItrOptList).c_str());
    ++fItrOptList;
    return val;
  }
  return 0.0;
}

//......................................................................

void JobCommand::SplitLine(const char *line, char sep, string& a, string& b)
{
//======================================================================
// Purpose: Split a character string into two pieces given a
//          separator.  Example peas::carots into peas and carrots
//
// Inputs: line - the text to split
//         sep  - the separation character (':' in the example above)
//         a    - text before the separator
//         b    - text after separator
//======================================================================
  // Clear a and b strings
  a = "";
  b = "";
  bool doFront = true;
  for (const char* c = line; *c != '\0'; ++c) {
    if (*c == ' ') continue;
    if (*c == sep) {
      doFront = false;
      continue;
    }
    if (doFront) a += (*c);
    else         b += (*c);
  }

  MSG("JobC",Msg::kVerbose) << 
    "Split " << line << " into " << a << " " << b << ".\n";
}


//......................................................................

void JobCommand::StringTok(std::vector<std::string>& ls,
                           const std::string& str,
                           const std::string& tok)
{
//======================================================================
// Split a long string into a set of shorter strings spliting along
// divisions makers by the characters listed in the token string
//======================================================================
  const string::size_type S     = str.size();
  const string::size_type toksz = tok.size();
  string::size_type  i = 0;
  
  while (i < S) {
    // eat leading whitespace
    while ( (i<S) && (tok.find(str[i])<=toksz) ) {
      ++i;
    }
    if (i == S)  return;  // nothing left but WS
    
    // find end of word
    string::size_type  j = i+1;
    while ( (j<S) && !(tok.find(str[j])<=toksz) ) {
      ++j;
    }

    // add word
    ls.push_back(str.substr(i,j-i));
    
    // set up for next loop
    i = j+1;
  }  
}

//......................................................................

bool JobCommand::IsInt(const char* s) 
{
//======================================================================
// Does the string s represent an integer?
//======================================================================
  char* endptr;
  strtol(s, &endptr,0);
// Consider this a failure if the entire string does not convert to a long
  if (endptr != (s + strlen(s))) return false;
  
  // All checks for "intness" passed
  return true;
}


//......................................................................

bool JobCommand::IsFloat(const char* s)
{
//======================================================================
// Does the string s represent a float?
//======================================================================
  char* endptr;
  strtod(s, &endptr);
// Consider this a failure if the entire string does not convert to a  double
  if (endptr != (s + strlen(s))) return false;
  
  // All checks for "floatness" passed
  return true;
}

//......................................................................

void JobCommand::StringToRegistry(Registry& r, const char* s) 
{
//======================================================================
// Convert a string like "a=1 b=2.0 name=Mark" to a registry
//======================================================================
  // JobCommand's expect format Command option1 option2...  so cast
  // the string into this form by prepending a bogus command string
  string cmd("Set "); // Set is as good a command name as any...
  cmd += s;           // Append the registry string
  JobCommand c(cmd.c_str());

  // Use the command to build a registry
  r.UnLockValues();
  while (c.HaveOpt()) {
    const char* key;
    const char* value;

    // Extract key/value pair
    key = c.PopOpt();
    if (c.HaveOpt() == false) {
      MSG("JobC",Msg::kWarning) << "Missing value for key \"" 
                                << key << "\"!" << endl;
      return;
    }
    value = c.PopOpt();
    
    // Guess type of value and build registry
    if (JobCommand::IsInt(value)) {
      // Intergers are floats so check them next
      int i = atoi(value);
      r.Set(key, i);
    }
    else if (JobCommand::IsFloat(value)) {
      // Check float as it is the smallest set
      double d = atof(value);
      r.Set(key, d);
    }
    else if (JobCommand::IsBool(value)) {
      bool b = JobCommand::atob(value);
      r.Set(key, b); // Which Set is this?? char? int? Dunno...
    }
    else {
      // Everything is a string so check that last
      r.Set(key, value);
    }
  }

  r.LockValues();
}

//......................................................................

bool JobCommand::IsBool(const char* value)
{
//======================================================================
// Can the string value be interpreted as a bool value?
//======================================================================
  std::string v(value);
  if (v == "true")   return true; // C++ style
  if (v == "false")  return true;
  if (v == "kTRUE")  return true; // ROOT style
  if (v == "kFALSE") return true;
  if (v == "TRUE")   return true; // Some other reasonable variations...
  if (v == "FALSE")  return true;
  if (v == "True")   return true;
  if (v == "False")  return true;
  if (v == "on")     return true;
  if (v == "off")    return true;
  if (v == "On")     return true;
  if (v == "Off")    return true;
  if (v == "ON")     return true;
  if (v == "OFF")    return true;
  return false;
}

//......................................................................

bool JobCommand::atob(const char* value)
{
//======================================================================
// Convert the text string to its bool equivalent No error checking is
// done. Returns "false" if the contents of value are not regognized
//======================================================================
  std::string v(value);
  if (v == "true")   return true;  // C++ style
  if (v == "false")  return false;
  if (v == "kTRUE")  return true;  // ROOT style
  if (v == "kFALSE") return false;
  if (v == "TRUE")   return true;  // Some other reasonable variations...
  if (v == "FALSE")  return false;
  if (v == "True")   return true;
  if (v == "False")  return false;
  if (v == "on")     return true;
  if (v == "off")    return false;
  if (v == "On")     return true;
  if (v == "Off")    return false;
  if (v == "ON")     return true;
  if (v == "OFF")    return false;

  // Oops, what have we here?
  MSG("JobC",Msg::kWarning) << 
    "Attmept to convert string '" << value << "' to bool. Result is 'false'\n";
  return false;
}

---