mirror of
https://github.com/FairRootGroup/FairMQ.git
synced 2025-10-13 16:46:47 +00:00
494 lines
17 KiB
C++
494 lines
17 KiB
C++
/********************************************************************************
|
|
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
|
|
* *
|
|
* This software is distributed under the terms of the *
|
|
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
|
|
* copied verbatim in the file "LICENSE" *
|
|
********************************************************************************/
|
|
|
|
/*
|
|
* File: FairProgOptions.cxx
|
|
* Author: winckler
|
|
*
|
|
* Created on March 11, 2015, 5:38 PM
|
|
*/
|
|
|
|
#include "FairProgOptions.h"
|
|
|
|
|
|
|
|
/// //////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Constructor / destructor
|
|
FairProgOptions::FairProgOptions() :
|
|
fGenericDesc("Generic options description"),
|
|
fConfigDesc("Configuration options description"),
|
|
fHiddenDesc("Hidden options description"),
|
|
fEnvironmentDesc("Environment Variables"),
|
|
fCmdline_options("Command line options"),
|
|
fConfig_file_options("Configuration file options"),
|
|
fVisible_options("Visible options"),
|
|
fVerboseLvl("INFO"), fUseConfigFile(false), fConfigFile()
|
|
{
|
|
// //////////////////////////////////
|
|
// define generic options
|
|
fGenericDesc.add_options()
|
|
("help,h", "produce help")
|
|
("version,v", "print version")
|
|
("verbose", po::value<std::string>(&fVerboseLvl)->default_value("INFO"), "Verbosity level : \n"
|
|
" TRACE \n"
|
|
" DEBUG \n"
|
|
" RESULTS \n"
|
|
" INFO \n"
|
|
" WARN \n"
|
|
" ERROR \n"
|
|
" STATE \n"
|
|
" NOLOG"
|
|
)
|
|
;
|
|
|
|
fSeverity_map["TRACE"] = fairmq::severity_level::TRACE;
|
|
fSeverity_map["DEBUG"] = fairmq::severity_level::DEBUG;
|
|
fSeverity_map["RESULTS"] = fairmq::severity_level::RESULTS;
|
|
fSeverity_map["INFO"] = fairmq::severity_level::INFO;
|
|
fSeverity_map["WARN"] = fairmq::severity_level::WARN;
|
|
fSeverity_map["ERROR"] = fairmq::severity_level::ERROR;
|
|
fSeverity_map["STATE"] = fairmq::severity_level::STATE;
|
|
fSeverity_map["NOLOG"] = fairmq::severity_level::NOLOG;
|
|
|
|
}
|
|
|
|
FairProgOptions::~FairProgOptions()
|
|
{
|
|
}
|
|
|
|
|
|
/// //////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Add option descriptions
|
|
|
|
int FairProgOptions::AddToCmdLineOptions(const po::options_description& optdesc, bool visible)
|
|
{
|
|
fCmdline_options.add(optdesc);
|
|
if(visible)
|
|
fVisible_options.add(optdesc);
|
|
return 0;
|
|
}
|
|
|
|
int FairProgOptions::AddToCfgFileOptions(const po::options_description& optdesc, bool visible)
|
|
{
|
|
//if UseConfigFile() not yet called, then enable it with required file name to be provided by command line
|
|
if(!fUseConfigFile)
|
|
UseConfigFile();
|
|
|
|
fConfig_file_options.add(optdesc);
|
|
if(visible)
|
|
fVisible_options.add(optdesc);
|
|
return 0;
|
|
}
|
|
|
|
int FairProgOptions::AddToEnvironmentOptions(const po::options_description& optdesc)
|
|
{
|
|
fEnvironmentDesc.add(optdesc);
|
|
return 0;
|
|
}
|
|
|
|
|
|
void FairProgOptions::UseConfigFile(const std::string& filename)
|
|
{
|
|
fUseConfigFile = true;
|
|
if (filename.empty())
|
|
{
|
|
fConfigDesc.add_options()
|
|
("config,c", po::value<boost::filesystem::path>(&fConfigFile)->required(), "Path to configuration file (required argument)");
|
|
AddToCmdLineOptions(fConfigDesc);
|
|
}
|
|
else
|
|
{
|
|
fConfigFile = filename;
|
|
}
|
|
}
|
|
|
|
/// //////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Parser
|
|
|
|
int FairProgOptions::ParseCmdLine(const int argc, char** argv, const po::options_description& desc, po::variables_map& varmap, bool AllowUnregistered)
|
|
{
|
|
// //////////////////////////////////
|
|
// get options from cmd line and store in variable map
|
|
// here we use command_line_parser instead of parse_command_line, to allow unregistered and positional options
|
|
if(AllowUnregistered)
|
|
{
|
|
po::command_line_parser parser{argc, argv};
|
|
parser.options(desc).allow_unregistered();
|
|
po::parsed_options parsedOptions = parser.run();
|
|
po::store(parsedOptions,varmap);
|
|
}
|
|
else
|
|
po::store(po::parse_command_line(argc, argv, desc), varmap);
|
|
|
|
// //////////////////////////////////
|
|
// call the virtual NotifySwitchOption method to handle switch options like e.g. "--help" or "--version"
|
|
// return 1 if switch options found in varmap
|
|
if(NotifySwitchOption())
|
|
return 1;
|
|
|
|
po::notify(varmap);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int FairProgOptions::ParseCmdLine(const int argc, char** argv, const po::options_description& desc, bool AllowUnregistered)
|
|
{
|
|
return ParseCmdLine(argc,argv,desc,fvarmap,AllowUnregistered);
|
|
}
|
|
|
|
|
|
|
|
int FairProgOptions::ParseCfgFile(std::ifstream& ifs, const po::options_description& desc, po::variables_map& varmap, bool AllowUnregistered)
|
|
{
|
|
if (!ifs)
|
|
{
|
|
std::cout << "can not open configuration file \n";
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
po:store(parse_config_file(ifs, desc, AllowUnregistered), varmap);
|
|
po::notify(varmap);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int FairProgOptions::ParseCfgFile(const std::string& filename, const po::options_description& desc, po::variables_map& varmap, bool AllowUnregistered)
|
|
{
|
|
std::ifstream ifs(filename.c_str());
|
|
if (!ifs)
|
|
{
|
|
std::cout << "can not open configuration file: " << filename << "\n";
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
po:store(parse_config_file(ifs, desc, AllowUnregistered), varmap);
|
|
po::notify(varmap);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int FairProgOptions::ParseCfgFile(const std::string& filename, const po::options_description& desc, bool AllowUnregistered)
|
|
{
|
|
return ParseCfgFile(filename,desc,fvarmap,AllowUnregistered);
|
|
}
|
|
|
|
int FairProgOptions::ParseCfgFile(std::ifstream& ifs, const po::options_description& desc, bool AllowUnregistered)
|
|
{
|
|
return ParseCfgFile(ifs,desc,fvarmap,AllowUnregistered);
|
|
}
|
|
|
|
|
|
int FairProgOptions::ParseEnvironment(const std::function<std::string(std::string)> & environment_mapper)
|
|
{
|
|
po::store(po::parse_environment(fEnvironmentDesc, environment_mapper), fvarmap);
|
|
po::notify(fvarmap);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Given a key, convert the variable value to string
|
|
std::string FairProgOptions::GetStringValue(const std::string& key)
|
|
{
|
|
std::string val_str;
|
|
try
|
|
{
|
|
if ( fvarmap.count(key) )
|
|
{
|
|
auto& value = fvarmap[key].value();
|
|
|
|
|
|
// string albeit useless here
|
|
if(auto q = boost::any_cast< std::string >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< std::string >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
// vector<string>
|
|
if(auto q = boost::any_cast< std::vector<std::string> >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< std::vector<std::string> >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
// int
|
|
if(auto q = boost::any_cast< int >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< int >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
// vector<int>
|
|
if(auto q = boost::any_cast< std::vector<int> >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< std::vector<int> >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
// float
|
|
if(auto q = boost::any_cast< float >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< float >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
// vector float
|
|
if(auto q = boost::any_cast< std::vector<float> >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< std::vector<float> >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
// double
|
|
if(auto q = boost::any_cast< double >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< double >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
// vector double
|
|
if(auto q = boost::any_cast< std::vector<double> >(&value ))
|
|
{
|
|
val_str = variable_value_to_string< std::vector<double> >(fvarmap[key]);
|
|
return val_str;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
catch(std::exception& e)
|
|
{
|
|
LOG(ERROR) << "Exception thrown for the key '" << key << "'";
|
|
LOG(ERROR) << e.what();
|
|
}
|
|
|
|
return val_str;
|
|
}
|
|
|
|
|
|
/// //////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Print/notify options
|
|
|
|
int FairProgOptions::PrintHelp() const
|
|
{
|
|
std::cout << fVisible_options << "\n";
|
|
return 0;
|
|
}
|
|
|
|
int FairProgOptions::PrintOptions()
|
|
{
|
|
// //////////////////////////////////
|
|
// Method to overload.
|
|
// -> loop over variable map and print its content
|
|
// -> In this example the following types are supported:
|
|
// std::string, int, float, double, boost::filesystem::path
|
|
// std::vector<std::string>, std::vector<int>, std::vector<float>, std::vector<double>
|
|
|
|
|
|
MapVarValInfo_t mapinfo;
|
|
|
|
// get string length for formatting and convert varmap values into string
|
|
int maxlen_1st = 0;
|
|
int maxlen_2nd = 0;
|
|
int maxlen_TypeInfo = 0;
|
|
int maxlen_default =0;
|
|
int maxlen_empty = 0;
|
|
int total_len=0;
|
|
for (const auto& m : fvarmap)
|
|
{
|
|
Max(maxlen_1st, m.first.length());
|
|
|
|
VarValInfo_t valinfo=Get_variable_value_info(m.second);
|
|
mapinfo[m.first]=valinfo;
|
|
std::string val_str;
|
|
std::string typeInfo_str;
|
|
std::string default_str;
|
|
std::string empty_str;
|
|
std::tie(val_str,typeInfo_str,default_str,empty_str)=valinfo;
|
|
|
|
Max(maxlen_2nd, val_str.length());
|
|
Max(maxlen_TypeInfo, typeInfo_str.length());
|
|
Max(maxlen_default, default_str.length());
|
|
Max(maxlen_empty, empty_str.length());
|
|
|
|
}
|
|
|
|
// TODO : limit the value length field in a better way
|
|
if(maxlen_2nd>100)
|
|
maxlen_2nd=100;
|
|
total_len=maxlen_1st+maxlen_2nd+maxlen_TypeInfo+maxlen_default+maxlen_empty;
|
|
|
|
|
|
//maxlen_2nd=200;
|
|
|
|
// formatting and printing
|
|
|
|
LOG(INFO)<<std::setfill ('*') << std::setw (total_len+3)<<"*";// +3 because of string " = "
|
|
std::string PrintOptionsTitle=" Program options found ";
|
|
|
|
int leftSpace_len=0;
|
|
int rightSpace_len=0;
|
|
int leftTitle_shift_len=0;
|
|
int rightTitle_shift_len=0;
|
|
|
|
leftTitle_shift_len=PrintOptionsTitle.length()/2;
|
|
|
|
if ((PrintOptionsTitle.length()) % 2)
|
|
rightTitle_shift_len=leftTitle_shift_len+1;
|
|
else
|
|
rightTitle_shift_len=leftTitle_shift_len;
|
|
|
|
leftSpace_len=(total_len+3)/2-leftTitle_shift_len;
|
|
if ((total_len+3) % 2)
|
|
rightSpace_len=(total_len+3)/2-rightTitle_shift_len+1;
|
|
else
|
|
rightSpace_len=(total_len+3)/2-rightTitle_shift_len;
|
|
|
|
|
|
LOG(INFO) << std::setfill ('*') << std::setw(leftSpace_len) <<"*"
|
|
<< std::setfill(' ')
|
|
<< std::setw(PrintOptionsTitle.length()) << PrintOptionsTitle
|
|
<< std::setfill ('*') << std::setw(rightSpace_len) <<"*";
|
|
|
|
LOG(INFO) <<std::setfill ('*') << std::setw (total_len+3)<<"*";
|
|
|
|
for (const auto& p : mapinfo)
|
|
{
|
|
std::string key_str;
|
|
std::string val_str;
|
|
std::string typeInfo_str;
|
|
std::string default_str;
|
|
std::string empty_str;
|
|
key_str=p.first;
|
|
std::tie(val_str,typeInfo_str,default_str,empty_str)=p.second;
|
|
LOG(INFO) << std::setfill(' ')
|
|
<< std::setw(maxlen_1st)<<std::left
|
|
<< p.first << " = "
|
|
<< std::setw(maxlen_2nd)
|
|
<< val_str
|
|
<< std::setw(maxlen_TypeInfo)
|
|
<< typeInfo_str
|
|
<< std::setw(maxlen_default)
|
|
<< default_str
|
|
<< std::setw(maxlen_empty)
|
|
<< empty_str;
|
|
}
|
|
LOG(INFO)<<std::setfill ('*') << std::setw (total_len+3)<<"*";// +3 for " = "
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int FairProgOptions::NotifySwitchOption()
|
|
{
|
|
// //////////////////////////////////
|
|
// Method to overload.
|
|
if ( fvarmap.count("help") )
|
|
{
|
|
std::cout << "***** FAIR Program Options ***** \n" << fVisible_options;
|
|
return 1;
|
|
}
|
|
|
|
if (fvarmap.count("version"))
|
|
{
|
|
std::cout << "alpha version 0.0\n";
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
FairProgOptions::VarValInfo_t FairProgOptions::Get_variable_value_info(const po::variable_value& var_val)
|
|
{
|
|
// tuple<val_str, type_info_str, default_str, empty>
|
|
auto& value = var_val.value();
|
|
std::string defaulted_val;
|
|
std::string empty_val;
|
|
|
|
if(var_val.empty())
|
|
empty_val=" [empty]";
|
|
else
|
|
if(var_val.defaulted())
|
|
defaulted_val=" [default value]";
|
|
else
|
|
defaulted_val=" [provided value]";
|
|
|
|
empty_val+=" *";
|
|
// string
|
|
if(auto q = boost::any_cast< std::string >(&value))
|
|
{
|
|
std::string val_str = *q;
|
|
return std::make_tuple(val_str,std::string(" [Type=string]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// vector<string>
|
|
if(auto q = boost::any_cast< std::vector<std::string> >(&value))
|
|
{
|
|
std::string val_str = variable_value_to_string< std::vector<std::string> >(var_val);
|
|
return std::make_tuple(val_str,std::string(" [Type=vector<string>]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// int
|
|
if(auto q = boost::any_cast< int >(&value))
|
|
{
|
|
std::string val_str = variable_value_to_string< int >(var_val);
|
|
return std::make_tuple(val_str,std::string(" [Type=int]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// vector<int>
|
|
if(auto q = boost::any_cast< std::vector<int> >(&value))
|
|
{
|
|
std::string val_str = variable_value_to_string< std::vector<int> >(var_val);
|
|
return std::make_tuple(val_str,std::string(" [Type=vector<int>]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// float
|
|
if(auto q = boost::any_cast< float >(&value))
|
|
{
|
|
std::string val_str = variable_value_to_string< float >(var_val);
|
|
return std::make_tuple(val_str,std::string(" [Type=float]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// vector<float>
|
|
if(auto q = boost::any_cast< std::vector<float> >(&value))
|
|
{
|
|
std::string val_str = variable_value_to_string< std::vector<float> >(var_val);
|
|
return std::make_tuple(val_str,std::string(" [Type=vector<float>]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// double
|
|
if(auto q = boost::any_cast< double >(&value))
|
|
{
|
|
std::string val_str = variable_value_to_string< double >(var_val);
|
|
return std::make_tuple(val_str,std::string(" [Type=double]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// vector<double>
|
|
if(auto q = boost::any_cast< std::vector<double> >(&value))
|
|
{
|
|
std::string val_str = variable_value_to_string< std::vector<double> >(var_val);
|
|
return std::make_tuple(val_str,std::string(" [Type=vector<double>]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// boost::filesystem::path
|
|
if(auto q = boost::any_cast<boost::filesystem::path>(&value))
|
|
{
|
|
std::string val_str = (*q).string();
|
|
//std::string val_str = (*q).filename().generic_string();
|
|
return std::make_tuple(val_str,std::string(" [Type=boost::filesystem::path]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
// if we get here, the type is not supported return unknown info
|
|
return std::make_tuple(std::string("Unknown value"), std::string(" [Type=Unknown]"),defaulted_val,empty_val);
|
|
}
|
|
|
|
|