Mirror/FairMQ
1
0
Fork 0
mirror of https://github.com/FairRootGroup/FairMQ.git synced 2025-10-13 16:46:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

FairMQProgOptions fixes and cleanup

Browse Source 
- Remove singular key names from JSON schema.
- Align the property tree created by `FairMQSuboptParser` with the format required by the main parser (plural names).
- Fix `--print-options` to print all options (not only those that have their value set).
- remove XML parser (outdated and unused).
- various code cleanup.
This commit is contained in:
Alexey Rybalchenko 2018-02-01 16:37:35 +01:00 committed by Mohammad Al-Turany
parent 4e2a195289
commit f8d4fe01d0
12 changed files with 321 additions and 646 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fairmq/FairMQDevice.cxx
View File

@ -993,7 +993,7 @@ void FairMQDevice::LogSocketRates()
bytesOut.at(i) = bytesOutNew.at(i);
msgOut.at(i) = msgOutNew.at(i);
LOG(debug) << filteredChannelNames.at(i) << ": "
LOG(info) << filteredChannelNames.at(i) << ": "
<< "in: " << msgPerSecIn.at(i) << " (" << mbPerSecIn.at(i) << " MB) "
<< "out: " << msgPerSecOut.at(i) << " (" << mbPerSecOut.at(i) << " MB)";
}

195
fairmq/options/FairMQParser.cxx
View File

@ -14,24 +14,27 @@
#include "FairMQParser.h"
#include "FairMQLogger.h"
#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/json_parser.hpp>
using namespace std;
namespace FairMQParser
namespace fair
{
namespace mq
{
namespace parser
{
// TODO : add key-value map<string,string> parameter for replacing/updating values from keys
// function that convert property tree (given the xml or json structure) to FairMQMap
FairMQMap ptreeToMQMap(const boost::property_tree::ptree& pt, const string& id, const string& rootNode, const string& formatFlag)
// function that convert property tree (given the json structure) to FairMQMap
FairMQMap ptreeToMQMap(const boost::property_tree::ptree& pt, const string& id, const string& rootNode)
{
// Create fair mq map
FairMQMap channelMap;
//Helper::PrintPropertyTree(pt);
//Helper::PrintDeviceList(pt.get_child(rootNode), formatFlag);
//Helper::PrintDeviceList(pt.get_child(rootNode));
// Extract value from boost::property_tree
Helper::DeviceParser(pt.get_child(rootNode), channelMap, id, formatFlag);
Helper::DeviceParser(pt.get_child(rootNode), channelMap, id);
if (channelMap.empty())
{
@ -56,24 +59,10 @@ FairMQMap JSON::UserParser(stringstream& input, const string& deviceId, const st
return ptreeToMQMap(pt, deviceId, rootNode);
}
FairMQMap XML::UserParser(const string& filename, const string& deviceId, const string& rootNode)
{
boost::property_tree::ptree pt;
boost::property_tree::read_xml(filename, pt);
return ptreeToMQMap(pt, deviceId, rootNode, "xml");
}
FairMQMap XML::UserParser(stringstream& input, const string& deviceId, const string& rootNode)
{
boost::property_tree::ptree pt;
boost::property_tree::read_xml(input, pt);
return ptreeToMQMap(pt, deviceId, rootNode, "xml");
}
namespace Helper
{
void PrintDeviceList(const boost::property_tree::ptree& tree, const string& formatFlag)
void PrintDeviceList(const boost::property_tree::ptree& tree)
{
string deviceIdKey;
@ -97,35 +86,10 @@ void PrintDeviceList(const boost::property_tree::ptree& tree, const string& form
}
}
}
if (p.first == "device")
{
// get id attribute to choose the device
if (formatFlag == "xml")
{
deviceIdKey = p.second.get<string>("<xmlattr>.id");
LOG(debug) << "Found config for '" << deviceIdKey << "' in XML input";
}
if (formatFlag == "json")
{
string key = p.second.get<string>("key", "");
if (key != "")
{
deviceIdKey = key;
LOG(debug) << "Found config for device key '" << deviceIdKey << "' in JSON input";
}
else
{
deviceIdKey = p.second.get<string>("id");
LOG(debug) << "Found config for device id '" << deviceIdKey << "' in JSON input";
}
}
}
}
}
void DeviceParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap, const string& deviceId, const string& formatFlag)
void DeviceParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap, const string& deviceId)
{
string deviceIdKey;
@ -160,48 +124,13 @@ void DeviceParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap
LOG(debug) << "Found with following channels:";
ChannelParser(q.second, channelMap, formatFlag);
ChannelParser(q.second, channelMap);
}
}
if (p.first == "device")
{
if (formatFlag == "xml")
{
deviceIdKey = p.second.get<string>("<xmlattr>.id");
}
if (formatFlag == "json")
{
// check if key is provided, otherwise use id
string key = p.second.get<string>("key", "");
if (key != "")
{
deviceIdKey = key;
// LOG(debug) << "Found config for device key '" << deviceIdKey << "' in JSON input";
}
else
{
deviceIdKey = p.second.get<string>("id");
// LOG(debug) << "Found config for device id '" << deviceIdKey << "' in JSON input";
}
}
// if not correct device id, do not fill MQMap
if (deviceId != deviceIdKey)
{
continue;
}
LOG(debug) << "Found with following channels:";
ChannelParser(p.second, channelMap, formatFlag);
}
}
}
void ChannelParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap, const string& formatFlag)
void ChannelParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap)
{
string channelKey;
@ -260,69 +189,6 @@ void ChannelParser(const boost::property_tree::ptree& tree, FairMQMap& channelMa
channelMap.insert(make_pair(channelKey, move(channelList)));
}
}
if (p.first == "channel")
{
// try to get common properties to use for all subChannels
FairMQChannel commonChannel;
int numSockets = 0;
// get name attribute to form key
if (formatFlag == "xml")
{
channelKey = p.second.get<string>("<xmlattr>.name");
}
if (formatFlag == "json")
{
channelKey = p.second.get<string>("name");
numSockets = p.second.get<int>("numSockets", 0);
// try to get common properties to use for all subChannels
commonChannel.UpdateType(p.second.get<string>("type", commonChannel.GetType()));
commonChannel.UpdateMethod(p.second.get<string>("method", commonChannel.GetMethod()));
commonChannel.UpdateAddress(p.second.get<string>("address", commonChannel.GetAddress()));
commonChannel.UpdateTransport(p.second.get<string>("transport", commonChannel.GetTransport()));
commonChannel.UpdateSndBufSize(p.second.get<int>("sndBufSize", commonChannel.GetSndBufSize()));
commonChannel.UpdateRcvBufSize(p.second.get<int>("rcvBufSize", commonChannel.GetRcvBufSize()));
commonChannel.UpdateSndKernelSize(p.second.get<int>("sndKernelSize", commonChannel.GetSndKernelSize()));
commonChannel.UpdateRcvKernelSize(p.second.get<int>("rcvKernelSize", commonChannel.GetRcvKernelSize()));
commonChannel.UpdateRateLogging(p.second.get<int>("rateLogging", commonChannel.GetRateLogging()));
}
// temporary FairMQChannel container
vector<FairMQChannel> channelList;
if (numSockets > 0)
{
LOG(debug) << "" << channelKey << ":";
LOG(debug) << "\tnumSockets of " << numSockets << " specified,";
LOG(debug) << "\tapplying common settings to each:";
LOG(debug) << "\ttype = " << commonChannel.GetType();
LOG(debug) << "\tmethod = " << commonChannel.GetMethod();
LOG(debug) << "\taddress = " << commonChannel.GetAddress();
LOG(debug) << "\ttransport = " << commonChannel.GetTransport();
LOG(debug) << "\tsndBufSize = " << commonChannel.GetSndBufSize();
LOG(debug) << "\trcvBufSize = " << commonChannel.GetRcvBufSize();
LOG(debug) << "\tsndKernelSize = " << commonChannel.GetSndKernelSize();
LOG(debug) << "\trcvKernelSize = " << commonChannel.GetRcvKernelSize();
LOG(debug) << "\trateLogging = " << commonChannel.GetRateLogging();
for (int i = 0; i < numSockets; ++i)
{
FairMQChannel channel(commonChannel);
channelList.push_back(channel);
}
}
else
{
SocketParser(p.second.get_child(""), channelList, channelKey, commonChannel);
}
channelMap.insert(make_pair(channelKey, move(channelList)));
}
}
}
@ -366,37 +232,6 @@ void SocketParser(const boost::property_tree::ptree& tree, vector<FairMQChannel>
++socketCounter;
}
}
if (p.first == "socket")
{
// create new channel and apply setting from the common channel
FairMQChannel channel(commonChannel);
// if the socket field specifies or overrides something from the common channel, apply those settings
channel.UpdateType(p.second.get<string>("type", channel.GetType()));
channel.UpdateMethod(p.second.get<string>("method", channel.GetMethod()));
channel.UpdateAddress(p.second.get<string>("address", channel.GetAddress()));
channel.UpdateTransport(p.second.get<string>("transport", channel.GetTransport()));
channel.UpdateSndBufSize(p.second.get<int>("sndBufSize", channel.GetSndBufSize()));
channel.UpdateRcvBufSize(p.second.get<int>("rcvBufSize", channel.GetRcvBufSize()));
channel.UpdateSndKernelSize(p.second.get<int>("sndKernelSize", channel.GetSndKernelSize()));
channel.UpdateRcvKernelSize(p.second.get<int>("rcvKernelSize", channel.GetRcvKernelSize()));
channel.UpdateRateLogging(p.second.get<int>("rateLogging", channel.GetRateLogging()));
LOG(debug) << "" << channelName << "[" << socketCounter << "]:";
LOG(debug) << "\ttype = " << channel.GetType();
LOG(debug) << "\tmethod = " << channel.GetMethod();
LOG(debug) << "\taddress = " << channel.GetAddress();
LOG(debug) << "\ttransport = " << channel.GetTransport();
LOG(debug) << "\tsndBufSize = " << channel.GetSndBufSize();
LOG(debug) << "\trcvBufSize = " << channel.GetRcvBufSize();
LOG(debug) << "\tsndKernelSize = " << channel.GetSndKernelSize();
LOG(debug) << "\trcvKernelSize = " << channel.GetRcvKernelSize();
LOG(debug) << "\trateLogging = " << channel.GetRateLogging();
channelList.push_back(channel);
++socketCounter;
}
} // end socket loop
if (socketCounter)
@ -435,4 +270,6 @@ void PrintPropertyTree(const boost::property_tree::ptree& tree, int level)
} // Helper namespace
} // FairMQParser namespace
} // namespace parser
} // namespace mq
} // namespace fair

24
fairmq/options/FairMQParser.h
View File

@ -17,12 +17,16 @@
#include "FairMQChannel.h"
namespace FairMQParser
namespace fair
{
namespace mq
{
namespace parser
{
using FairMQMap = std::unordered_map<std::string, std::vector<FairMQChannel>>;
FairMQMap ptreeToMQMap(const boost::property_tree::ptree& pt, const std::string& deviceId, const std::string& rootNode, const std::string& formatFlag = "json");
FairMQMap ptreeToMQMap(const boost::property_tree::ptree& pt, const std::string& deviceId, const std::string& rootNode);
struct JSON
{
@ -30,23 +34,19 @@ struct JSON
FairMQMap UserParser(std::stringstream& input, const std::string& deviceId, const std::string& rootNode = "fairMQOptions");
};
struct XML
{
FairMQMap UserParser(const std::string& filename, const std::string& deviceId, const std::string& rootNode = "fairMQOptions");
FairMQMap UserParser(std::stringstream& input, const std::string& deviceId, const std::string& rootNode = "fairMQOptions");
};
namespace Helper
{
void PrintDeviceList(const boost::property_tree::ptree& tree, const std::string& formatFlag = "json");
void DeviceParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap, const std::string& deviceId, const std::string& formatFlag);
void ChannelParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap, const std::string& formatFlag);
void PrintDeviceList(const boost::property_tree::ptree& tree);
void DeviceParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap, const std::string& deviceId);
void ChannelParser(const boost::property_tree::ptree& tree, FairMQMap& channelMap);
void SocketParser(const boost::property_tree::ptree& tree, std::vector<FairMQChannel>& channelList, const std::string& channelName, const FairMQChannel& commonChannel);
void PrintPropertyTree(const boost::property_tree::ptree& tree, int level = 0);
} // Helper namespace
} // FairMQParser namespace
} // namespace parser
} // namespace mq
} // namespace fair
#endif /* FAIRMQPARSER_H */

126
fairmq/options/FairMQProgOptions.cxx
View File

@ -31,7 +31,7 @@ FairMQProgOptions::FairMQProgOptions()
, fMQKeyMap()
{
InitOptionDescription();
ParseDefaults(fCmdLineOptions);
ParseDefaults();
}
FairMQProgOptions::~FairMQProgOptions()
@ -52,7 +52,7 @@ int FairMQProgOptions::ParseAll(const vector<string>& cmdLineArgs, bool allowUnr
int FairMQProgOptions::ParseAll(const int argc, char const* const* argv, bool allowUnregistered)
{
if (FairProgOptions::ParseCmdLine(argc, argv, fCmdLineOptions, fVarMap, allowUnregistered))
if (FairProgOptions::ParseCmdLine(argc, argv, allowUnregistered))
{
// ParseCmdLine returns 0 if no immediate switches found.
return 1;
@ -83,93 +83,53 @@ int FairMQProgOptions::ParseAll(const int argc, char const* const* argv, bool al
fair::Logger::SetConsoleSeverity(severity);
}
// check if one of required MQ config option is there
auto parserOptions = fMQParserOptions.options();
bool optionExists = false;
vector<string> MQParserKeys;
for (const auto& p : parserOptions)
{
MQParserKeys.push_back(p->canonical_display_name());
if (fVarMap.count(p->canonical_display_name()))
{
optionExists = true;
break;
}
}
string id;
if (!optionExists)
// check if config-key for config parser is provided
if (fVarMap.count("config-key"))
{
LOG(warn) << "FairMQProgOptions: no channels configuration provided via neither of:";
for (const auto& p : MQParserKeys)
{
LOG(warn) << " --" << p;
}
LOG(warn) << "No channels will be created (You can create them manually).";
id = fVarMap["config-key"].as<string>();
}
else
{
string id;
id = fVarMap["id"].as<string>();
}
if (fVarMap.count("config-key"))
{
id = fVarMap["config-key"].as<string>();
}
else
{
id = fVarMap["id"].as<string>();
}
// if cmdline mq-config called then use the default xml/json parser
// check if any config parser is selected
try
{
if (fVarMap.count("mq-config"))
{
LOG(debug) << "mq-config: Using default XML/JSON parser";
string file = fVarMap["mq-config"].as<string>();
string ext = boost::filesystem::extension(file);
transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
if (ext == ".json")
{
UserParser<FairMQParser::JSON>(file, id);
}
else
{
if (ext == ".xml")
{
UserParser<FairMQParser::XML>(file, id);
}
else
{
LOG(error) << "mq-config command line called but file extension '" << ext << "' not recognized. Program will now exit";
return 1;
}
}
LOG(debug) << "mq-config: Using default JSON parser";
Store(fair::mq::parser::JSON().UserParser(fVarMap["mq-config"].as<string>(), id));
}
else if (fVarMap.count("config-json-string"))
{
LOG(debug) << "config-json-string: Parsing JSON string";
string value = FairMQ::ConvertVariableValue<FairMQ::ToString>().Run(fVarMap.at("config-json-string"));
string value = fair::mq::ConvertVariableValue<fair::mq::VarInfoToString>()(fVarMap.at("config-json-string"));
stringstream ss;
ss << value;
UserParser<FairMQParser::JSON>(ss, id);
Store(fair::mq::parser::JSON().UserParser(ss, id));
}
else if (fVarMap.count("config-xml-string"))
{
LOG(debug) << "config-json-string: Parsing XML string";
string value = FairMQ::ConvertVariableValue<FairMQ::ToString>().Run(fVarMap.at("config-xml-string"));
stringstream ss;
ss << value;
UserParser<FairMQParser::XML>(ss, id);
}
else if (fVarMap.count(FairMQParser::SUBOPT::OptionKeyChannelConfig))
else if (fVarMap.count("channel-config"))
{
LOG(debug) << "channel-config: Parsing channel configuration";
UserParser<FairMQParser::SUBOPT>(fVarMap, id);
Store(fair::mq::parser::SUBOPT().UserParser(fVarMap.at("channel-config").as<vector<string>>(), id));
}
else
{
LOG(warn) << "FairMQProgOptions: no channels configuration provided via neither of:";
for (const auto& p : fMQParserOptions.options())
{
LOG(warn) << "--" << p->canonical_display_name();
}
LOG(warn) << "No channels will be created (You can create them manually).";
}
}
catch (std::exception& e)
{
LOG(error) << e.what();
return 1;
}
FairProgOptions::PrintOptions();
@ -223,15 +183,15 @@ void FairMQProgOptions::UpdateMQValues()
string rcvKernelSizeKey = "chans." + p.first + "." + to_string(index) + ".rcvKernelSize";
string rateLoggingKey = "chans." + p.first + "." + to_string(index) + ".rateLogging";
fMQKeyMap[typeKey] = make_tuple(p.first, index, "type");
fMQKeyMap[methodKey] = make_tuple(p.first, index, "method");
fMQKeyMap[addressKey] = make_tuple(p.first, index, "address");
fMQKeyMap[transportKey] = make_tuple(p.first, index, "transport");
fMQKeyMap[sndBufSizeKey] = make_tuple(p.first, index, "sndBufSize");
fMQKeyMap[rcvBufSizeKey] = make_tuple(p.first, index, "rcvBufSize");
fMQKeyMap[sndKernelSizeKey] = make_tuple(p.first, index, "sndKernelSize");
fMQKeyMap[rcvKernelSizeKey] = make_tuple(p.first, index, "rcvkernelSize");
fMQKeyMap[rateLoggingKey] = make_tuple(p.first, index, "rateLogging");
fMQKeyMap[typeKey] = MQKey{p.first, index, "type"};
fMQKeyMap[methodKey] = MQKey{p.first, index, "method"};
fMQKeyMap[addressKey] = MQKey{p.first, index, "address"};
fMQKeyMap[transportKey] = MQKey{p.first, index, "transport"};
fMQKeyMap[sndBufSizeKey] = MQKey{p.first, index, "sndBufSize"};
fMQKeyMap[rcvBufSizeKey] = MQKey{p.first, index, "rcvBufSize"};
fMQKeyMap[sndKernelSizeKey] = MQKey{p.first, index, "sndKernelSize"};
fMQKeyMap[rcvKernelSizeKey] = MQKey{p.first, index, "rcvkernelSize"};
fMQKeyMap[rateLoggingKey] = MQKey{p.first, index, "rateLogging"};
UpdateVarMap<string>(typeKey, channel.GetType());
UpdateVarMap<string>(methodKey, channel.GetMethod());
@ -253,7 +213,7 @@ int FairMQProgOptions::ImmediateOptions()
{
if (fVarMap.count("help"))
{
cout << "===== FairMQ Program Options =====" << endl << fVisibleOptions;
cout << "===== FairMQ Program Options =====" << endl << fAllOptions;
return 1;
}
@ -285,13 +245,11 @@ void FairMQProgOptions::InitOptionDescription()
;
fMQParserOptions.add_options()
("config-xml-string", po::value<vector<string>>()->multitoken(), "XML input as command line string.")
("config-json-string", po::value<vector<string>>()->multitoken(), "JSON input as command line string.")
("mq-config", po::value<string>(), "JSON/XML input as file. The configuration object will check xml or json file extention and will call the json or xml parser accordingly")
(FairMQParser::SUBOPT::OptionKeyChannelConfig, po::value<vector<string>>()->multitoken()->composing(), "Configuration of single or multiple channel(s) by comma separated key=value list")
("channel-config", po::value<vector<string>>()->multitoken()->composing(), "Configuration of single or multiple channel(s) by comma separated key=value list")
;
AddToCmdLineOptions(fGeneralDesc);
AddToCmdLineOptions(fMQCmdOptions);
AddToCmdLineOptions(fMQParserOptions);
}

42
fairmq/options/FairMQProgOptions.h
View File

@ -52,22 +52,6 @@ class FairMQProgOptions : public FairProgOptions
// default parser for the mq-configuration file (JSON/XML) is called if command line key mq-config is called
int ParseAll(const int argc, char const* const* argv, bool allowUnregistered = false) override;
// external parser, store function
template <typename T, typename ...Args>
int UserParser(Args &&... args)
{
try
{
Store(T().UserParser(std::forward<Args>(args)...));
}
catch (std::exception& e)
{
LOG(error) << e.what();
return 1;
}
return 0;
}
FairMQMap GetFairMQMap() const
{
return fFairMQMap;
@ -78,12 +62,6 @@ class FairMQProgOptions : public FairProgOptions
return fChannelInfo;
}
// store key-value of type T into variable_map.
// If key is found in fMQKeyMap, update the FairMQChannelMap accordingly
// Note that the fMQKeyMap is filled:
// - if UpdateChannelMap(const FairMQMap& map) method is called
// - if UserParser template method is called (it is called in the ParseAll method if json or xml MQ-config files is provided)
template<typename T>
int UpdateValue(const std::string& key, T val)
{
@ -99,11 +77,7 @@ class FairMQProgOptions : public FairProgOptions
{
if (fMQKeyMap.count(key))
{
std::string channelName;
int index = 0;
std::string member;
std::tie(channelName, index, member) = fMQKeyMap.at(key);
UpdateChannelMap(channelName, index, member, val);
UpdateChannelMap(fMQKeyMap.at(key).channel, fMQKeyMap.at(key).index, fMQKeyMap.at(key).member, val);
}
}
@ -135,11 +109,7 @@ class FairMQProgOptions : public FairProgOptions
{
if (fMQKeyMap.count(key))
{
std::string channelName;
int index = 0;
std::string member;
std::tie(channelName, index, member) = fMQKeyMap.at(key);
UpdateChannelMap(channelName, index, member, val);
UpdateChannelMap(fMQKeyMap.at(key).channel, fMQKeyMap.at(key).index, fMQKeyMap.at(key).member, val);
}
}
@ -189,6 +159,13 @@ class FairMQProgOptions : public FairProgOptions
int UpdateChannelMap(const FairMQMap& map);
protected:
struct MQKey
{
std::string channel;
int index;
std::string member;
};
po::options_description fMQCmdOptions;
po::options_description fMQParserOptions;
FairMQMap fFairMQMap;
@ -196,7 +173,6 @@ class FairMQProgOptions : public FairProgOptions
// map of read channel info - channel name - number of subchannels
std::unordered_map<std::string, int> fChannelInfo;
using MQKey = std::tuple<std::string, int, std::string>;//store key info
std::map<std::string, MQKey> fMQKeyMap;// key=full path - val=key info
int ImmediateOptions() override; // for custom help & version printing

89
fairmq/options/FairMQSuboptParser.cxx
View File

@ -12,68 +12,81 @@
/// @brief Parser implementation for key-value subopt format
#include "FairMQSuboptParser.h"
#include <boost/property_tree/ptree.hpp>
#include <cstring>
#include <utility> // make_pair
using boost::property_tree::ptree;
using namespace std;
namespace FairMQParser
namespace fair
{
namespace mq
{
namespace parser
{
constexpr const char* SUBOPT::channelOptionKeys[];
FairMQMap SUBOPT::UserParser(const po::variables_map& omap, const std::string& deviceId, const std::string& rootNode)
FairMQMap SUBOPT::UserParser(const vector<string>& channelConfig, const string& deviceId, const string& rootNode)
{
std::string nodeKey = rootNode + ".device";
ptree pt;
pt.put(nodeKey + ".id", deviceId.c_str());
nodeKey += ".channels";
ptree devicesArray;
ptree deviceProperties;
// parsing of channel properties is the only implemented method right now
if (omap.count(OptionKeyChannelConfig) > 0)
ptree channelsArray;
for (auto token : channelConfig)
{
std::map<std::string, ptree> channelProperties;
auto tokens = omap[OptionKeyChannelConfig].as<std::vector<std::string>>();
for (auto token : tokens)
string channelName;
ptree channelProperties;
ptree socketsArray;
ptree socketProperties;
string argString(token);
char* subopts = &argString[0];
char* value = nullptr;
while (subopts && *subopts != 0 && *subopts != ' ')
{
// std::map<std::string, ptree>::iterator channelProperty = channelProperties.end();
ptree socketProperty;
std::string channelName;
std::string argString(token);
char* subopts = &argString[0];
char* value = nullptr;
while (subopts && *subopts != 0 && *subopts != ' ')
int subopt = getsubopt(&subopts, (char**)channelOptionKeys, &value);
if (subopt == NAME)
{
// char* saved = subopts;
int subopt=getsubopt(&subopts, (char**)channelOptionKeys, &value);
if (subopt == NAME)
{
channelName = value;
channelProperties[channelName].put("name", channelName);
}
else if (subopt>=0 && value != nullptr)
{
socketProperty.put(channelOptionKeys[subopt], value);
}
channelName = value;
channelProperties.put("name", channelName);
}
if (channelName != "")
else if (subopt >= 0 && value != nullptr)
{
channelProperties[channelName].add_child("sockets.socket", socketProperty);
}
else
{
// TODO: what is the error policy here, should we abort?
LOG(error) << "missing channel name in argument of option --channel-config";
socketProperties.put(channelOptionKeys[subopt], value);
}
}
for (auto channelProperty : channelProperties)
if (channelName != "")
{
pt.add_child(nodeKey + ".channel", channelProperty.second);
socketsArray.push_back(make_pair("", socketProperties));
channelProperties.add_child("sockets", socketsArray);
}
else
{
// TODO: what is the error policy here, should we abort?
LOG(error) << "missing channel name in argument of option --channel-config";
}
channelsArray.push_back(make_pair("", channelProperties));
}
deviceProperties.put("id", deviceId);
deviceProperties.add_child("channels", channelsArray);
devicesArray.push_back(make_pair("", deviceProperties));
pt.add_child("fairMQOptions.devices", devicesArray);
return ptreeToMQMap(pt, deviceId, rootNode);
}
} // namespace FairMQParser
}
}
}

72
fairmq/options/FairMQSuboptParser.h
View File

@ -17,11 +17,18 @@
#include "FairMQParser.h" // for FairMQMap
#include <boost/program_options.hpp>
#include <cstring>
#include <vector>
#include <string>
namespace po = boost::program_options;
namespace FairMQParser
namespace fair
{
namespace mq
{
namespace parser
{
/**
* A parser implementation for FairMQ channel properties.
* The parser handles a comma separated key=value list format by using the
@ -38,39 +45,42 @@ namespace FairMQParser
* the concept is extensible by renaming UserParser to ChannelPropertyParser
* and introducing additional parser functions.
*/
struct SUBOPT {
enum channelOptionKeyIds {
NAME = 0, // name of the channel
TYPE, // push, pull, publish, subscribe, etc
METHOD, // bind or connect
ADDRESS, // host, protocol and port address
TRANSPORT, //
SNDBUFSIZE, // size of the send queue
RCVBUFSIZE, // size of the receive queue
SNDKERNELSIZE,
RCVKERNELSIZE,
RATELOGGING, // logging rate
lastsocketkey
};
struct SUBOPT
{
enum channelOptionKeyIds
{
NAME = 0, // name of the channel
TYPE, // push, pull, publish, subscribe, etc
METHOD, // bind or connect
ADDRESS, // host, protocol and port address
TRANSPORT, //
SNDBUFSIZE, // size of the send queue
RCVBUFSIZE, // size of the receive queue
SNDKERNELSIZE,
RCVKERNELSIZE,
RATELOGGING, // logging rate
lastsocketkey
};
constexpr static const char *channelOptionKeys[] = {
/*[NAME] = */ "name",
/*[TYPE] = */ "type",
/*[METHOD] = */ "method",
/*[ADDRESS] = */ "address",
/*[TRANSPORT] = */ "transport",
/*[SNDBUFSIZE] = */ "sndBufSize",
/*[RCVBUFSIZE] = */ "rcvBufSize",
/*[SNDKERNELSIZE] = */ "sndKernelSize",
/*[RCVKERNELSIZE] = */ "rcvKernelSize",
/*[RATELOGGING] = */ "rateLogging",
nullptr
};
constexpr static const char *channelOptionKeys[] = {
/*[NAME] = */ "name",
/*[TYPE] = */ "type",
/*[METHOD] = */ "method",
/*[ADDRESS] = */ "address",
/*[TRANSPORT] = */ "transport",
/*[SNDBUFSIZE] = */ "sndBufSize",
/*[RCVBUFSIZE] = */ "rcvBufSize",
/*[SNDKERNELSIZE] = */ "sndKernelSize",
/*[RCVKERNELSIZE] = */ "rcvKernelSize",
/*[RATELOGGING] = */ "rateLogging",
nullptr
};
constexpr static const char* OptionKeyChannelConfig = "channel-config";
FairMQMap UserParser(const po::variables_map& omap, const std::string& deviceId, const std::string& rootNode = "fairMQOptions");
FairMQMap UserParser(const std::vector<std::string>& channelConfig, const std::string& deviceId, const std::string& rootNode = "fairMQOptions");
};
}
}
}
#endif /* FAIRMQPARSER_SUBOPT_H */

176
fairmq/options/FairProgOptions.cxx
View File

@ -19,15 +19,15 @@
#include <algorithm>
using namespace std;
using namespace fair::mq;
FairProgOptions::FairProgOptions()
: fVarMap()
, fGeneralDesc("General options")
, fCmdLineOptions("Command line options")
, fVisibleOptions("Visible options")
, fGeneralOptions("General options")
, fAllOptions("Command line options")
, fConfigMutex()
{
fGeneralDesc.add_options()
fGeneralOptions.add_options()
("help,h", "produce help")
("version,v", "print version")
("severity", po::value<string>()->default_value("debug"), "Log severity level: trace, debug, info, state, warn, error, fatal, nolog")
@ -35,6 +35,8 @@ FairProgOptions::FairProgOptions()
("color", po::value<bool>()->default_value(true), "Log color (true/false)")
("log-to-file", po::value<string>()->default_value(""), "Log output to a file.")
("print-options", po::value<bool>()->implicit_value(true), "print options in machine-readable format (<option>:<computed-value>:<type>:<description>)");
fAllOptions.add(fGeneralOptions);
}
FairProgOptions::~FairProgOptions()
@ -42,54 +44,45 @@ FairProgOptions::~FairProgOptions()
}
/// Add option descriptions
int FairProgOptions::AddToCmdLineOptions(const po::options_description optDesc, bool visible)
int FairProgOptions::AddToCmdLineOptions(const po::options_description optDesc, bool /* visible */)
{
fCmdLineOptions.add(optDesc);
if (visible)
{
fVisibleOptions.add(optDesc);
}
fAllOptions.add(optDesc);
return 0;
}
po::options_description& FairProgOptions::GetCmdLineOptions()
{
return fCmdLineOptions;
return fAllOptions;
}
int FairProgOptions::ParseCmdLine(const int argc, char const* const* argv, const po::options_description& desc, po::variables_map& varmap, bool allowUnregistered)
int FairProgOptions::ParseCmdLine(const int argc, char const* const* argv, 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();
parser.options(fAllOptions).allow_unregistered();
po::parsed_options parsedOptions = parser.run();
po::store(parsedOptions, varmap);
po::store(parsedOptions, fVarMap);
}
else
{
po::store(po::parse_command_line(argc, argv, desc), varmap);
po::store(po::parse_command_line(argc, argv, fAllOptions), fVarMap);
}
// Handles options like "--help" or "--version"
// return 1 if switch options found in varmap
// return 1 if switch options found in fVarMap
if (ImmediateOptions())
{
return 1;
}
po::notify(varmap);
po::notify(fVarMap);
return 0;
}
int FairProgOptions::ParseCmdLine(const int argc, char const* const* argv, const po::options_description& desc, bool allowUnregistered)
{
return ParseCmdLine(argc, argv, desc, fVarMap, allowUnregistered);
}
void FairProgOptions::ParseDefaults(const po::options_description& desc)
void FairProgOptions::ParseDefaults()
{
vector<string> emptyArgs;
emptyArgs.push_back("dummy");
@ -101,148 +94,85 @@ void FairProgOptions::ParseDefaults(const po::options_description& desc)
return str.c_str();
});
po::store(po::parse_command_line(argv.size(), const_cast<char**>(argv.data()), desc), fVarMap);
po::store(po::parse_command_line(argv.size(), const_cast<char**>(argv.data()), fAllOptions), fVarMap);
}
int FairProgOptions::PrintOptions()
{
// Method to overload.
// -> loop over variable map and print its content
// -> In this example the following types are supported:
// string, int, float, double, short, boost::filesystem::path
// vector<string>, vector<int>, vector<float>, vector<double>, vector<short>
MapVarValInfo_t mapinfo;
map<string, VarValInfo> mapinfo;
// get string length for formatting and convert varmap values into string
int maxLength1st = 0;
int maxLength2nd = 0;
int maxLengthTypeInfo = 0;
int maxLengthDefault = 0;
int maxLengthEmpty = 0;
int totalLength = 0;
int maxLen1st = 0;
int maxLen2nd = 0;
int maxLenTypeInfo = 0;
int maxLenDefault = 0;
int maxLenEmpty = 0;
for (const auto& m : fVarMap)
{
Max(maxLength1st, m.first.length());
Max(maxLen1st, m.first.length());
VarValInfo_t valinfo = GetVariableValueInfo(m.second);
VarValInfo valinfo = GetVariableValueInfo(m.second);
mapinfo[m.first] = valinfo;
string valueStr;
string typeInfoStr;
string defaultStr;
string emptyStr;
tie(valueStr, typeInfoStr, defaultStr, emptyStr) = valinfo;
Max(maxLength2nd, valueStr.length());
Max(maxLengthTypeInfo, typeInfoStr.length());
Max(maxLengthDefault, defaultStr.length());
Max(maxLengthEmpty, emptyStr.length());
Max(maxLen2nd, valinfo.value.length());
Max(maxLenTypeInfo, valinfo.type.length());
Max(maxLenDefault, valinfo.defaulted.length());
Max(maxLenEmpty, valinfo.empty.length());
}
// TODO : limit the value length field in a better way
if (maxLength2nd > 100)
// TODO : limit the value len field in a better way
if (maxLen2nd > 100)
{
maxLength2nd = 100;
maxLen2nd = 100;
}
totalLength = maxLength1st + maxLength2nd + maxLengthTypeInfo + maxLengthDefault + maxLengthEmpty;
// maxLength2nd = 200;
// formatting and printing
stringstream ss;
ss << "\n";
ss << setfill('*') << setw(totalLength + 3) << "*" << "\n"; // +3 because of string " = "
string title = " Configuration ";
int leftSpaceLength = 0;
int rightSpaceLength = 0;
int leftTitleShiftLength = 0;
int rightTitleShiftLength = 0;
leftTitleShiftLength = title.length() / 2;
if ((title.length()) % 2)
{
rightTitleShiftLength = leftTitleShiftLength + 1;
}
else
{
rightTitleShiftLength = leftTitleShiftLength;
}
leftSpaceLength = (totalLength + 3) / 2 - leftTitleShiftLength;
if ((totalLength + 3) % 2)
{
rightSpaceLength = (totalLength + 3) / 2 - rightTitleShiftLength + 1;
}
else
{
rightSpaceLength = (totalLength + 3) / 2 - rightTitleShiftLength;
}
ss << setfill ('*') << setw(leftSpaceLength) << "*"
<< setw(title.length()) << title
<< setfill ('*') << setw(rightSpaceLength) << "*" << "\n";
ss << setfill ('*') << setw (totalLength+3) << "*" << "\n";
ss << "Configuration: \n";
for (const auto& p : mapinfo)
{
string keyStr;
string valueStr;
string typeInfoStr;
string defaultStr;
string emptyStr;
keyStr = p.first;
tie(valueStr, typeInfoStr, defaultStr, emptyStr) = p.second;
ss << setfill(' ')
<< setw(maxLength1st) << left
<< p.first << " = "
<< setw(maxLength2nd)
<< valueStr
<< setw(maxLengthTypeInfo)
<< typeInfoStr
<< setw(maxLengthDefault)
<< defaultStr
<< setw(maxLengthEmpty)
<< emptyStr
<< setw(maxLen1st) << left << p.first << " = "
<< setw(maxLen2nd) << p.second.value
<< setw(maxLenTypeInfo) << p.second.type
<< setw(maxLenDefault) << p.second.defaulted
<< setw(maxLenEmpty) << p.second.empty
<< "\n";
}
ss << setfill ('*') << setw(totalLength + 3) << "*";// +3 for " = "
LOG(debug) << ss.str();
LOG(info) << ss.str();
return 0;
}
int FairProgOptions::PrintOptionsRaw()
{
MapVarValInfo_t mapInfo;
const std::vector<boost::shared_ptr<po::option_description>>& options = fAllOptions.options();
for (const auto& m : fVarMap)
for (const auto& o : options)
{
mapInfo[m.first] = GetVariableValueInfo(m.second);
}
VarValInfo value;
if (fVarMap.count(o->canonical_display_name()))
{
value = GetVariableValueInfo(fVarMap[o->canonical_display_name()]);
}
for (const auto& p : mapInfo)
{
string keyStr;
string valueStr;
string typeInfoStr;
string defaultStr;
string emptyStr;
keyStr = p.first;
tie(valueStr, typeInfoStr, defaultStr, emptyStr) = p.second;
auto option = fCmdLineOptions.find_nothrow(keyStr, false);
cout << keyStr << ":" << valueStr << ":" << typeInfoStr << ":" << (option ? option->description() : "<not found>") << endl;
string description = o->description();
replace(description.begin(), description.end(), '\n', ' ');
cout << o->long_name() << ":" << value.value << ":" << (value.type == "" ? "<unknown>" : value.type) << ":" << description << endl;
}
return 0;
}
FairProgOptions::VarValInfo_t FairProgOptions::GetVariableValueInfo(const po::variable_value& varValue)
VarValInfo FairProgOptions::GetVariableValueInfo(const po::variable_value& varValue)
{
return FairMQ::ConvertVariableValue<FairMQ::ToVarInfo>().Run(varValue);
return ConvertVariableValue<ToVarValInfo>()(varValue);
}

61
fairmq/options/FairProgOptions.h
View File

@ -26,35 +26,6 @@
#include <iostream>
#include <fstream>
#include <mutex>
#include <tuple>
/*
* FairProgOptions abstract base class
* parse command line, configuration file options.
*
* The user defines in the derived class the option descriptions and
* the pure virtual ParseAll() method
*
* class MyOptions : public FairProgOptions
* {
* public :
* MyOptions() : FairProgOptions()
* {
* fCmdlineOptions.add(fGenericDesc);
* fVisibleOptions.add(fCmdlineOptions);
* }
* virtual ~MyOptions() {}
* virtual void ParseAll(const int argc, char** argv, bool allowUnregistered = false)
* {
* if (ParseCmdLine(argc, argv, fCmdlineOptions, fVarMap, allowUnregistered))
* {
* exit(EXIT_FAILURE);
* }
*
* PrintOptions();
* }
* }
*/
namespace po = boost::program_options;
namespace fs = boost::filesystem;
@ -120,7 +91,7 @@ class FairProgOptions
{
if (fVarMap.count(key))
{
valueStr = FairMQ::ConvertVariableValue<FairMQ::ToString>().Run(fVarMap.at(key));
valueStr = fair::mq::ConvertVariableValue<fair::mq::VarInfoToString>()(fVarMap.at(key));
}
}
catch (std::exception& e)
@ -158,12 +129,10 @@ class FairProgOptions
const po::variables_map& GetVarMap() const { return fVarMap; }
// boost prog options parsers
int ParseCmdLine(const int argc, char const* const* argv, const po::options_description& desc, po::variables_map& varmap, bool allowUnregistered = false);
int ParseCmdLine(const int argc, char const* const* argv, const po::options_description& desc, bool allowUnregistered = false);
void ParseDefaults(const po::options_description& desc);
int ParseCmdLine(const int argc, char const* const* argv, bool allowUnregistered = false);
void ParseDefaults();
virtual int ParseAll(const int argc, char const* const* argv, bool allowUnregistered = false) = 0;// TODO change return type to bool and propagate to executable
virtual int ParseAll(const int argc, char const* const* argv, bool allowUnregistered = false) = 0;
virtual int PrintOptions();
virtual int PrintOptionsRaw();
@ -172,37 +141,29 @@ class FairProgOptions
// options container
po::variables_map fVarMap;
// basic description categories
po::options_description fGeneralDesc;
po::options_description fCmdLineOptions;
// Description which is printed in help command line
po::options_description fVisibleOptions;
// options descriptions
po::options_description fGeneralOptions;
po::options_description fAllOptions;
mutable std::mutex fConfigMutex;
virtual int ImmediateOptions() = 0;
// UpdateVarMap() and replace() --> helper functions to modify the value of variable map after calling po::store
// UpdateVarMap() and Replace() --> helper functions to modify the value of variable map after calling po::store
template<typename T>
void UpdateVarMap(const std::string& key, const T& val)
{
replace(fVarMap, key, val);
Replace(fVarMap, key, val);
}
template<typename T>
void replace(std::map<std::string, po::variable_value>& vm, const std::string& key, const T& val)
void Replace(std::map<std::string, po::variable_value>& vm, const std::string& key, const T& val)
{
vm[key].value() = boost::any(val);
}
private:
// Methods below are helper functions used in the PrintOptions method
using VarValInfo_t = std::tuple<std::string, std::string, std::string, std::string>;
using MapVarValInfo_t = std::map<std::string, VarValInfo_t>;
VarValInfo_t GetVariableValueInfo(const po::variable_value& varValue);
fair::mq::VarValInfo GetVariableValueInfo(const po::variable_value& varValue);
static void Max(int& val, const int& comp)
{

168
fairmq/options/FairProgOptionsHelper.h
View File

@ -21,9 +21,21 @@
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <ostream>
#include <iterator>
#include <tuple>
namespace fair
{
namespace mq
{
struct VarValInfo
{
std::string value;
std::string type;
std::string defaulted;
std::string empty;
};
template<class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
@ -32,23 +44,22 @@ std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
return os;
}
namespace FairMQ
{
namespace po = boost::program_options;
template<typename T>
bool is_this_type(const po::variable_value& varValue)
bool typeIs(const boost::program_options::variable_value& varValue)
{
auto& value = varValue.value();
if (auto q = boost::any_cast<T>(&value))
{
return true;
}
else
{
return false;
}
}
template<typename T>
std::string ConvertVariableValueToString(const po::variable_value& varValue)
std::string ConvertVariableValueToString(const boost::program_options::variable_value& varValue)
{
auto& value = varValue.value();
std::ostringstream ostr;
@ -62,7 +73,7 @@ std::string ConvertVariableValueToString(const po::variable_value& varValue)
// string specialization
template<>
inline std::string ConvertVariableValueToString<std::string>(const po::variable_value& varValue)
inline std::string ConvertVariableValueToString<std::string>(const boost::program_options::variable_value& varValue)
{
auto& value = varValue.value();
std::string valueStr;
@ -75,7 +86,7 @@ inline std::string ConvertVariableValueToString<std::string>(const po::variable_
// boost::filesystem::path specialization
template<>
inline std::string ConvertVariableValueToString<boost::filesystem::path>(const po::variable_value& varValue)
inline std::string ConvertVariableValueToString<boost::filesystem::path>(const boost::program_options::variable_value& varValue)
{
auto& value = varValue.value();
std::string valueStr;
@ -87,11 +98,12 @@ inline std::string ConvertVariableValueToString<boost::filesystem::path>(const p
}
// policy to convert boost variable value into string
struct ToString
struct VarInfoToString
{
using returned_type = std::string;
template<typename T>
std::string Value(const po::variable_value& varValue, const std::string&, const std::string&, const std::string&)
std::string Value(const boost::program_options::variable_value& varValue, const std::string&, const std::string&, const std::string&)
{
return ConvertVariableValueToString<T>(varValue);
}
@ -102,20 +114,21 @@ struct ToString
}
};
// policy to convert variable value content into a tuple with value, type, defaulted, empty information
struct ToVarInfo
// policy to convert variable value content into VarValInfo
struct ToVarValInfo
{
using returned_type = std::tuple<std::string, std::string,std::string, std::string>;
using returned_type = fair::mq::VarValInfo;
template<typename T>
returned_type Value(const po::variable_value& varValue, const std::string& type, const std::string& defaulted, const std::string& empty)
returned_type Value(const boost::program_options::variable_value& varValue, const std::string& type, const std::string& defaulted, const std::string& empty)
{
std::string valueStr = ConvertVariableValueToString<T>(varValue);
return make_tuple(valueStr, type, defaulted, empty);
return fair::mq::VarValInfo{valueStr, type, defaulted, empty};
}
returned_type DefaultValue(const std::string& defaulted, const std::string& empty)
{
return make_tuple(std::string("Unknown value"), std::string(" [Unknown]"), defaulted, empty);
return fair::mq::VarValInfo{std::string("Unknown value"), std::string(" [Unknown]"), defaulted, empty};
}
};
@ -123,113 +136,90 @@ struct ToVarInfo
template<typename T>
struct ConvertVariableValue : T
{
//typename T::returned_type Run(const po::variable_value& varValue) //-> decltype(T::returned_type)
auto Run(const po::variable_value& varValue) -> typename T::returned_type
auto operator()(const boost::program_options::variable_value& varValue) -> typename T::returned_type
{
std::string defaultedValue;
std::string emptyValue;
std::string defaulted;
std::string empty;
if (varValue.empty())
{
emptyValue = " [empty]";
empty = " [empty]";
}
else
{
if (varValue.defaulted())
{
defaultedValue = " [default]";
defaulted = " [default]";
}
else
{
defaultedValue = " [provided]";
defaulted = " [provided]";
}
}
// emptyValue += " *";
if (typeIs<std::string>(varValue))
return T::template Value<std::string>(varValue, std::string("<string>"), defaulted, empty);
//////////////////////////////// std types
// std::string albeit useless here
if (is_this_type<std::string>(varValue))
return T::template Value<std::string>(varValue, std::string("<string>"), defaultedValue, emptyValue);
if (typeIs<std::vector<std::string>>(varValue))
return T::template Value<std::vector<std::string>>(varValue, std::string("<vector<string>>"), defaulted, empty);
// std::vector<std::string>
if (is_this_type<std::vector<std::string>>(varValue))
return T::template Value<std::vector<std::string>>(varValue, std::string("<vector<string>>"), defaultedValue, emptyValue);
if (typeIs<int>(varValue))
return T::template Value<int>(varValue, std::string("<int>"), defaulted, empty);
// int
if (is_this_type<int>(varValue))
return T::template Value<int>(varValue, std::string("<int>"), defaultedValue, emptyValue);
if (typeIs<std::vector<int>>(varValue))
return T::template Value<std::vector<int>>(varValue, std::string("<vector<int>>"), defaulted, empty);
// std::vector<int>
if (is_this_type<std::vector<int>>(varValue))
return T::template Value<std::vector<int>>(varValue, std::string("<vector<int>>"), defaultedValue, emptyValue);
if (typeIs<float>(varValue))
return T::template Value<float>(varValue, std::string("<float>"), defaulted, empty);
// float
if (is_this_type<float>(varValue))
return T::template Value<float>(varValue, std::string("<float>"), defaultedValue, emptyValue);
if (typeIs<std::vector<float>>(varValue))
return T::template Value<std::vector<float>>(varValue, std::string("<vector<float>>"), defaulted, empty);
// std::vector float
if (is_this_type<std::vector<float>>(varValue))
return T::template Value<std::vector<float>>(varValue, std::string("<vector<float>>"), defaultedValue, emptyValue);
if (typeIs<double>(varValue))
return T::template Value<double>(varValue, std::string("<double>"), defaulted, empty);
// double
if (is_this_type<double>(varValue))
return T::template Value<double>(varValue, std::string("<double>"), defaultedValue, emptyValue);
if (typeIs<std::vector<double>>(varValue))
return T::template Value<std::vector<double>>(varValue, std::string("<vector<double>>"), defaulted, empty);
// std::vector double
if (is_this_type<std::vector<double>>(varValue))
return T::template Value<std::vector<double>>(varValue, std::string("<vector<double>>"), defaultedValue, emptyValue);
if (typeIs<short>(varValue))
return T::template Value<short>(varValue, std::string("<short>"), defaulted, empty);
// short
if (is_this_type<short>(varValue))
return T::template Value<short>(varValue, std::string("<short>"), defaultedValue, emptyValue);
if (typeIs<std::vector<short>>(varValue))
return T::template Value<std::vector<short>>(varValue, std::string("<vector<short>>"), defaulted, empty);
// std::vector short
if (is_this_type<std::vector<short>>(varValue))
return T::template Value<std::vector<short>>(varValue, std::string("<vector<short>>"), defaultedValue, emptyValue);
if (typeIs<long>(varValue))
return T::template Value<long>(varValue, std::string("<long>"), defaulted, empty);
// long
if (is_this_type<long>(varValue))
return T::template Value<long>(varValue, std::string("<long>"), defaultedValue, emptyValue);
if (typeIs<std::vector<long>>(varValue))
return T::template Value<std::vector<long>>(varValue, std::string("<vector<long>>"), defaulted, empty);
// std::vector short
if (is_this_type<std::vector<long>>(varValue))
return T::template Value<std::vector<long>>(varValue, std::string("<vector<long>>"), defaultedValue, emptyValue);
if (typeIs<std::size_t>(varValue))
return T::template Value<std::size_t>(varValue, std::string("<std::size_t>"), defaulted, empty);
// size_t
if (is_this_type<std::size_t>(varValue))
return T::template Value<std::size_t>(varValue, std::string("<std::size_t>"), defaultedValue, emptyValue);
if (typeIs<std::vector<std::size_t>>(varValue))
return T::template Value<std::vector<std::size_t>>(varValue, std::string("<vector<std::size_t>>"), defaulted, empty);
// std::vector size_t
if (is_this_type<std::vector<std::size_t>>(varValue))
return T::template Value<std::vector<std::size_t>>(varValue, std::string("<vector<std::size_t>>"), defaultedValue, emptyValue);
if (typeIs<std::uint64_t>(varValue))
return T::template Value<std::uint64_t>(varValue, std::string("<std::uint64_t>"), defaulted, empty);
// uint64_t
if (is_this_type<std::uint64_t>(varValue))
return T::template Value<std::uint64_t>(varValue, std::string("<std::uint64_t>"), defaultedValue, emptyValue);
if (typeIs<std::vector<std::uint64_t>>(varValue))
return T::template Value<std::vector<std::uint64_t>>(varValue, std::string("<vector<std::uint64_t>>"), defaulted, empty);
// std::vector uint64_t
if (is_this_type<std::vector<std::uint64_t>>(varValue))
return T::template Value<std::vector<std::uint64_t>>(varValue, std::string("<vector<std::uint64_t>>"), defaultedValue, emptyValue);
if (typeIs<bool>(varValue))
return T::template Value<bool>(varValue, std::string("<bool>"), defaulted, empty);
// bool
if (is_this_type<bool>(varValue))
return T::template Value<bool>(varValue, std::string("<bool>"), defaultedValue, emptyValue);
if (typeIs<std::vector<bool>>(varValue))
return T::template Value<std::vector<bool>>(varValue, std::string("<vector<bool>>"), defaulted, empty);
// std::vector bool
if (is_this_type<std::vector<bool>>(varValue))
return T::template Value<std::vector<bool>>(varValue, std::string("<vector<bool>>"), defaultedValue, emptyValue);
//////////////////////////////// boost types
// boost::filesystem::path
if (is_this_type<boost::filesystem::path>(varValue))
return T::template Value<boost::filesystem::path>(varValue, std::string("<boost::filesystem::path>"), defaultedValue, emptyValue);
if (typeIs<boost::filesystem::path>(varValue))
return T::template Value<boost::filesystem::path>(varValue, std::string("<boost::filesystem::path>"), defaulted, empty);
// if we get here, the type is not supported return unknown info
return T::DefaultValue(defaultedValue, emptyValue);
return T::DefaultValue(defaulted, empty);
}
};
} // FairMQ namespace
} // namespace mq
} // namespace fair
#endif /* FAIRPROGOPTIONSHELPER_H */

4
fairmq/options/ProgOptionTest/run/testMQoptions2.cxx
View File

@ -35,8 +35,8 @@ int main(int argc, char** argv)
("output.file.branch", po::value<std::string>(), "output branch name")
;
config.AddToCmdLineOptions(format_desc,true);
config.AddToCmdLineOptions(io_file_opt_desc,true);
config.AddToCmdLineOptions(format_desc);
config.AddToCmdLineOptions(io_file_opt_desc);
config.EnableCfgFile();// UseConfigFile (by default config file is not defined)
config.AddToCfgFileOptions(format_desc,false);//false because already added to visible

8
fairmq/run/startMQBenchmark.sh.in
View File

@ -71,9 +71,9 @@ SAMPLER+=" --same-msg $sameMsg"
# SAMPLER+=" --msg-rate 1000"
SAMPLER+=" --max-iterations $maxIterations"
SAMPLER+=" --mq-config @CMAKE_BINARY_DIR@/bin/config/benchmark.json"
xterm -geometry 90x23+0+0 -hold -e $affinitySamp @CMAKE_BINARY_DIR@/bin/$SAMPLER &
xterm -geometry 90x50+0+0 -hold -e $affinitySamp @CMAKE_BINARY_DIR@/bin/$SAMPLER &
echo ""
echo "started: xterm -geometry 90x23+0+0 -hold -e $affinitySamp @CMAKE_BINARY_DIR@/bin/$SAMPLER"
echo "started: xterm -geometry 90x50+0+0 -hold -e $affinitySamp @CMAKE_BINARY_DIR@/bin/$SAMPLER"
echo "pid: $!"
SINK="sink"
@ -84,8 +84,8 @@ SINK+=" --transport $transport"
SINK+=" --severity debug"
SINK+=" --max-iterations $maxIterations"
SINK+=" --mq-config @CMAKE_BINARY_DIR@/bin/config/benchmark.json"
xterm -geometry 90x23+550+0 -hold -e $affinitySink @CMAKE_BINARY_DIR@/bin/$SINK &
xterm -geometry 90x50+550+0 -hold -e $affinitySink @CMAKE_BINARY_DIR@/bin/$SINK &
echo ""
echo "started: xterm -geometry 90x23+550+0 -hold -e $affinitySink @CMAKE_BINARY_DIR@/bin/$SINK"
echo "started: xterm -geometry 90x50+550+0 -hold -e $affinitySink @CMAKE_BINARY_DIR@/bin/$SINK"
echo "pid: $!"
echo ""