QwOptions Class Reference

An options class. More...

#include <QwOptions.h>

Public Member Functions
	QwOptions ()
	Default constructor. More...
	QwOptions (int argc, char *argv[])
	Constructor with command line arguments. More...
	QwOptions (const std::string &configfile)
	Constructor with configuration file. More...
	QwOptions (int argc, char *argv[], const std::string &configfile)
	Constructor with command line arguments and configuration file. More...
virtual	~QwOptions ()
	Default destructor. More...
po::options_description_easy_init	AddDefaultOptions ()
	Add a default option. More...
po::options_description_easy_init	AddOptions (const std::string &blockname="Specialized options")
	Add an option to a named block or create new block. More...
void	Usage ()
	Print usage information. More...
void	Version ()
	Print version string. More...
void	SetCommandLine (int argc, char *argv[], bool default_config_file=true)
	Set the command line arguments. More...
void	SetConfigFile (const std::string &configfile)
	Set a configuration file. More...
void	AddConfigFile (const std::string &configfile)
	Add a configuration file. More...
void	AddConfigFile (std::vector< std::string > configfiles)
	Add some configuration files. More...
void	ListConfigFiles ()
	List the configuration files. More...
void	Parse (bool force=false)
	Parse all sources of options. More...
bool	HasValue (const std::string &key)
	Has this key been defined. More...
template<class T >
T	GetValue (const std::string &key)
	Get a templated value. More...
template<class T >
std::vector< T >	GetValueVector (const std::string &key)
	Get a list of templated values. More...
std::pair< int, int >	GetIntValuePair (const std::string &key)
	Get a pair of integer values. More...
int	GetIntValuePairFirst (const std::string &key)
	Get the first of a pair of integer values. More...
int	GetIntValuePairLast (const std::string &key)
	Get the last of a pair of integer values. More...
int	GetArgc ()
	Get the number of command line arguments. More...
char **	GetArgv ()
	Get the vector of command line arguments. More...
void	Clear ()
	Clear the parsed variables. More...

Static Public Member Functions
static void	DefineOptions (QwOptions &options)
	Define the options. More...

Private Member Functions
po::options_description *	CombineOptions ()
	Combine the various option description in one. More...
void	ParseCommandLine ()
	Parse the command line arguments. More...
void	ParseConfigFile ()
	Parse the configuration file. More...
void	ParseEnvironment ()
	Parse the environment variables. More...

Private Attributes
std::vector< std::string >	fConfigFiles
	Configuration file. More...
std::vector < po::options_description * >	fOptionBlock
std::vector< std::string >	fOptionBlockName
po::variables_map	fVariablesMap
bool	fParsed

Static Private Attributes
static int	fArgc = 0
	Command line arguments. More...
static char **	fArgv = 0

Detailed Description

An options class.

On instantiation of the global gQwOptions object the argc and argv are passed. The filename is set to a default value, but on instantiation a check is done for the option –config filename. After this no parsing is done without the user requesting a value.

To use this class in your own programs, just include the header file. This will make the global object gQwOptions available. Set the command line and config file with the methods SetCommandLine() and SetConfigFile() in the main routine. In other classes you can add subsystem-specific config files with the AddConfigFile() method.

* gQwOptions.SetCommandLine(argc, argv); // store command line arguments
* gQwOptions.SetConfigFile("qwtracking.conf"); // set the default config file
* gQwOptions.AddConfigFile("qweak-tracking.conf"); // add another config file
* 

Define your own options by calling the AddOptions() method. Look in the documentation of boost::program_options for the allowed syntax if you need more than just '–key value' pairs. Positional arguments are supported (untested), default values can and should preferably be given, and multiple values can be put into a vector corresponding to a single key (untested).

* gQwOptions.AddOptions()("int,i", po::value<int>(), "integer-valued option");
* gQwOptions.AddOptions()("bool,b", po::value<bool>(), "boolean-valued option");
* gQwOptions.AddOptions()("float,f", po::value<float>(), "float-valued option");
* gQwOptions.AddOptions()("string,s", po::value<string>(), "string-valued option");
* gQwOptions.AddOptions()("range,r", po::value<string>(), "range-valued option");
* gQwOptions.AddOptions()("def-int", po::value<int>()->default_value(1), "int-valued option, default of 1");
* 

For boolean-valued options you might want to use zero_tokens() to allow the option to be specified as –bool instead of –bool yes.

* gQwOptions.AddOptions()("bool,b", po::value<bool>()->zero_tokens(), "boolean-valued option");
* 

Keep in mind, though, that this then ignores the value after the option completely, and it will not allow you to unset settings in the default configuration file. A better approach is to use the implicit_value(b) semantic that will still accept the value after the option. However, this was only introduced in boost 1.35.0. To avoid the need to test for this, use the syntac default_bool_value(b), with b the default value. If the flag is specified, the option will be set to true regardless of the specified default value.

It is easiest if you define your options in a static function DefineOptions() and then call that function in the QwOptionsTracking.h or QwOptionsParity.h header files. This ensures that only a single call to gQwOptions.DefineOptions() will load all the options and provide the information on a –help call.

To use the options, check first for the existence with HasValue(key), then get their value using GetValue<type>(key). Flags defined without type are treated as 'existence-only' keys, so use HasValue(key) on them instead of GetValue<bool>(key). If you define an option as bool, you should still use the regular GetValue<bool>(key) to retrieve the value.

* // Test for presence of the option before using its value
* if (gQwOptions.HasValue("string")) string my_string = gQwOptions.GetValue<string>("string");
* // Or use options with default values (preferable)
* int my_int = gQwOptions.GetValue<int>("def-int");
* 

To get the results of an integer range argument (strictly speaking a string argument), you can use GetIntValuePair() which returns a pair<int,int>, or the more specific GetIntValuePairFirst() and GetIntValuePairLast().

* std::pair<int,int> my_run_pair = gQwOptions.GetIntValuePair("run");
* gQwOptions.GetIntValuePair("run").first == gQwOptions.GetIntValuePairFirst("run");
* gQwOptions.GetIntValuePair("run").second == gQwOptions.GetIntValuePairLast("run");
* 

The default allowed options are:

• –usage: print a help message
• –help, -h: print a help message
• –config, -c: configuration file to read

Definition at line 133 of file QwOptions.h.

Constructor & Destructor Documentation

QwOptions::QwOptions

(

)

Default constructor.

The default constructor sets up the options description object with some options that should always be there. The other options can be setup wherever this object is accessible.

Definition at line 51 of file QwOptions.cc.

References AddDefaultOptions(), and fConfigFiles.

  : fParsed(false)
{
  // No default config files
  fConfigFiles.clear();

  // Declare the default options
  AddDefaultOptions()("usage", "print this help message");
  AddDefaultOptions()("help,h", "print this help message");
  AddDefaultOptions()("version,V", "print the version string");
  AddDefaultOptions()("config,c", po::value<std::string>(), "read ONLY this config file\n(will override default config files)");
  AddDefaultOptions()("add-config,a", po::value<std::vector<std::string> >(), "read ALSO this config file\n(will keep the default config files)");
}

Here is the call graph for this function:

QwOptions::QwOptions ( int  argc, char *  argv[]  )

inline

Constructor with command line arguments.

Definition at line 141 of file QwOptions.h.

References SetCommandLine().

                                      {
      SetCommandLine(argc, argv);
    };

Here is the call graph for this function:

QwOptions::QwOptions ( const std::string &  configfile )

inline

Constructor with configuration file.

Definition at line 145 of file QwOptions.h.

References SetConfigFile().

                                           {
      SetConfigFile(configfile);
    };

Here is the call graph for this function:

QwOptions::QwOptions ( int  argc, char *  argv[], const std::string &  configfile  )

inline

Constructor with command line arguments and configuration file.

Definition at line 149 of file QwOptions.h.

References SetCommandLine(), and SetConfigFile().

                                                                   {
      SetCommandLine(argc, argv);
      SetConfigFile(configfile);
    };

Here is the call graph for this function:

QwOptions::~QwOptions ( )

virtual

Default destructor.

Destructor where we clean up locally allocated memory

Definition at line 91 of file QwOptions.cc.

References fArgv, and fOptionBlock.

{
  // Clean up the copy of the command line arguments
  // Note: only the array of arguments is allocated, the arguments themselves
  // are still owned by main.
  if (fArgv)
    delete[] fArgv;

  // Delete the option blocks
  for (size_t i = 0; i < fOptionBlock.size(); i++)
    delete fOptionBlock.at(i);
  fOptionBlock.clear();
}

Member Function Documentation

void QwOptions::AddConfigFile ( const std::string &  configfile )

inline

Add a configuration file.

Definition at line 199 of file QwOptions.h.

References QwLog::endl(), fConfigFiles, fParsed, and QwMessage.

Referenced by main(), ParseCommandLine(), and SetCommandLine().

                                                    {
      QwMessage << "Adding user-defined configuration file "
                << configfile << QwLog::endl;
      fConfigFiles.push_back(configfile);
      fParsed = false;
    };

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::AddConfigFile ( std::vector< std::string >  configfiles )

inline

Add some configuration files.

Definition at line 207 of file QwOptions.h.

References fConfigFiles, and fParsed.

                                                         {
      for (size_t i = 0; i < configfiles.size(); i++)
        fConfigFiles.push_back(configfiles.at(i));
      fParsed = false;
    };

po::options_description_easy_init QwOptions::AddDefaultOptions ( )

inline

Add a default option.

Definition at line 159 of file QwOptions.h.

References AddOptions().

Referenced by QwEventRing::DefineOptions(), QwEventBuffer::DefineOptions(), and QwOptions().

                                                        {
      return AddOptions("Default options");
    };

Here is the call graph for this function:

Here is the caller graph for this function:

po::options_description_easy_init QwOptions::AddOptions ( const std::string &  blockname = "Specialized options" )

inline

Add an option to a named block or create new block.

Definition at line 164 of file QwOptions.h.

References Clear(), fOptionBlock, and fOptionBlockName.

Referenced by AddDefaultOptions(), QwParityDB::DefineAdditionalOptions(), QwHistogramHelper::DefineOptions(), QwEventRing::DefineOptions(), QwEventBuffer::DefineOptions(), QwDriftChamberHDC::DefineOptions(), QwEPICSEvent::DefineOptions(), QwDriftChamberVDC::DefineOptions(), QwHelicityPattern::DefineOptions(), QwRegression::DefineOptions(), QwRayTracer::DefineOptions(), QwDriftChamber::DefineOptions(), QwHelicity::DefineOptions(), QwDatabase::DefineOptions(), QwMainCerenkovDetector::DefineOptions(), QwTrackingWorker::DefineOptions(), QwTreeEventBuffer::DefineOptions(), QwMagneticField::DefineOptions(), QwTriggerScintillator::DefineOptions(), QwMainDetector::DefineOptions(), QwLog::DefineOptions(), QwLumi::DefineOptions(), QwBlinder::DefineOptions(), QwSubsystemArray::DefineOptions(), QwRootFile::DefineOptions(), main(), and setOptions().

                                                                   {
      // Clear the parsed options
      Clear();
      // Note: Would like to solve this with find_if(b,e,bind()) but no access to block name
      // Search for the block name if it exists
      for (size_t i = 0; i < fOptionBlockName.size(); i++)
        if (blockname == fOptionBlockName.at(i))
          return fOptionBlock.at(i)->add_options();
      // Create new block if not existing yet
      fOptionBlock.push_back(new po::options_description(blockname));
      fOptionBlockName.push_back(blockname);
      return fOptionBlock.back()->add_options();
    };

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::Clear ( )

inline

Clear the parsed variables.

Definition at line 281 of file QwOptions.h.

References fParsed, and fVariablesMap.

Referenced by AddOptions().

                 {
      fVariablesMap.clear();
      fParsed = false;
    };

Here is the caller graph for this function:

po::options_description * QwOptions::CombineOptions ( )

private

Combine the various option description in one.

Combine the options of the various option descriptions in one object for parsing at once. This avoids having to try/catch every single option description

Definition at line 149 of file QwOptions.cc.

References fOptionBlock, and fOptionBlockName.

Referenced by ParseCommandLine(), ParseConfigFile(), and ParseEnvironment().

{
  // The options can be grouped by defining a vector fOptions of
  // options_description objects. Each entry can have a name and
  // will show up as a separate section in the usage information.
  po::options_description* options = new po::options_description("options");
  for (size_t i = 0; i < fOptionBlockName.size(); i++) {
    // Right now every parser gets access to all options
    options->add(*fOptionBlock.at(i));
  }
  return options;
}

Here is the caller graph for this function:

void QwOptions::DefineOptions ( QwOptions &  options )

static

Define the options.

Define standard options on the specified options object

Parameters

options

Options object

Definition at line 69 of file QwOptions.cc.

References QwHistogramHelper::DefineOptions(), QwEventBuffer::DefineOptions(), QwEPICSEvent::DefineOptions(), QwDatabase::DefineOptions(), QwLog::DefineOptions(), QwSubsystemArray::DefineOptions(), and QwRootFile::DefineOptions().

Referenced by DefineOptionsParity(), and DefineOptionsTracking().

{
  // Define logging options (Note: only QwLog takes a pointer argument!!!)
  QwLog::DefineOptions(&options);

  // Define execution options
  QwEventBuffer::DefineOptions(options);
  // Define database options
  QwDatabase::DefineOptions(options);
  // Define ROOT file options
  QwRootFile::DefineOptions(options);
  // Define EPICS event options
  QwEPICSEvent::DefineOptions(options);
  // Define subsystem array options
  QwSubsystemArray::DefineOptions(options);
  // Define histogram helper options
  QwHistogramHelper::DefineOptions(options);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int QwOptions::GetArgc ( )

inline

Get the number of command line arguments.

Definition at line 276 of file QwOptions.h.

References fArgc.

Referenced by QwRootFile::QwRootFile(), and QwParityDB::SetAnalysisID().

{ return (int) fArgc; };

Here is the caller graph for this function:

char** QwOptions::GetArgv ( )

inline

Get the vector of command line arguments.

Definition at line 278 of file QwOptions.h.

References fArgv.

Referenced by QwRootFile::QwRootFile(), and QwParityDB::SetAnalysisID().

{ return (char**) fArgv; };

Here is the caller graph for this function:

std::pair< int, int > QwOptions::GetIntValuePair

(

const std::string &

key

)

Get a pair of integer values.

Get a pair of integers specified as a colon-separated range This function uses the utility function QwParameterFile::ParseIntRange.

Parameters

key	Option key

Returns

Pair of integers

Definition at line 332 of file QwOptions.cc.

References fParsed, fVariablesMap, Parse(), and QwParameterFile::ParseIntRange().

Referenced by GetIntValuePairFirst(), GetIntValuePairLast(), QwTreeEventBuffer::ProcessOptions(), and QwEventBuffer::ProcessOptions().

{
  std::pair<int, int> mypair;
  mypair.first = 0;
  mypair.second = 0;

  if (fParsed == false) Parse();
  if (fVariablesMap.count(key)) {
    std::string range = fVariablesMap[key].as<std::string>();
    mypair = QwParameterFile::ParseIntRange(":",range);
  }

  return mypair;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int QwOptions::GetIntValuePairFirst ( const std::string &  key )

inline

Get the first of a pair of integer values.

Definition at line 266 of file QwOptions.h.

References GetIntValuePair().

Referenced by main().

                                                   {
      return GetIntValuePair(key).first;
    };

Here is the call graph for this function:

Here is the caller graph for this function:

int QwOptions::GetIntValuePairLast ( const std::string &  key )

inline

Get the last of a pair of integer values.

Definition at line 271 of file QwOptions.h.

References GetIntValuePair().

Referenced by main().

                                                  {
      return GetIntValuePair(key).second;
    };

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

T QwOptions::GetValue ( const std::string &  key )

inline

Get a templated value.

Definition at line 240 of file QwOptions.h.

References QwLog::endl(), fParsed, fVariablesMap, Parse(), QwError, QwVerbose, and Qw::T.

Referenced by QwTrackingWorker::InitTree(), QwDriftChamberHDC::LoadChannelMap(), QwDriftChamberVDC::LoadChannelMap(), VQwSubsystemTracking::LoadGeometryDefinition(), main(), QwParityDB::ProcessAdditionalOptions(), QwHistogramHelper::ProcessOptions(), QwEventRing::ProcessOptions(), QwDriftChamberHDC::ProcessOptions(), QwEPICSEvent::ProcessOptions(), QwDriftChamberVDC::ProcessOptions(), QwHelicityPattern::ProcessOptions(), QwRegression::ProcessOptions(), QwRayTracer::ProcessOptions(), QwHelicity::ProcessOptions(), QwDatabase::ProcessOptions(), QwEventBuffer::ProcessOptions(), QwTrackingWorker::ProcessOptions(), QwTreeEventBuffer::ProcessOptions(), QwMainCerenkovDetector::ProcessOptions(), QwMagneticField::ProcessOptions(), QwTriggerScintillator::ProcessOptions(), QwMainDetector::ProcessOptions(), QwLog::ProcessOptions(), QwLumi::ProcessOptions(), QwBlinder::ProcessOptions(), QwRootFile::ProcessOptions(), QwSubsystemArray::ProcessOptionsToplevel(), QwTrackingTreeCombine::QwTrackingTreeCombine(), QwTrackingTreeSearch::QwTrackingTreeSearch(), QwTrackingWorker::QwTrackingWorker(), QwTrackingTreeCombine::TlCheckForX(), and QwTrackingTreeCombine::TlTreeCombine().

                                     {
      if (fParsed == false) Parse();
      if (fVariablesMap.count(key)) {
        QwVerbose << "Option " << key << ": "
                  << fVariablesMap[key].as<T>() << QwLog::endl;
        return fVariablesMap[key].as<T>();
      } else {
        QwError << "Variable " << key << " unknown" << QwLog::endl;
        return 0;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

std::vector< T > QwOptions::GetValueVector ( const std::string &  key )

inline

Get a list of templated values.

Definition at line 253 of file QwOptions.h.

References fParsed, fVariablesMap, and Parse().

Referenced by QwLog::ProcessOptions(), and QwSubsystemArray::ProcessOptionsToplevel().

                                                         {
      std::vector<T> list;
      if (fParsed == false) Parse();
      if (fVariablesMap.count(key)) {
        list = fVariablesMap[key].as< std::vector<T> >();
      }
      return list;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool QwOptions::HasValue ( const std::string &  key )

inline

Has this key been defined.

Definition at line 233 of file QwOptions.h.

References fParsed, fVariablesMap, and Parse().

Referenced by VQwSubsystemTracking::LoadGeometryDefinition(), main(), QwHistogramHelper::ProcessOptions(), QwEventRing::ProcessOptions(), QwHelicity::ProcessOptions(), QwDatabase::ProcessOptions(), QwEventBuffer::ProcessOptions(), QwLog::ProcessOptions(), and QwBlinder::ProcessOptions().

                                        {
      if (fParsed == false) Parse();
      return (fVariablesMap.count(key) > 0);
    };

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::ListConfigFiles ( )

inline

List the configuration files.

Definition at line 214 of file QwOptions.h.

References QwLog::endl(), fConfigFiles, and QwMessage.

Referenced by main().

                           {
      QwMessage << "Config files:" << QwLog::endl;
      for (size_t i = 0; i < fConfigFiles.size(); i++)
        QwMessage << fConfigFiles.at(i) << QwLog::endl;
    };

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::Parse ( bool  force = false )

inline

Parse all sources of options.

Definition at line 222 of file QwOptions.h.

References fParsed, ParseCommandLine(), ParseConfigFile(), and ParseEnvironment().

Referenced by GetIntValuePair(), GetValue(), GetValueVector(), HasValue(), and main().

                                   {
      if (! fParsed || force) {
        ParseCommandLine();
        ParseEnvironment();
        ParseConfigFile();
        fParsed = true;
      }
    };

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::ParseCommandLine ( )

private

Parse the command line arguments.

Parse the command line arguments for options and warn when encountering an unknown option, then notify the variables map. Print usage instructions when no options are given, or when explicitly asked for.

Definition at line 167 of file QwOptions.cc.

References AddConfigFile(), CombineOptions(), Qw::e, QwLog::endl(), fArgc, fArgv, fVariablesMap, QwWarning, SetConfigFile(), Usage(), and Version().

Referenced by Parse().

{
#if BOOST_VERSION >= 103300
  //  Boost versions starting with 1.33.00 allow unrecognized options to be
  //  passed through the parser.
  try {
    po::options_description* command_line_options = CombineOptions();
    po::store(po::command_line_parser(fArgc, fArgv).options(*command_line_options).allow_unregistered().run(), fVariablesMap);
    delete command_line_options;
  } catch (std::exception const& e) {
    QwWarning << e.what() << " while parsing command line arguments" << QwLog::endl;
    exit(10);
  }
#endif

#if BOOST_VERSION < 103300
  //  Boost versions before 1.33.00 do not allow unrecognized options to be
  //  passed through the parser.
  try {
    //  Boost versions before 1.33.00 do not recognize "allow_unregistered".
    po::options_description* command_line_options = CombineOptions();
    po::store(po::command_line_parser(fArgc, fArgv).options(*command_line_options).run(), fVariablesMap);
    delete command_line_options;
  } catch (std::exception const& e) {
    QwWarning << e.what() << " while parsing command line arguments" << QwLog::endl;
    QwWarning << "All command line arguments may have been ignored!" << QwLog::endl;
    exit(10);
  }
#endif

  // Notify of new options
  po::notify(fVariablesMap);

  // If option help/usage, print help text
  if (fVariablesMap.count("help") || fVariablesMap.count("usage")) {
    Usage();
    exit(0);
  }

  // If option version, print version string
  if (fVariablesMap.count("version")) {
    Version();
    exit(0);
  }

  // If a configuration file is specified, load it.
  if (fVariablesMap.count("config") > 0) {
    QwWarning << "Overriding the default configuration files with "
        << "user-defined configuration file "
              << fVariablesMap["config"].as<std::string>() << QwLog::endl;
    SetConfigFile(fVariablesMap["config"].as<std::string>());
  }
  // If a configuration file is specified, load it.
  if (fVariablesMap.count("add-config") > 0) {
    QwWarning << "Adding user-defined configuration file " << QwLog::endl;
    AddConfigFile(fVariablesMap["add-config"].as<std::vector<std::string> >());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::ParseConfigFile ( )

private

Parse the configuration file.

Parse the configuration file for options and warn when encountering an unknown option, then notify the variables map.

Definition at line 247 of file QwOptions.cc.

References CombineOptions(), Qw::e, QwLog::endl(), fConfigFiles, fVariablesMap, QwWarning, and QwParameterFile::rdbuf().

Referenced by Parse().

{
  for (size_t i = 0; i < fConfigFiles.size(); i++) {
    QwParameterFile configfile(fConfigFiles.at(i).c_str());
    std::stringstream configstream;
    configstream << configfile.rdbuf();

    try {
#if BOOST_VERSION >= 103500
      // Boost version after 1.35 have bool allow_unregistered = false in
      // their signature.  This allows for unknown options in the config file.
      po::options_description* config_file_options = CombineOptions();
      po::store(po::parse_config_file(configstream, *config_file_options, true),
    fVariablesMap);
      delete config_file_options;
#else
      // Boost versions before 1.35 cannot handle files with unregistered
      // options.
      po::options_description* config_file_options = CombineOptions();
      po::store(po::parse_config_file(configstream, *config_file_options),
    fVariablesMap);
      delete config_file_options;
#endif
    } catch (std::exception const& e) {
      QwWarning << e.what() << " while parsing configuration file "
                << fConfigFiles.at(i) << QwLog::endl;
#if BOOST_VERSION < 103500
      QwWarning << "The entire configuration file was ignored!" << QwLog::endl;
#endif
      exit(10);
    }
    // Notify of new options
    po::notify(fVariablesMap);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::ParseEnvironment ( )

private

Parse the environment variables.

Parse the environment variables for options and notify the variables map.

Definition at line 229 of file QwOptions.cc.

References CombineOptions(), Qw::e, QwLog::endl(), fVariablesMap, and QwWarning.

Referenced by Parse().

{
  try {
    po::options_description* environment_options = CombineOptions();
    po::store(po::parse_environment(*environment_options, "Qw"), fVariablesMap);
    delete environment_options;
  } catch (std::exception const& e) {
    QwWarning << e.what() << " while parsing environment variables" << QwLog::endl;
    exit(10);
  }
  // Notify of new options
  po::notify(fVariablesMap);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::SetCommandLine	(	int	argc,
		char *	argv[],
		bool	default_config_file = true
	)

Set the command line arguments.

Make a local copy of the command line arguments so they are available for later parsing.

Parameters

argc	Number of arguments
argv[]	Array of arguments
default_config_file	Flag to enable default config file named by executable

Definition at line 112 of file QwOptions.cc.

References AddConfigFile(), QwLog::endl(), fArgc, fArgv, fParsed, and QwDebug.

Referenced by main(), and QwOptions().

{
  // Copy command line options
  fArgc = argc;
  if (fArgv) delete[] fArgv;
  fArgv = new char*[fArgc];
  QwDebug << "Arguments:";
  for (int i = 0; i < argc; i++) {
    fArgv[i] = argv[i];
    QwDebug << " " << fArgv[i];
  }
  QwDebug << QwLog::endl;

  fParsed = false;

  // Add default config file based on file name
  if (fArgc > 0 && default_config_file) {
    std::string path = fArgv[0];
    QwDebug << "Invocation name: " << path << QwLog::endl;
    // Find file name from full path
    size_t pos = path.find_last_of('/');
    if (pos != std::string::npos)
      // Called with path
      AddConfigFile(path.substr(pos+1) + ".conf");
    else
      // Called without path
      AddConfigFile(path + ".conf");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::SetConfigFile ( const std::string &  configfile )

inline

Set a configuration file.

Definition at line 192 of file QwOptions.h.

References fConfigFiles, and fParsed.

Referenced by main(), ParseCommandLine(), and QwOptions().

                                                    {
      fConfigFiles.clear();
      fConfigFiles.push_back(configfile);
      fParsed = false;
    };

Here is the caller graph for this function:

void QwOptions::Usage

(

)

Print usage information.

Print usage information

Definition at line 288 of file QwOptions.cc.

References QwLog::endl(), fOptionBlock, and QwMessage.

Referenced by main(), and ParseCommandLine().

{
  QwMessage << QwLog::endl;
  QwMessage << "Welcome to the Qweak analyzer code." << QwLog::endl;
  QwMessage << QwLog::endl;
  for (size_t i = 0; i < fOptionBlock.size(); i++)
    QwMessage << *(fOptionBlock.at(i)) << QwLog::endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwOptions::Version

(

)

Print version string.

Print version string

Definition at line 301 of file QwOptions.cc.

References QwLog::endl(), fArgv, QWANA_SVN_LASTCHANGEDREVISION, QWANA_SVN_REVISION, QWANA_SVN_URL, and QwMessage.

Referenced by ParseCommandLine().

{
  TString root_version = gROOT->GetVersion();
  root_version += ", Date : ";
  root_version += gROOT->GetVersionDate();
#if ROOT_VERSION_CODE < ROOT_VERSION(6,0,0)
  root_version += ", SVN : ";
  root_version += gROOT->GetSvnRevision();
  root_version += " ";
  root_version += gROOT->GetSvnBranch();
#else // ROOT_VERSION_CODE >= ROOT_VERSION(6,0,0)
  root_version += ", GIT : ";
  root_version += gROOT->GetGitCommit();
  root_version += " ";
  root_version += gROOT->GetGitBranch();
#endif

  QwMessage << "\n Qweak Analysis Framework : " << fArgv[0] << QwLog::endl;
  QwMessage << " * Revision: " << QWANA_SVN_REVISION << QwLog::endl;
  QwMessage << " * URL: " << QWANA_SVN_URL << QwLog::endl;
  QwMessage << " * Last Changed Rev: " << QWANA_SVN_LASTCHANGEDREVISION << QwLog::endl;
  QwMessage << " * ROOT " << root_version << QwLog::endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

int QwOptions::fArgc = 0

staticprivate

Command line arguments.

Because argc and argv are only available in the main routine, we need to store a copy of them for later parsing. The copy is static to have them available in local copies of the options object.

Definition at line 309 of file QwOptions.h.

Referenced by GetArgc(), ParseCommandLine(), and SetCommandLine().

char ** QwOptions::fArgv = 0

staticprivate

Definition at line 310 of file QwOptions.h.

Referenced by GetArgv(), ParseCommandLine(), SetCommandLine(), Version(), and ~QwOptions().

std::vector<std::string> QwOptions::fConfigFiles

private

Configuration file.

Definition at line 301 of file QwOptions.h.

Referenced by AddConfigFile(), ListConfigFiles(), ParseConfigFile(), QwOptions(), and SetConfigFile().

std::vector<po::options_description*> QwOptions::fOptionBlock

private

Definition at line 316 of file QwOptions.h.

Referenced by AddOptions(), CombineOptions(), Usage(), and ~QwOptions().

std::vector<std::string> QwOptions::fOptionBlockName

private

Definition at line 317 of file QwOptions.h.

Referenced by AddOptions(), and CombineOptions().

bool QwOptions::fParsed

private

Definition at line 322 of file QwOptions.h.

Referenced by AddConfigFile(), Clear(), GetIntValuePair(), GetValue(), GetValueVector(), HasValue(), Parse(), SetCommandLine(), and SetConfigFile().

po::variables_map QwOptions::fVariablesMap

private

Definition at line 320 of file QwOptions.h.

Referenced by Clear(), GetIntValuePair(), GetValue(), GetValueVector(), HasValue(), ParseCommandLine(), ParseConfigFile(), and ParseEnvironment().

---

The documentation for this class was generated from the following files:

• QwOptions.h
• QwOptions.cc