#include <CommandLineParser.h>

Inheritance diagram for optutl::CommandLineParser:

Public Types
enum	{ kEventContOpt = 1 << 0 }

Public Types inherited from optutl::VariableMapCont
typedef std::vector< double >	DVec

typedef DVec::const_iterator	DVecConstIter

typedef DVec::iterator	DVecIter

typedef std::vector< int >	IVec

typedef IVec::const_iterator	IVecConstIter

typedef IVec::iterator	IVecIter

enum	OptionType { kNone = 0, kInteger, kDouble, kString, kBool, kIntegerVector, kDoubleVector, kStringVector, kNumOptionTypes }

typedef std::map< std::string, bool >	SBMap

typedef SBMap::const_iterator	SBMapConstIter

typedef SBMap::iterator	SBMapIter

typedef std::map< std::string, double >	SDMap

typedef SDMap::const_iterator	SDMapConstIter

typedef SDMap::iterator	SDMapIter

typedef std::map< std::string, DVec >	SDVecMap

typedef SDVecMap::const_iterator	SDVecMapConstIter

typedef SDVecMap::iterator	SDVecMapIter

typedef std::map< std::string, int >	SIMap

typedef SIMap::const_iterator	SIMapConstIter

typedef SIMap::iterator	SIMapIter

typedef std::map< std::string, IVec >	SIVecMap

typedef SIVecMap::const_iterator	SIVecMapConstIter

typedef SIVecMap::iterator	SIVecMapIter

typedef std::map< std::string, std::string >	SSMap

typedef SSMap::const_iterator	SSMapConstIter

typedef SSMap::iterator	SSMapIter

typedef std::map< std::string, SVec >	SSVecMap

typedef SSVecMap::const_iterator	SSVecMapConstIter

typedef SSVecMap::iterator	SSVecMapIter

typedef std::vector< std::string >	SVec

typedef SVec::const_iterator	SVecConstIter

typedef SVec::iterator	SVecIter

Public Member Functions
void	_finishDefaultOptions (std::string tag="")

const SVec	argVec () const

	CommandLineParser (const std::string &usage, unsigned int optionsType=kEventContOpt)

void	help ()

void	parseArguments (int argc, char **argv, bool allowArgs=false)

void	printOptionValues ()

void	setPrintOptoins (bool print)

Public Member Functions inherited from optutl::VariableMapCont
void	_checkKey (std::string &key, const std::string &description="")

void	addOption (std::string key, OptionType type, const std::string &description="")

void	addOption (std::string key, OptionType type, const std::string &description, int defaultValue)

void	addOption (std::string key, OptionType type, const std::string &description, double defaultValue)

void	addOption (std::string key, OptionType type, const std::string &description, const std::string &defaultValue)

void	addOption (std::string key, OptionType type, const std::string &description, const char *defaultValue)

void	addOption (std::string key, OptionType type, const std::string &description, bool defaultValue)

void	addVariable (std::string key, OptionType type)

void	addVariable (std::string key, OptionType type, int defaultValue)

void	addVariable (std::string key, OptionType type, double defaultValue)

void	addVariable (std::string key, OptionType type, const std::string &defaultValue)

void	addVariable (std::string key, OptionType type, const char *defaultValue)

void	addVariable (std::string key, OptionType type, bool defaultValue)

bool &	boolValue (std::string key)

double &	doubleValue (std::string key)

DVec &	doubleVector (std::string key)

OptionType	hasOption (std::string key)

OptionType	hasVariable (std::string key)

void	help ()

int &	integerValue (std::string key)

IVec &	integerVector (std::string key)

std::string &	stringValue (std::string key)

SVec &	stringVector (std::string key)

	VariableMapCont ()

Static Public Member Functions
static void	findCommand (const std::string &line, std::string &command, std::string &rest)

static void	removeComment (std::string &line)

static std::string	removeEnding (const std::string &input, const std::string &ending)

static void	removeLeadingAndTrailingSpaces (std::string &line)

static void	split (SVec &retval, std::string line, std::string match=" \t", bool ignoreComments=true)

Static Public Member Functions inherited from optutl::VariableMapCont
static void	lowercaseString (std::string &arg)

static char	toLower (char &ch)

Static Public Attributes
static const std::string	kSpaces = " \t"

Static Public Attributes inherited from optutl::VariableMapCont
static const bool	kDefaultBool = false

static const double	kDefaultDouble = 0.

static const int	kDefaultInteger = 0

static const std::string	kDefaultString = ""

static const DVec	kEmptyDVec

static const IVec	kEmptyIVec

static const SVec	kEmptySVec

Private Member Functions
void	_getSectionFiles (const SVec &inputList, SVec &outputList, int section, int totalSection)

bool	_runVariableCommandFromString (const std::string &arg)

bool	_setVariableFromString (const std::string &arg, bool dontOverrideChange=false, int offset=0)

bool	_setVariablesFromFile (const std::string &filename)

Private Attributes
std::string	m_argv0

SVec	m_fullArgVec

unsigned int	m_optionsType

bool	m_printOptions

std::string	m_usageString

Friends
std::ostream &	operator<< (std::ostream &o_stream, const CommandLineParser &rhs)

Additional Inherited Members
Protected Member Functions inherited from optutl::VariableMapCont
bool	_valueHasBeenModified (const std::string &key)

Protected Attributes inherited from optutl::VariableMapCont
SBMap	m_boolMap

SDMap	m_doubleMap

SDVecMap	m_doubleVecMap

SIMap	m_integerMap

SIVecMap	m_integerVecMap

SSMap	m_stringMap

SSVecMap	m_stringVecMap

SSMap	m_variableDescriptionMap

SBMap	m_variableModifiedMap

Detailed Description

Definition at line 11 of file CommandLineParser.h.

Member Enumeration Documentation

anonymous enum

Enumerator
kEventContOpt

Definition at line 20 of file CommandLineParser.h.

       {
          kEventContOpt = 1 << 0
       };

Constructor & Destructor Documentation

CommandLineParser::CommandLineParser	(	const std::string &	usage,
		unsigned int	optionsType = `kEventContOpt`
	)

Definition at line 20 of file CommandLineParser.cc.

References optutl::VariableMapCont::addOption(), MessageLogger_cfi::cerr, optutl::VariableMapCont::kBool, kEventContOpt, optutl::VariableMapCont::kInteger, optutl::VariableMapCont::kString, optutl::VariableMapCont::kStringVector, and m_optionsType.

                                                                 :
    m_argv0(""), m_usageString (usage), 
    m_printOptions (true), m_optionsType (optionsType)
 {
    if (m_optionsType & kEventContOpt)
    {
       // Integer options
       addOption ("totalSections", kInteger,
                  "Total number of sections", 
                  0);
       addOption ("section",       kInteger,
                  "This section (from 1..totalSections inclusive)", 
                  0);
       addOption ("maxEvents",     kInteger,
                  "Maximum number of events to run over (0 for whole file)", 
                  0);
       addOption ("jobID",         kInteger,
                  "jobID given by CRAB,etc. (-1 means append nothing)", 
                  -1);
       addOption ("outputEvery",   kInteger,
                  "Output something once every N events (0 for never)", 
                  0);
       // String options
       addOption ("outputFile",    kString,
                  "Output filename", 
                  "output.root");
       addOption ("storePrepend",  kString,
                  "Prepend location on files starting with '/store/'");
       addOption ("tag",           kString,
                  "A 'tag' to append to output file (e.g., 'v2', etc.)");
       // Bool options
       addOption ("logName",       kBool,
                  "Print log name and exit");
       // String vector options
       addOption ("inputFiles",    kStringVector,
                  "List of input files");
       addOption ("secondaryInputFiles",    kStringVector,
                  "List of secondary input files (a.k.a. two-file-solution");
       addOption ("orderedSecondaryFiles", kBool,
          "Are the secondary files ordered?",
          false );
       return;
    }
    // If we're still here, we have a type I don't understand.
    cerr << "CommandLineParser() Error: type '" << optionsType 
         << "' is not understood.  Aborting." << endl;
    assert (0);   
 }

Member Function Documentation

void CommandLineParser::_finishDefaultOptions ( std::string tag = "" )

Definition at line 753 of file CommandLineParser.cc.

References _getSectionFiles(), optutl::VariableMapCont::boolValue(), gather_cfg::cout, cmsRelvalreport::exit, corrVsCorr::filename, optutl::VariableMapCont::integerValue(), kEventContOpt, m_optionsType, m_printOptions, match(), download_sqlite_cfg::outputFile, printOptionValues(), removeEnding(), optutl::VariableMapCont::stringValue(), optutl::VariableMapCont::stringVector(), and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by argVec(), and fwlite::EventContainer::EventContainer().

 {
   if (! (m_optionsType & kEventContOpt) )
    {
       // nothing to see here, folks
       return;
    }
    // Deal with sections //
    if ( integerValue ("totalSections") )
    {
       // we have a request to break this into sections.  First, note
       // this in the output file
       tag += Form ("_sec%03d", integerValue ("section"));
       SVec tempVec;
       _getSectionFiles ( stringVector ("inputFiles"), 
                          tempVec,
                          integerValue ("section"),
                          integerValue ("totalSections") );
       stringVector ("inputFiles") = tempVec;  
    } // if section requested
 
    // Store lfn to pfn //
    const string &kStorePrepend = stringValue ("storePrepend");
    if (kStorePrepend.length())
    {
       string match = "/store/";
       int matchLen = match.length();
       SVec tempVec;
       SVec &currentFiles = stringVector ("inputFiles");
       for (SVecConstIter iter = currentFiles.begin();
            currentFiles.end() != iter;
            ++iter)
       {
          const string &filename = *iter;
          if ((int) filename.length() > matchLen &&
              filename.substr(0, matchLen) == match)
          {
             tempVec.push_back( kStorePrepend + filename );
          } else {
             tempVec.push_back( filename);
          }
       }
       currentFiles = tempVec;
    } // if storePrepend.
 
    // //////////////////////////// //
    // // Modify output filename // //
    // //////////////////////////// //
    string outputFile = stringValue ("outputFile");
    bool modifyOutputFile = ( outputFile.length() );
    outputFile = removeEnding (outputFile, ".root");
    outputFile += tag;
    if ( integerValue ("maxEvents") )
    {
       outputFile += Form ("_maxevt%03d", integerValue ("maxEvents"));
    }
    if ( integerValue ("jobID") >= 0)
    {
       outputFile += Form ("_jobID%03d", integerValue ("jobID"));
    }
    if ( stringValue ("tag").length() )
    {
       outputFile += "_" + stringValue ("tag");
    }
 
    // Log File Name, if requested //
    if ( boolValue ("logName") )
    {
       cout << outputFile << ".log" << endl;
       exit(0);
    }
    outputFile += ".root";
    if (modifyOutputFile)
    {
       stringValue ("outputFile") = outputFile;
    }
 
    // finally, if they asked us to print all options, let's do so
    // after we've modified all variables appropriately
    if (m_printOptions)
    {
       printOptionValues();
    } // if printOptions
 }

void CommandLineParser::_getSectionFiles	(	const SVec &	inputList,
		SVec &	outputList,
		int	section,
		int	totalSection
	)

private

Definition at line 709 of file CommandLineParser.cc.

References createfilelist::int, heppy_loop::loop, pileupDistInMC::num, and trackingPlots::section.

Referenced by _finishDefaultOptions(), and argVec().

 {
    // Make sure the segment numbers make sense
    assert (section > 0 && section <= totalSections);
 
    // The Perl code:
    // my $entries    = @list;
    // my $perSection = int ($entries / $totalSections);
    // my $extra      = $entries % $totalSections;
    // --$section; # we want 0..n-1 not 1..n
    // my $start = $perSection * $section;
    // my $num   = $perSection - 1;
    // if ($section < $extra) {
    //    $start += $section;
    //    ++$num;
    // } else {
    //    $start += $extra;
    // };
    // my $end = $start + $num;
    int entries = (int) inputList.size();
    int perSection = entries / totalSections;
    int extra = entries % totalSections;
    --section; // we want 0..n-1, not 1..n.
    int current = perSection * section;
    int num = perSection - 1;
    if (section < extra)
    {
       current += section;
       ++num;
    } else 
    {
       current += extra;
    }
    outputList.clear();
    // we want to go from 0 to num inclusive, so make sure we have '<='
    // and not '='
    for (int loop = current; loop <= current + num; ++loop)
    {
       outputList.push_back( inputList.at( loop ) );
    } // for loop
 }

bool CommandLineParser::_runVariableCommandFromString ( const std::string & arg )

private

Definition at line 606 of file CommandLineParser.cc.

References MessageLogger_cfi::cerr, mps_check::command, optutl::VariableMapCont::doubleVector(), corrVsCorr::filename, optutl::VariableMapCont::hasOption(), recoMuon::in, optutl::VariableMapCont::integerVector(), optutl::VariableMapCont::kDoubleVector, crabWrapper::key, optutl::VariableMapCont::kIntegerVector, kSpaces, optutl::VariableMapCont::kStringVector, geometryCSVtoXML::line, optutl::VariableMapCont::lowercaseString(), source, split(), and optutl::VariableMapCont::stringVector().

Referenced by argVec(), and parseArguments().

 {
    SVec equalWords;
    split (equalWords, arg, "=");
    if (2 != equalWords.size())
    {
       return false;
    }
    SVec commandWords;
    split (commandWords, equalWords.at(0), "_");
    if (2 != commandWords.size())
    {
       return false;
    }
    string &command = commandWords.at(1);
    lowercaseString (command);   
    if (command != "load" && command != "clear")
    {
       return false;
    }
    const string &key = commandWords.at(0);
    OptionType type = hasOption (key);
    if (type < kIntegerVector || type > kStringVector)
    {
       cerr << "Command '" << command << "' only works on vectors." << endl;
       return false;
    }
 
    // Clear //
    if ("clear" == command)
    {
       if (kIntegerVector == type)
       {
          integerVector(key).clear();         
       } else if (kDoubleVector == type)
       {
          doubleVector(key).clear();
       } else if (kStringVector == type)
       {
          stringVector(key).clear();
       } else {
          // If we're here, then I made a coding mistake and want to
          // know about it.
          assert (0);
       }
       return true;
    }
 
    // Load //
    const string &filename = equalWords.at(1);
    ifstream source (filename.c_str(), ios::in);
    if (! source)
    {
       cerr << "file " << filename << "could not be opened" << endl;
       return false;
    }
    string line;
    while (getline (source, line))
    {
       // find the first nonspace
       string::size_type where = line.find_first_not_of (kSpaces);
       if (string::npos == where)
       {
          // no non-spaces
          continue;
       }
       // get rid of leading spaces
       line = line.substr (where);
       // get rid of trailing spaces
       where = line.find_last_not_of (kSpaces);
       if (line.length() - 1 != where)
       {
          line = line.substr (0, where + 1);
       }
       if ('#' == line.at(0))
       {
          // this is a comment line, ignore it
          continue;
       }
       if (kIntegerVector == type)
       {
          integerVector(key).push_back( (int) atof( line.c_str() ) );
       } else if (kDoubleVector == type)
       {
          doubleVector(key).push_back( atof( line.c_str() ) );
       } else if (kStringVector == type)
       {
          stringVector(key).push_back( line );
       } else {
          // If we're here, then I made a coding mistake and want to
          // know about it.
          assert (0);
       }
    } // while getline
    return true;
    
 }

bool CommandLineParser::_setVariableFromString	(	const std::string &	arg,
		bool	dontOverrideChange = `false`,
		int	offset = `0`
	)

private

Definition at line 423 of file CommandLineParser.cc.

Referenced by _setVariablesFromFile(), argVec(), and parseArguments().

 {
    string::size_type where = arg.find_first_of("=", offset + 1);
    string varname = arg.substr (offset, where - offset);
    string value   = arg.substr (where + 1);
    lowercaseString (varname);
    // check to make sure this is a valid option
    SBMapConstIter sbiter = m_variableModifiedMap.find (varname);
    if (m_variableModifiedMap.end() == sbiter)
    {
       // Not found.  Not a valid option
       return false;
    }
    // if 'dontOverrideChange' is set, then we are being asked to NOT
    // change any variables that have already been changed.
    if (dontOverrideChange && _valueHasBeenModified (varname) )
    {
       // don't go any further
       return true;
    }
    // integers
    SIMapIter integerIter = m_integerMap.find(varname);
    if (m_integerMap.end() != integerIter)
    {
       // we found it
       // use 'atof' instead of 'atoi' to get scientific notation
       integerIter->second = (int) atof( value.c_str() );
       m_variableModifiedMap[varname] = true;
       return true;
    }
    // double
    SDMapIter doubleIter = m_doubleMap.find(varname);
    if (m_doubleMap.end() != doubleIter)
    {
       // we found it
       doubleIter->second = atof( value.c_str() );
       m_variableModifiedMap[varname] = true;
       return true;
    }
    // string
    SSMapIter stringIter = m_stringMap.find(varname);
    if (m_stringMap.end() != stringIter)
    {
       // we found it
       stringIter->second = value;
       m_variableModifiedMap[varname] = true;
       return true;
    }
    // bool
    SBMapIter boolIter = m_boolMap.find(varname);
    if (m_boolMap.end() != boolIter)
    {
       // we found it
       boolIter->second = 0 != atoi( value.c_str() );
       m_variableModifiedMap[varname] = true;
       return true;
    }
    // IntegerVec
    SIVecMapIter integerVecIter = m_integerVecMap.find(varname);
    if (m_integerVecMap.end() != integerVecIter)
    {
       // we found it
       SVec words;
       split (words, value, ",");
       for (SVecConstIter wordIter = words.begin();
            words.end() != wordIter;
            ++wordIter)
       {
          integerVecIter->second.push_back( (int) atof( wordIter->c_str() ) );
       }
       // we don't want to mark this as modified because we can add
       // many values to this
       // m_variableModifiedMap[varname] = true;
       return true;
    }
    // DoubleVec
    SDVecMapIter doubleVecIter = m_doubleVecMap.find(varname);
    if (m_doubleVecMap.end() != doubleVecIter)
    {
       // we found it
       SVec words;
       split (words, value, ",");
       for (SVecConstIter wordIter = words.begin();
            words.end() != wordIter;
            ++wordIter)
       {
          doubleVecIter->second.push_back( atof( wordIter->c_str() ) );
       }
       // we don't want to mark this as modified because we can add
       // many values to this
       // m_variableModifiedMap[varname] = true;
       return true;
    }
    // StringVec
    SSVecMapIter stringVecIter = m_stringVecMap.find(varname);
    if (m_stringVecMap.end() != stringVecIter)
    {
       // we found it
       SVec words;
       split (words, value, ",");
       for (SVecConstIter wordIter = words.begin();
            words.end() != wordIter;
            ++wordIter)
       {
          stringVecIter->second.push_back( *wordIter );
       }
       // we don't want to mark this as modified because we can add
       // many values to this
       // m_variableModifiedMap[varname] = true;
       return true;
    }
    // We didn't find your variable.  And we really shouldn't be here
    // because we should have know that we didn't find your variable.
    cerr << "CommandLineParser::SetVeriableFromString() Error: "
         << "Unknown variable and internal fault.  Aborting." << endl;
    assert (0);
    return false;
 }

bool CommandLineParser::_setVariablesFromFile ( const std::string & filename )

private

Definition at line 545 of file CommandLineParser.cc.

References _setVariableFromString(), MessageLogger_cfi::cerr, cmsRelvalreport::exit, plotBeamSpotDB::first, recoMuon::in, createfilelist::int, kSpaces, geometryCSVtoXML::line, position, and source.

Referenced by argVec().

 {
    ifstream source (filename.c_str(), ios::in);
    if (! source)
    {
       cerr << "file " << filename << "could not be opened" << endl;
       return false;
    }
    string line;
    while (getline (source, line))
    {
       // find the first nonspace
       string::size_type where = line.find_first_not_of(kSpaces);
       if (string::npos == where)
       {
          // no non-spaces
          continue;
       } 
       char first = line.at (where);
       if ('-' != first)
       {
          continue;
       }
       where = line.find_first_not_of(kSpaces, where + 1);
       if (string::npos == where)
       {
          // no non-spaces
          continue;
       }
       // Get string starting at first nonspace after '-'.  Copy it to
       // another string without copying any spaces and stopping at the
       // first '#'.
       string withspaces = line.substr (where);
       string nospaces;
       for (int position = 0; 
            position < (int) withspaces.length(); 
            ++position)
       {
          char ch = withspaces[position];
          if ('#' == ch)
          {
             // start of a comment
             break;
          } else if (' ' == ch || '\t' == ch)
          {
             continue;
          }
          nospaces += ch;
       } // for position
       if (! _setVariableFromString (nospaces, true) )
       {
          cerr << "Don't understand line" << endl << line << endl
               << "in options file '" << filename << "'.  Aborting."
               << endl;
          exit(0);
       } // if setting variable failed
    } // while getline
    return true;
 }

const SVec optutl::CommandLineParser::argVec ( ) const

inline

Definition at line 53 of file CommandLineParser.h.

References _finishDefaultOptions(), _getSectionFiles(), _runVariableCommandFromString(), _setVariableFromString(), _setVariablesFromFile(), dir2webdir::argc, cmsBatch::argv, mps_check::command, corrVsCorr::filename, findCommand(), help(), input, geometryCSVtoXML::line, m_fullArgVec, match(), PFRecoTauDiscriminationByIsolation_cfi::offset, parseArguments(), printOptionValues(), removeComment(), removeEnding(), removeLeadingAndTrailingSpaces(), trackingPlots::section, split(), AlCaHLTBitMon_QueryRunRegistry::string, and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by fwlite::EventContainer::~EventContainer().

53 { return m_fullArgVec; }

optutl::CommandLineParser::m_fullArgVec

SVec m_fullArgVec

Definition: CommandLineParser.h:131

void CommandLineParser::findCommand	(	const std::string &	line,
		std::string &	command,
		std::string &	rest
	)

static

Definition at line 246 of file CommandLineParser.cc.

References kSpaces, and removeLeadingAndTrailingSpaces().

Referenced by argVec().

 {
    command = rest = "";
    string::size_type nonspace = line.find_first_not_of (kSpaces);
    if (string::npos == nonspace)
    {
       // we don't have anything here at all.  Just quit now
       return;
    }
    string::size_type space = line.find_first_of (kSpaces, nonspace);
    if (string::npos == space)
    {
       // we only have a command and nothing else
       command = line.substr (nonspace);
       return;
    }
    command = line.substr (nonspace, space - nonspace);
    rest    = line.substr (space + 1);
    removeLeadingAndTrailingSpaces (rest);
 }

void CommandLineParser::help ( )

Definition at line 143 of file CommandLineParser.cc.

References gather_cfg::cout, cmsRelvalreport::exit, m_argv0, m_usageString, and printOptionValues().

Referenced by argVec(), main(), and parseArguments().

 {
    if (m_usageString.length())
    {
       cout << m_argv0 << " - " << m_usageString << endl;
    }
    cout << "--help    - This screen" << endl
         << "--noPrint - Do not print out all settings" << endl 
         << "--print   - Print out all settings" << endl;
    printOptionValues();
    exit (0);
 }

void CommandLineParser::parseArguments	(	int	argc,
		char **	argv,
		bool	allowArgs = `false`
	)

Definition at line 71 of file CommandLineParser.cc.

References _runVariableCommandFromString(), _setVariableFromString(), dir2webdir::argc, MessageLogger_cfi::cerr, cmsRelvalreport::exit, plotBeamSpotDB::first, help(), heppy_loop::loop, optutl::VariableMapCont::lowercaseString(), m_argv0, m_fullArgVec, and m_printOptions.

Referenced by argVec(), and main().

 {   
    bool callHelp = false;
    SVec argsVec;
    m_argv0 = argv[0];
    m_fullArgVec.push_back (argv[0]);
    for (int loop = 1; loop < argc; ++loop)
    {
       string arg = argv[loop];
       m_fullArgVec.push_back (arg);
       string::size_type where = arg.find_first_of("=");
       if (string::npos != where)
       {
          if ( _setVariableFromString (arg) )
          {
             continue;
          }
          if ( _runVariableCommandFromString (arg) )
          {
             continue;
          }
          cerr << "Don't understand: " << arg << endl;
          exit(0);
       } // tag=value strings
       else if (arg.at(0) == '-')
       {
          string::size_type where = arg.find_first_not_of("-");
          if (string::npos == where)
          {
             // a poorly formed option
             cerr << "Don't understand: " << arg << endl;
             exit(0);
             continue;
          }
          lowercaseString (arg);
          char first = arg.at (where);
          // Print the values
          if ('p' == first)
          {
             m_printOptions = true;
             continue;
          }
          if ('n' == first)
          {
             m_printOptions = false;
             continue;
          }
          // Exit after printing values
          if ('h' == first)
          {
             callHelp = true;
             continue;
          }
          // if we're still here, then we've got a problem.
          cerr << "Don't understand: " << arg << endl;
          exit(0);
       } // -arg strings
       if (returnArgs)
       {
          argsVec.push_back (arg);
       } else {
          cerr << "Don't understand: " << arg << endl;
          exit(0);
       }
    } // for loop
    if (callHelp)
    {
       help();
    }
 }

void CommandLineParser::printOptionValues ( )

Definition at line 271 of file CommandLineParser.cc.

References gather_cfg::cout, heppy_report::description, optutl::VariableMapCont::m_boolMap, optutl::VariableMapCont::m_doubleMap, optutl::VariableMapCont::m_doubleVecMap, optutl::VariableMapCont::m_integerMap, optutl::VariableMapCont::m_integerVecMap, optutl::VariableMapCont::m_stringMap, optutl::VariableMapCont::m_stringVecMap, and optutl::VariableMapCont::m_variableDescriptionMap.

Referenced by _finishDefaultOptions(), argVec(), and help().

 {
    cout << "------------------------------------------------------------------" 
         << left << endl;
    // Print the integers next
    if (!m_integerMap.empty())
    {
       cout << endl << "Integer options:" << endl;
    }
    for (SIMapConstIter iter = m_integerMap.begin(); 
        m_integerMap.end() != iter; 
        ++iter) 
    {
       const string &description = m_variableDescriptionMap[ iter->first ];
       cout << "    " << setw(14) << iter->first << " = " << setw(14)
            << iter->second;
       if (description.length())
       {
          cout << " - " << description;
       }
       cout << endl;
    } // for iter
 
    // Print the doubles next
    if (!m_doubleMap.empty())
    {
       cout << endl << "Double options:" << endl;
    }
    for (SDMapConstIter iter = m_doubleMap.begin(); 
        m_doubleMap.end() != iter; 
        ++iter) 
    {
       const string &description = m_variableDescriptionMap[ iter->first ];
       cout << "    " << setw(14) << iter->first << " = " << setw(14) 
            << iter->second;
       if (description.length())
       {
          cout << " - " << description;
       }
       cout << endl;
    } // for iter
 
    // Print the bools first
    if (!m_boolMap.empty())
    {
       cout << endl << "Bool options:" << endl;
    }
    for (SBMapConstIter iter = m_boolMap.begin(); 
        m_boolMap.end() != iter; 
        ++iter) 
    {
       const string &description = m_variableDescriptionMap[ iter->first ];
       cout << "    " << setw(14) << iter->first << " = " << setw(14);
       if (iter->second)
       {
          cout << "true";
       } else {
          cout << "false";
       }
       if (description.length())
       {
          cout << " - " << description;
       }
       cout << endl;
    } // for iter
 
    // Print the strings next
    if (!m_stringMap.empty())
    {
       cout << endl << "String options:" << endl;
    }
    for (SSMapConstIter iter = m_stringMap.begin(); 
        m_stringMap.end() != iter; 
        ++iter) 
    {
       const string &description = m_variableDescriptionMap[ iter->first ];
       cout << "    " << setw(14) << iter->first << " = ";
       const string value = "'" + iter->second + "'";
       cout << setw(14) << "";
       if (description.length())
       {
          cout << " - " << description;
       }
       cout << endl << "        " << value << endl;
    } // for iter
 
    // Integer Vec
    if (!m_integerVecMap.empty())
    {
       cout << endl << "Integer Vector options:" << endl;
    }
    for (SIVecMapConstIter iter = m_integerVecMap.begin(); 
        m_integerVecMap.end() != iter; 
        ++iter) 
    {
       const string &description = m_variableDescriptionMap[ iter->first ];
       cout << "    " << setw(14) << iter->first << " = ";
       dumpSTL (iter->second); 
       cout << endl;
       if (description.length())
       {
          cout << "      - " << description;
       }
       cout << endl;
    } // for iter
 
    // Double Vec
    if (!m_doubleVecMap.empty())
    {
       cout << endl << "Double Vector options:" << endl;
    }
    for (SDVecMapConstIter iter = m_doubleVecMap.begin(); 
        m_doubleVecMap.end() != iter; 
        ++iter) 
    {
       const string &description = m_variableDescriptionMap[ iter->first ];
       cout << "    " << setw(14) << iter->first << " = ";
       dumpSTL (iter->second); 
       cout << endl;
       if (description.length())
       {
          cout << "      - " << description;
       }
       cout << endl;
    } // for iter
 
    // String Vec
    if (!m_stringVecMap.empty())
    {
       cout << endl << "String Vector options:" << endl;
    } else {
       cout << endl;
    }
    for (SSVecMapConstIter iter = m_stringVecMap.begin(); 
        m_stringVecMap.end() != iter; 
        ++iter) 
    {
       const string &description = m_variableDescriptionMap[ iter->first ];
       cout << "    " << setw(14) << iter->first << " = ";
       if (description.length())
       {
          cout << setw(14) << "" << " - " << description;
       }
       cout << endl;
       dumpSTLeachEndl (iter->second, 8); 
    } // for iter
 
    cout << "------------------------------------------------------------------" 
         << right << endl;
 }

void CommandLineParser::removeComment ( std::string & line )

static

Definition at line 200 of file CommandLineParser.cc.

Referenced by argVec(), and split().

 {
    string::size_type location = line.find ("#");
    if (string::npos != location)
    {
       // we've got a comment.  Strip it out
       line = line.substr (0, location - 1);
    } // if found
 }

string CommandLineParser::removeEnding	(	const std::string &	input,
		const std::string &	ending
	)

static

Definition at line 233 of file CommandLineParser.cc.

References input, and position.

Referenced by _finishDefaultOptions(), and argVec().

 {
    string::size_type position = input.rfind(ending);
    if (input.length() - ending.length() == position)
    {
       // we've got it
       return input.substr(0, position);
    }
    // If we're still here, it wasn't there
    return input;
 }

void CommandLineParser::removeLeadingAndTrailingSpaces ( std::string & line )

static

Definition at line 211 of file CommandLineParser.cc.

References kSpaces.

Referenced by argVec(), and findCommand().

 {
    string::size_type pos = line.find_first_not_of (kSpaces);
    if (string::npos == pos)
    {
       // we don't have anything here at all.  Just quit now
       return;
    }
    if (pos)
    {
       // We have spaces at the beginning.
       line = line.substr (pos);
    }
    pos = line.find_last_not_of (kSpaces);
    if (pos + 1 != line.length())
    {
       // we've got spaces at the end
       line = line.substr (0, pos + 1);
    }
 }

void optutl::CommandLineParser::setPrintOptoins ( bool print )

inline

Definition at line 50 of file CommandLineParser.h.

References m_printOptions, and edm::print().

50 { m_printOptions = print; }

edm::print

S & print(S &os, JobReport::InputFile const &f)

Definition: JobReport.cc:65

optutl::CommandLineParser::m_printOptions

bool m_printOptions

Definition: CommandLineParser.h:134

void CommandLineParser::split	(	SVec &	retval,
		std::string	line,
		std::string	match = `" \t"`,
		bool	ignoreComments = `true`
	)

static

Definition at line 158 of file CommandLineParser.cc.

References kSpaces, plotBeamSpotDB::last, match(), and removeComment().

Referenced by _runVariableCommandFromString(), _setVariableFromString(), and argVec().

 {
    if (ignoreComments)
    {
       removeComment (line);
    } // if ignoreComments
    retval.clear();
    // find the first non-space
    string::size_type start1 = line.find_first_not_of (kSpaces);
    // Is the first non-space character a '#'
    char firstCh = line[start1];
    if ('#' == firstCh)
    {
       // this line is a comment
       return;
    }
 
    line += match; // get last word of line
    string::size_type last = string::npos;
    string::size_type current = line.find_first_of(match);
    while (string::npos != current)
    {
       string::size_type pos;
       if (string::npos != last)
       {
          pos = last + 1;
       } else {
          pos = 0;
       }
       string part = line.substr( pos, current - last - 1);
       // don't bother adding 0 length strings
       if (part.length()) 
       {
          retval.push_back(part);
       }
       last = current;
       current = line.find_first_of(match, current + 1);
    } // while we're finding spaces
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	o_stream,
		const CommandLineParser &	rhs
	)

friend

Member Data Documentation

const std::string CommandLineParser::kSpaces = " \t"

static

Definition at line 18 of file CommandLineParser.h.

Referenced by _runVariableCommandFromString(), _setVariablesFromFile(), findCommand(), removeLeadingAndTrailingSpaces(), and split().

std::string optutl::CommandLineParser::m_argv0

private

Definition at line 132 of file CommandLineParser.h.

Referenced by help(), and parseArguments().

SVec optutl::CommandLineParser::m_fullArgVec

private

Definition at line 131 of file CommandLineParser.h.

Referenced by argVec(), and parseArguments().

unsigned int optutl::CommandLineParser::m_optionsType

private

Definition at line 135 of file CommandLineParser.h.

Referenced by _finishDefaultOptions(), and CommandLineParser().

bool optutl::CommandLineParser::m_printOptions

private

Definition at line 134 of file CommandLineParser.h.

Referenced by _finishDefaultOptions(), parseArguments(), and setPrintOptoins().

std::string optutl::CommandLineParser::m_usageString

private

Definition at line 133 of file CommandLineParser.h.

Referenced by help().

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation