Command-line and configuration file options processor. More...

#include <QwOptions.h>

Collaboration diagram for QwOptions:

Public Member Functions
virtual	~QwOptions ()
	Default destructor.

po::options_description_easy_init	AddDefaultOptions ()
	Add a default option.

po::options_description_easy_init	AddOptions (const std::string &blockname="Specialized options")
	Add an option to a named block or create new block.

void	Usage ()
	Print usage information.

void	Version ()
	Print version string.

void	SetCommandLine (int argc, char *argv[], bool default_config_file=true)
	Set the command line arguments.

void	SetConfigFile (const std::string &configfile)
	Set a configuration file.

void	AddConfigFile (const std::string &configfile)
	Add a configuration file.

void	AddConfigFile (std::vector< std::string > configfiles)
	Add some configuration files.

void	ListConfigFiles ()
	List the configuration files.

void	Parse (bool force=false)
	Parse all sources of options.

bool	HasValue (const std::string &key)
	Has this key been defined.

template<class T>
T	GetValue (const std::string &key)
	Get a templated value.

template<class T>
std::vector< T >	GetValueVector (const std::string &key)
	Get a list of templated values.

std::pair< int, int >	GetIntValuePair (const std::string &key)
	Get a pair of integer values.

int	GetIntValuePairFirst (const std::string &key)
	Get the first of a pair of integer values.

int	GetIntValuePairLast (const std::string &key)
	Get the last of a pair of integer values.

int	GetArgc ()
	Get the number of command line arguments.

char **	GetArgv ()
	Get the vector of command line arguments.

void	Clear ()
	Clear the parsed variables.

Static Public Member Functions
static QwOptions &	Instance ()
	Get instance.

static void	DefineOptions (QwOptions &options)
	Define the options.

Private Member Functions
	QwOptions ()
	Private default constructor.

	QwOptions (QwOptions const &)
	Private copy constructor, not implemented.

QwOptions &	operator= (QwOptions const &)
	Private assignment operator, not implemented.

po::options_description *	CombineOptions ()
	Combine the various option description in one.

void	ParseCommandLine ()
	Parse the command line arguments.

void	ParseConfigFile ()
	Parse the configuration file.

void	ParseEnvironment ()
	Parse the environment variables.

Private Attributes
std::vector< std::string >	fConfigFiles
	Configuration file.

int	fArgc
	Command line arguments.

char **	fArgv

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

std::vector< std::string >	fOptionBlockName

po::variables_map	fVariablesMap

bool	fParsed

Static Private Attributes
static QwOptions *	fInstance = 0

Detailed Description

Command-line and configuration file options processor.

QwOptions provides a unified interface for handling command-line arguments, configuration files, and environment variables using Boost.Program_options. It supports typed options with defaults, positional arguments, and hierarchical configuration loading. The global gQwOptions singleton is available throughout the framework.

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 syntax 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 141 of file QwOptions.h.

Constructor & Destructor Documentation

◆ QwOptions() [1/2]

QwOptions::QwOptions ( )

private

Private 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 49 of file QwOptions.cc.

  : fArgc(0), fArgv(NULL), 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> >()->composing(), "read ALSO this config file\n(will keep the default config files)");
}

References AddDefaultOptions(), fArgc, fArgv, fConfigFiles, and fParsed.

Referenced by DefineOptions(), Instance(), operator=(), and QwOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QwOptions() [2/2]

QwOptions::QwOptions ( QwOptions const & )

private

Private copy constructor, not implemented.

References QwOptions().

Here is the call graph for this function:

◆ ~QwOptions()

QwOptions::~QwOptions ( )

virtual

Default destructor.

Destructor where we clean up locally allocated memory

Definition at line 91 of file QwOptions.cc.

{
  // 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();
}

References fArgv, and fOptionBlock.

Member Function Documentation

◆ AddConfigFile() [1/2]

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

Add a configuration file.

Add the named configuration file to the list.

Parameters

configfile Name of the config file, without path

Definition at line 161 of file QwOptions.cc.

{
  Bool_t notfound = kTRUE;
  for (size_t i = 0; i < fConfigFiles.size(); i++){
    if (fConfigFiles.at(i) == configfile){
      notfound=kFALSE;
      break;
    }
  }
  if (notfound){
    QwMessage << "Adding user-defined configuration file "
          << configfile.c_str() << QwLog::endl;
    fConfigFiles.push_back(configfile);
    fParsed = false;
  }
};

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

Referenced by AddConfigFile(), ParseCommandLine(), ParseConfigFile(), and SetCommandLine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddConfigFile() [2/2]

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

inline

Add some configuration files.

Definition at line 204 of file QwOptions.h.

                                                         {
      for (size_t i = 0; i < configfiles.size(); i++)
    AddConfigFile(configfiles.at(i));
    };

References AddConfigFile().

Here is the call graph for this function:

◆ AddDefaultOptions()

po::options_description_easy_init QwOptions::AddDefaultOptions ( )

inline

Add a default option.

Definition at line 165 of file QwOptions.h.

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

References AddOptions().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddOptions()

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 170 of file QwOptions.h.

                                                                   {
      // 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();
    };

References Clear(), fOptionBlock, and fOptionBlockName.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clear()

void QwOptions::Clear ( )

inline

Clear the parsed variables.

Definition at line 277 of file QwOptions.h.

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

References fParsed, and fVariablesMap.

Referenced by AddOptions().

Here is the caller graph for this function:

◆ CombineOptions()

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 183 of file QwOptions.cc.

{
  // 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;
}

References fOptionBlock, and fOptionBlockName.

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

Here is the caller graph for this function:

◆ DefineOptions()

void QwOptions::DefineOptions ( QwOptions & options )

static

Define the options.

Define standard options on the specified options object

Parameters

options Options object

Definition at line 67 of file QwOptions.cc.

{
  // Define logging options (Note: only QwLog takes a pointer argument!!!)
  QwLog::DefineOptions(&options);
 
  // Define execution options
  QwEventBuffer::DefineOptions(options);
#ifdef __USE_DATABASE__
  // Define database options
  QwDatabase::DefineOptions(options);
#endif //__USE_DATABASE__
  // 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);
}

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

Referenced by DefineOptionsParity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetArgc()

int QwOptions::GetArgc ( )

inline

Get the number of command line arguments.

Definition at line 272 of file QwOptions.h.

272{ return (int) fArgc; };

References fArgc.

◆ GetArgv()

char ** QwOptions::GetArgv ( )

inline

Get the vector of command line arguments.

Definition at line 274 of file QwOptions.h.

274{ return (char**) fArgv; };

References fArgv.

◆ GetIntValuePair()

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 357 of file QwOptions.cc.

{
  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;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIntValuePairFirst()

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

inline

Get the first of a pair of integer values.

Definition at line 262 of file QwOptions.h.

                                                   {
      return GetIntValuePair(key).first;
    };

References GetIntValuePair().

Here is the call graph for this function:

◆ GetIntValuePairLast()

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

inline

Get the last of a pair of integer values.

Definition at line 267 of file QwOptions.h.

                                                  {
      return GetIntValuePair(key).second;
    };

References GetIntValuePair().

Here is the call graph for this function:

◆ GetValue()

template<class T>

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

inline

Get a templated value.

Definition at line 236 of file QwOptions.h.

                                     {
      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 {};
      }
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetValueVector()

template<class T>

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

inline

Get a list of templated values.

Definition at line 249 of file QwOptions.h.

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

References fParsed, fVariablesMap, and Parse().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasValue()

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

inline

Has this key been defined.

Definition at line 229 of file QwOptions.h.

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

References fParsed, fVariablesMap, and Parse().

Referenced by QwDatabase::ProcessOptions(), QwDataHandlerArray::ProcessOptions(), QwEventBuffer::ProcessOptions(), QwHelicity::ProcessOptions(), QwHistogramHelper::ProcessOptions(), and QwLog::ProcessOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Instance()

static QwOptions & QwOptions::Instance ( )

inlinestatic

Get instance.

Definition at line 155 of file QwOptions.h.

                                 {
      if (! fInstance) fInstance = new QwOptions();
      return *fInstance;
    }

References fInstance, and QwOptions().

Here is the call graph for this function:

◆ ListConfigFiles()

void QwOptions::ListConfigFiles ( )

inline

List the configuration files.

Definition at line 210 of file QwOptions.h.

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

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

Here is the call graph for this function:

◆ operator=()

QwOptions & QwOptions::operator= ( QwOptions const & )

private

Private assignment operator, not implemented.

References QwOptions().

Here is the call graph for this function:

◆ Parse()

void QwOptions::Parse ( bool force = false )

inline

Parse all sources of options.

Definition at line 218 of file QwOptions.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseCommandLine()

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 201 of file QwOptions.cc.

{
  //  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);
  }
 
  // 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) {
    SetConfigFile(fVariablesMap["config"].as<std::string>());
  }
  // If a configuration file is specified, load it.
  if (fVariablesMap.count("add-config") > 0) {
    AddConfigFile(fVariablesMap["add-config"].as<std::vector<std::string> >());
  }
}

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

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseConfigFile()

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 278 of file QwOptions.cc.

{
  for (size_t i = 0; i < fConfigFiles.size(); i++) {
    QwParameterFile configfile(fConfigFiles.at(i).c_str());
    std::stringstream configstream;
    configstream << configfile.rdbuf();
 
    try {
      // 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;
    } catch (std::exception const& e) {
      QwWarning << e.what() << " while parsing configuration file "
                << fConfigFiles.at(i) << QwLog::endl;
      exit(10);
    }
    // Notify of new options
    po::notify(fVariablesMap);
    
    // If a configuration file is specified, load it.
    if (fVariablesMap.count("add-config") > 0) {
      AddConfigFile(fVariablesMap["add-config"].as<std::vector<std::string> >());
    }
  }
}

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

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseEnvironment()

void QwOptions::ParseEnvironment ( )

private

Parse the environment variables.

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

Definition at line 242 of file QwOptions.cc.

{
  class name_mapper {
    public:
      name_mapper(const std::string& prefix, const std::string& ignore)
      : prefix(prefix),ignore(ignore) { }
      std::string operator()(const std::string& s) {
        string lc;
        if (s.find(prefix) == 0) {
          for(string::size_type n = prefix.size(); n < s.size(); ++n) {
            lc += static_cast<char>(tolower(s[n]));
          }
        }
        if (ignore.find(lc) == std::string::npos) return lc;
        else return "";
      }
  private:
    std::string prefix, ignore;
  } qw_name_mapper("QW_", "bin fieldmap lib lookup prminput searchtree tmp");
 
  try {
    po::options_description* environment_options = CombineOptions();
    po::store(po::parse_environment(*environment_options, qw_name_mapper), 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);
}

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

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCommandLine()

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.

{
  // 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");
  }
}

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

Here is the call graph for this function:

◆ SetConfigFile()

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

Set a configuration file.

Set the named configuration file as the first (and initially only) one in the list.

Parameters

configfile Name of the config file, without path

Definition at line 147 of file QwOptions.cc.

{
  QwWarning << "Overriding the default configuration files with "
        << "user-defined configuration file "
        << configfile.c_str() << QwLog::endl;
  fConfigFiles.clear();
  fConfigFiles.push_back(configfile);
  fParsed = false;
};

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

Referenced by ParseCommandLine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Usage()

void QwOptions::Usage ( )

Print usage information.

Print usage information

Definition at line 312 of file QwOptions.cc.

{
  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;
}

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

Referenced by ParseCommandLine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Version()

void QwOptions::Version ( )

Print version string.

Print version string

Definition at line 325 of file QwOptions.cc.

{
  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 << " * GIT info: " << gGitInfo << 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;
}

References QwLog::endl(), fArgv, gGitInfo, and QwMessage.

Referenced by ParseCommandLine().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ fArgc

int QwOptions::fArgc

private

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 305 of file QwOptions.h.

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

◆ fArgv

char** QwOptions::fArgv

private

Definition at line 306 of file QwOptions.h.

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

◆ fConfigFiles

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

private

Configuration file.

Definition at line 297 of file QwOptions.h.

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

◆ fInstance

QwOptions * QwOptions::fInstance = 0

staticprivate

Definition at line 144 of file QwOptions.h.

Referenced by Instance().

◆ fOptionBlock

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

private

Definition at line 312 of file QwOptions.h.

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

◆ fOptionBlockName

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

private

Definition at line 313 of file QwOptions.h.

Referenced by AddOptions(), and CombineOptions().

◆ fParsed

bool QwOptions::fParsed

private

Definition at line 318 of file QwOptions.h.

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

◆ fVariablesMap

po::variables_map QwOptions::fVariablesMap

private

Definition at line 316 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:

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ QwOptions() [1/2]

◆ QwOptions() [2/2]

◆ ~QwOptions()

Member Function Documentation

◆ AddConfigFile() [1/2]

◆ AddConfigFile() [2/2]

◆ AddDefaultOptions()

◆ AddOptions()

◆ Clear()

◆ CombineOptions()

◆ DefineOptions()

◆ GetArgc()

◆ GetArgv()

◆ GetIntValuePair()

◆ GetIntValuePairFirst()

◆ GetIntValuePairLast()

◆ GetValue()

◆ GetValueVector()

◆ HasValue()

◆ Instance()

◆ ListConfigFiles()

◆ operator=()

◆ Parse()

◆ ParseCommandLine()

◆ ParseConfigFile()

◆ ParseEnvironment()

◆ SetCommandLine()

◆ SetConfigFile()

◆ Usage()

◆ Version()

Field Documentation

◆ fArgc

◆ fArgv

◆ fConfigFiles

◆ fInstance

◆ fOptionBlock

◆ fOptionBlockName

◆ fParsed

◆ fVariablesMap