From: Otto Moerbeek <otto.moerbeek@open-xchange.com>
Date: Fri, 12 May 2023 09:00:25 +0000 (+0200)
Subject: Reformat
X-Git-Tag: rec-5.0.0-alpha1~180^2~2
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=725bf8033245bd87b65dfb55ece21099440e92ee;p=thirdparty%2Fpdns.git

Reformat
---

diff --git a/.not-formatted b/.not-formatted
index a9f2b5c615..cbe3421eb7 100644
--- a/.not-formatted
+++ b/.not-formatted
@@ -4,8 +4,6 @@
 ./ext/lmdb-safe/lmdb-typed.hh
 ./ext/probds/murmur3.cc
 ./pdns/anadns.hh
-./pdns/arguments.cc
-./pdns/arguments.hh
 ./pdns/auth-caches.cc
 ./pdns/auth-carbon.cc
 ./pdns/auth-packetcache.cc
diff --git a/pdns/arguments.cc b/pdns/arguments.cc
index 7f9f9b558c..70f66a93eb 100644
--- a/pdns/arguments.cc
+++ b/pdns/arguments.cc
@@ -45,74 +45,73 @@ const ArgvMap::param_t::const_iterator ArgvMap::end()
   return d_params.end();
 }
 
-string & ArgvMap::set(const string &var)
+string& ArgvMap::set(const string& var)
 {
   return d_params[var];
 }
 
-void ArgvMap::setDefault(const string &var, const string &value)
+void ArgvMap::setDefault(const string& var, const string& value)
 {
-  if(! defaultmap.count(var))
+  if (!defaultmap.count(var))
     defaultmap.insert(pair<string, string>(var, value));
 }
 
 void ArgvMap::setDefaults()
 {
-  for (const auto& i: d_params)
-    if(! defaultmap.count(i.first))
+  for (const auto& i : d_params)
+    if (!defaultmap.count(i.first))
       defaultmap.insert(i);
 }
 
-bool ArgvMap::mustDo(const string &var)
+bool ArgvMap::mustDo(const string& var)
 {
-  return ((*this)[var]!="no") && ((*this)[var]!="off");
+  return ((*this)[var] != "no") && ((*this)[var] != "off");
 }
 
-vector<string>ArgvMap::list()
+vector<string> ArgvMap::list()
 {
   vector<string> ret;
-  for (const auto& i: d_params)
+  for (const auto& i : d_params)
     ret.push_back(i.first);
   return ret;
 }
 
-string ArgvMap::getHelp(const string &item)
+string ArgvMap::getHelp(const string& item)
 {
   return helpmap[item];
 }
 
-string & ArgvMap::set(const string &var, const string &help)
+string& ArgvMap::set(const string& var, const string& help)
 {
-  helpmap[var]=help;
-  d_typeMap[var]="Parameter";
+  helpmap[var] = help;
+  d_typeMap[var] = "Parameter";
   return set(var);
 }
 
-void ArgvMap::setCmd(const string &var, const string &help)
+void ArgvMap::setCmd(const string& var, const string& help)
 {
-  helpmap[var]=help;
-  d_typeMap[var]="Command";
-  set(var)="no";
+  helpmap[var] = help;
+  d_typeMap[var] = "Command";
+  set(var) = "no";
 }
 
-string & ArgvMap::setSwitch(const string &var, const string &help)
+string& ArgvMap::setSwitch(const string& var, const string& help)
 {
-  helpmap[var]=help;
-  d_typeMap[var]="Switch";
+  helpmap[var] = help;
+  d_typeMap[var] = "Switch";
   return set(var);
 }
 
-
-bool ArgvMap::contains(const string &var, const string &val)
+bool ArgvMap::contains(const string& var, const string& val)
 {
   const auto& param = d_params.find(var);
-  if(param == d_params.end() || param->second.empty())  {
+  if (param == d_params.end() || param->second.empty()) {
     return false;
   }
   vector<string> parts;
 
   stringtok(parts, param->second, ", \t");
-  for (const auto& part: parts) {
+  for (const auto& part : parts) {
     if (part == val) {
       return true;
     }
@@ -123,38 +122,35 @@ bool ArgvMap::contains(const string &var, const string &val)
 
 string ArgvMap::helpstring(string prefix)
 {
-  if(prefix=="no")
-    prefix="";
+  if (prefix == "no")
+    prefix = "";
 
   string help;
 
-  for (const auto& i: helpmap) {
-      if(!prefix.empty() && i.first.find(prefix) != 0) // only print items with prefix
-          continue;
-
-      help+="  --";
-      help+=i.first;
-
-      string type=d_typeMap[i.first];
-
-      if(type=="Parameter")
-        help+="=...";
-      else if(type=="Switch")
-        {
-          help+=" | --"+i.first+"=yes";
-          help+=" | --"+i.first+"=no";
-        }
+  for (const auto& i : helpmap) {
+    if (!prefix.empty() && i.first.find(prefix) != 0) // only print items with prefix
+      continue;
 
+    help += "  --";
+    help += i.first;
 
-      help+="\n\t";
-      help+=i.second;
-      help+="\n";
+    string type = d_typeMap[i.first];
 
+    if (type == "Parameter")
+      help += "=...";
+    else if (type == "Switch") {
+      help += " | --" + i.first + "=yes";
+      help += " | --" + i.first + "=no";
     }
+
+    help += "\n\t";
+    help += i.second;
+    help += "\n";
+  }
   return help;
 }
 
-const string ArgvMap::formatOne(bool running, bool full, const string &var, const string &help, const string& theDefault, const string& current)
+const string ArgvMap::formatOne(bool running, bool full, const string& var, const string& help, const string& theDefault, const string& current)
 {
   string out;
 
@@ -165,13 +161,14 @@ const string ArgvMap::formatOne(bool running, bool full, const string &var, cons
     out += "\t";
     out += help;
     out += "\n#\n";
-  } else {
+  }
+  else {
     if (theDefault == current) {
       return "";
     }
   }
 
-  if (! running || theDefault == current) {
+  if (!running || theDefault == current) {
     out += "# ";
   }
 
@@ -180,7 +177,8 @@ const string ArgvMap::formatOne(bool running, bool full, const string &var, cons
     if (full) {
       out += "\n";
     }
-  } else {
+  }
+  else {
     out += var + "=" + theDefault + "\n\n";
   }
 
@@ -193,28 +191,28 @@ string ArgvMap::configstring(bool running, bool full)
   string help;
 
   if (running)
-    help="# Autogenerated configuration file based on running instance ("+nowTime()+")\n\n";
+    help = "# Autogenerated configuration file based on running instance (" + nowTime() + ")\n\n";
   else
-    help="# Autogenerated configuration file template\n\n";
+    help = "# Autogenerated configuration file template\n\n";
 
   // Affects parsing, should come first.
   help += formatOne(running, full, "ignore-unknown-settings", helpmap["ignore-unknown-settings"], defaultmap["ignore-unknown-settings"], d_params["ignore-unknown-settings"]);
 
-  for(const auto& i: helpmap) {
+  for (const auto& i : helpmap) {
     if (d_typeMap[i.first] == "Command")
       continue;
     if (i.first == "ignore-unknown-settings")
       continue;
 
     if (!defaultmap.count(i.first)) {
-      throw ArgException(string("Default for setting '")+i.first+"' not set");
+      throw ArgException(string("Default for setting '") + i.first + "' not set");
     }
 
     help += formatOne(running, full, i.first, i.second, defaultmap[i.first], d_params[i.first]);
   }
 
   if (running) {
-    for(const auto& i: d_unknownParams) {
+    for (const auto& i : d_unknownParams) {
       help += formatOne(running, full, i.first, "unknown setting", "", i.second);
     }
   }
@@ -222,142 +220,142 @@ string ArgvMap::configstring(bool running, bool full)
   return help;
 }
 
-const string & ArgvMap::operator[](const string &arg)
+const string& ArgvMap::operator[](const string& arg)
 {
-  if(!parmIsset(arg))
-    throw ArgException(string("Undefined but needed argument: '")+arg+"'");
+  if (!parmIsset(arg))
+    throw ArgException(string("Undefined but needed argument: '") + arg + "'");
 
   return d_params[arg];
 }
 
-mode_t ArgvMap::asMode(const string &arg)
+mode_t ArgvMap::asMode(const string& arg)
 {
   mode_t mode;
-  const char *cptr_orig;
-  char *cptr_ret = nullptr;
+  const char* cptr_orig;
+  char* cptr_ret = nullptr;
 
-  if(!parmIsset(arg))
-   throw ArgException(string("Undefined but needed argument: '")+arg+"'");
+  if (!parmIsset(arg))
+    throw ArgException(string("Undefined but needed argument: '") + arg + "'");
 
   cptr_orig = d_params[arg].c_str();
   mode = static_cast<mode_t>(strtol(cptr_orig, &cptr_ret, 8));
   if (mode == 0 && cptr_ret == cptr_orig)
     throw ArgException("'" + arg + string("' contains invalid octal mode"));
-   return mode;
+  return mode;
 }
 
-gid_t ArgvMap::asGid(const string &arg)
+gid_t ArgvMap::asGid(const string& arg)
 {
   gid_t gid;
-  const char *cptr_orig;
-  char *cptr_ret = nullptr;
+  const char* cptr_orig;
+  char* cptr_ret = nullptr;
 
-  if(!parmIsset(arg))
-   throw ArgException(string("Undefined but needed argument: '")+arg+"'");
+  if (!parmIsset(arg))
+    throw ArgException(string("Undefined but needed argument: '") + arg + "'");
 
   cptr_orig = d_params[arg].c_str();
   gid = static_cast<gid_t>(strtol(cptr_orig, &cptr_ret, 0));
   if (gid == 0 && cptr_ret == cptr_orig) {
     // try to resolve
-    struct group *group = getgrnam(d_params[arg].c_str());
+    struct group* group = getgrnam(d_params[arg].c_str());
     if (group == nullptr)
-     throw ArgException("'" + arg + string("' contains invalid group"));
+      throw ArgException("'" + arg + string("' contains invalid group"));
     gid = group->gr_gid;
-   }
-   return gid;
+  }
+  return gid;
 }
 
-uid_t ArgvMap::asUid(const string &arg)
+uid_t ArgvMap::asUid(const string& arg)
 {
   uid_t uid;
-  const char *cptr_orig;
-  char *cptr_ret = nullptr;
+  const char* cptr_orig;
+  char* cptr_ret = nullptr;
 
-  if(!parmIsset(arg))
-   throw ArgException(string("Undefined but needed argument: '")+arg+"'");
+  if (!parmIsset(arg))
+    throw ArgException(string("Undefined but needed argument: '") + arg + "'");
 
   cptr_orig = d_params[arg].c_str();
   uid = static_cast<uid_t>(strtol(cptr_orig, &cptr_ret, 0));
   if (uid == 0 && cptr_ret == cptr_orig) {
     // try to resolve
-    struct passwd *pwent = getpwnam(d_params[arg].c_str());
+    struct passwd* pwent = getpwnam(d_params[arg].c_str());
     if (pwent == nullptr)
-     throw ArgException("'" + arg + string("' contains invalid group"));
+      throw ArgException("'" + arg + string("' contains invalid group"));
     uid = pwent->pw_uid;
-   }
-   return uid;
+  }
+  return uid;
 }
 
-int ArgvMap::asNum(const string &arg, int def)
+int ArgvMap::asNum(const string& arg, int def)
 {
   int retval;
-  const char *cptr_orig;
-  char *cptr_ret = nullptr;
+  const char* cptr_orig;
+  char* cptr_ret = nullptr;
 
-  if(!parmIsset(arg))
-    throw ArgException(string("Undefined but needed argument: '")+arg+"'");
+  if (!parmIsset(arg))
+    throw ArgException(string("Undefined but needed argument: '") + arg + "'");
 
   // use default for empty values
   if (d_params[arg].empty())
-   return def;
+    return def;
 
   cptr_orig = d_params[arg].c_str();
   retval = static_cast<int>(strtol(cptr_orig, &cptr_ret, 0));
   if (!retval && cptr_ret == cptr_orig)
-   throw ArgException("'"+arg+"' value '"+string(cptr_orig) + string( "' is not a valid number"));
+    throw ArgException("'" + arg + "' value '" + string(cptr_orig) + string("' is not a valid number"));
 
   return retval;
 }
 
-bool ArgvMap::isEmpty(const string &arg)
+bool ArgvMap::isEmpty(const string& arg)
 {
-   if(!parmIsset(arg))
+  if (!parmIsset(arg))
     return true;
-   return d_params[arg].empty();
+  return d_params[arg].empty();
 }
 
-double ArgvMap::asDouble(const string &arg)
+double ArgvMap::asDouble(const string& arg)
 {
   double retval;
-  const char *cptr_orig;
-  char *cptr_ret = nullptr;
+  const char* cptr_orig;
+  char* cptr_ret = nullptr;
 
-  if(!parmIsset(arg))
-    throw ArgException(string("Undefined but needed argument: '")+arg+"'");
+  if (!parmIsset(arg))
+    throw ArgException(string("Undefined but needed argument: '") + arg + "'");
 
   if (d_params[arg].empty())
-   return 0.0;
+    return 0.0;
 
   cptr_orig = d_params[arg].c_str();
   retval = strtod(cptr_orig, &cptr_ret);
 
   if (retval == 0 && cptr_ret == cptr_orig)
-   throw ArgException("'"+arg+string("' is not valid double"));
+    throw ArgException("'" + arg + string("' is not valid double"));
 
   return retval;
 }
 
 ArgvMap::ArgvMap()
 {
-  set("ignore-unknown-settings","Configuration settings to ignore if they are unknown")="";
+  set("ignore-unknown-settings", "Configuration settings to ignore if they are unknown") = "";
 }
 
-bool ArgvMap::parmIsset(const string &var)
+bool ArgvMap::parmIsset(const string& var)
 {
   return d_params.find(var) != d_params.end();
 }
 
 // ATM Shared between Recursor and Auth, is that a good idea?
-static const map<string,string> deprecateList = {
-  { "stats-api-blacklist", "stats-api-disabled-list" },
-  { "stats-carbon-blacklist", "stats-carbon-disabled-list" },
-  { "stats-rec-control-blacklist", "stats-rec-control-disabled-list" },
-  { "stats-snmp-blacklist", "stats-snmp-disabled-list" },
-  { "edns-subnet-whitelist", "edns-subnet-allow-list" },
-  { "new-domain-whitelist", "new-domain-ignore-list" },
-  { "snmp-master-socket", "snmp-daemon-socket" },
-  { "xpf-allow-from", "Proxy Protocol" },
-  { "xpf-rr-code", "Proxy Protocol" },
+static const map<string, string> deprecateList = {
+  {"stats-api-blacklist", "stats-api-disabled-list"},
+  {"stats-carbon-blacklist", "stats-carbon-disabled-list"},
+  {"stats-rec-control-blacklist", "stats-rec-control-disabled-list"},
+  {"stats-snmp-blacklist", "stats-snmp-disabled-list"},
+  {"edns-subnet-whitelist", "edns-subnet-allow-list"},
+  {"new-domain-whitelist", "new-domain-ignore-list"},
+  {"snmp-master-socket", "snmp-daemon-socket"},
+  {"xpf-allow-from", "Proxy Protocol"},
+  {"xpf-rr-code", "Proxy Protocol"},
 };
 
 void ArgvMap::warnIfDeprecated(const string& var)
@@ -369,102 +367,96 @@ void ArgvMap::warnIfDeprecated(const string& var)
   }
 }
 
-void ArgvMap::parseOne(const string &arg, const string &parseOnly, bool lax)
+void ArgvMap::parseOne(const string& arg, const string& parseOnly, bool lax)
 {
   string var, val;
   string::size_type pos;
   bool incremental = false;
 
-  if(arg.find("--") == 0 && (pos=arg.find("+="))!=string::npos) // this is a --port+=25 case
+  if (arg.find("--") == 0 && (pos = arg.find("+=")) != string::npos) // this is a --port+=25 case
   {
-    var=arg.substr(2,pos-2);
-    val=arg.substr(pos+2);
+    var = arg.substr(2, pos - 2);
+    val = arg.substr(pos + 2);
     incremental = true;
   }
-  else if(arg.find("--") == 0 && (pos=arg.find('='))!=string::npos)  // this is a --port=25 case
+  else if (arg.find("--") == 0 && (pos = arg.find('=')) != string::npos) // this is a --port=25 case
   {
-    var=arg.substr(2,pos-2);
-    val=arg.substr(pos+1);
+    var = arg.substr(2, pos - 2);
+    val = arg.substr(pos + 1);
   }
-  else if(arg.find("--") == 0 && (arg.find('=')==string::npos))  // this is a --daemon case
+  else if (arg.find("--") == 0 && (arg.find('=') == string::npos)) // this is a --daemon case
   {
-    var=arg.substr(2);
-    val="";
+    var = arg.substr(2);
+    val = "";
   }
-  else if(arg[0]=='-' && arg.length() > 1)
-  {
-    var=arg.substr(1);
-    val="";
+  else if (arg[0] == '-' && arg.length() > 1) {
+    var = arg.substr(1);
+    val = "";
   }
   else // command
     d_cmds.push_back(arg);
 
   boost::trim(var);
 
-  if(var!="" && (parseOnly.empty() || var==parseOnly)) {
+  if (var != "" && (parseOnly.empty() || var == parseOnly)) {
     if (!lax) {
       warnIfDeprecated(var);
     }
-    pos=val.find_first_not_of(" \t");  // strip leading whitespace
-    if(pos && pos!=string::npos)
-      val=val.substr(pos);
-    if(parmIsset(var))
-    {
-      if(incremental)
-      {
-        if(d_params[var].empty())
-        {
-          if(!d_cleared.count(var))
-            throw ArgException("Incremental setting '"+var+"' without a parent");
+    pos = val.find_first_not_of(" \t"); // strip leading whitespace
+    if (pos && pos != string::npos)
+      val = val.substr(pos);
+    if (parmIsset(var)) {
+      if (incremental) {
+        if (d_params[var].empty()) {
+          if (!d_cleared.count(var))
+            throw ArgException("Incremental setting '" + var + "' without a parent");
           d_params[var] = val;
         }
         else
           d_params[var] += ", " + val;
       }
-      else
-      {
+      else {
         d_params[var] = val;
         d_cleared.insert(var);
       }
     }
-    else
-    {
+    else {
       // unknown setting encountered. see if its on the ignore list before throwing.
       vector<string> parts;
       stringtok(parts, d_params["ignore-unknown-settings"], " ,\t\n\r");
       if (find(parts.begin(), parts.end(), var) != parts.end()) {
         d_unknownParams[var] = val;
-        SLOG(g_log<<Logger::Warning<<"Ignoring unknown setting '"<<var<<"' as requested"<<endl,
+        SLOG(g_log << Logger::Warning << "Ignoring unknown setting '" << var << "' as requested" << endl,
              d_log->info(Logr::Warning, "Ignoring unknown setting as requested", "name", Logging::Loggable(var)));
         return;
       }
 
       if (!lax) {
-        throw ArgException("Trying to set unknown setting '"+var+"'");
+        throw ArgException("Trying to set unknown setting '" + var + "'");
       }
     }
   }
 }
 
-const vector<string>&ArgvMap::getCommands()
+const vector<string>& ArgvMap::getCommands()
 {
   return d_cmds;
 }
 
-void ArgvMap::parse(int &argc, char **argv, bool lax)
+void ArgvMap::parse(int& argc, char** argv, bool lax)
 {
   d_cmds.clear();
   d_cleared.clear();
-  for(int n=1;n<argc;n++) {
-    parseOne(argv[n],"",lax);
+  for (int n = 1; n < argc; n++) {
+    parseOne(argv[n], "", lax);
   }
 }
 
-void ArgvMap::preParse(int &argc, char **argv, const string &arg)
+void ArgvMap::preParse(int& argc, char** argv, const string& arg)
 {
-  for(int n=1;n<argc;n++) {
-    string varval=argv[n];
-    if(varval.find("--"+arg) == 0)
+  for (int n = 1; n < argc; n++) {
+    string varval = argv[n];
+    if (varval.find("--" + arg) == 0)
       parseOne(argv[n]);
   }
 }
@@ -517,7 +509,7 @@ bool ArgvMap::parseFile(const char* fname, const string& arg, bool lax)
   return true;
 }
 
-bool ArgvMap::preParseFile(const char *fname, const string &arg, const string& theDefault)
+bool ArgvMap::preParseFile(const char* fname, const string& arg, const string& theDefault)
 {
   d_params[arg] = theDefault;
 
@@ -557,12 +549,13 @@ bool ArgvMap::file(const char* fname, bool lax, bool included)
   return true;
 }
 
-void ArgvMap::gatherIncludes(std::vector<std::string> &extraConfigs) {
+void ArgvMap::gatherIncludes(std::vector<std::string>& extraConfigs)
+{
   extraConfigs.clear();
   if (d_params["include-dir"].empty())
     return; // nothing to do
 
-  DIR *dir;
+  DIR* dir;
   if (!(dir = opendir(d_params["include-dir"].c_str()))) {
     int err = errno;
     string msg = d_params["include-dir"] + " is not accessible: " + strerror(err);
@@ -571,7 +564,7 @@ void ArgvMap::gatherIncludes(std::vector<std::string> &extraConfigs) {
     throw ArgException(msg);
   }
 
-  struct dirent *ent;
+  struct dirent* ent;
   while ((ent = readdir(dir)) != nullptr) {
     if (ent->d_name[0] == '.')
       continue; // skip any dots
diff --git a/pdns/arguments.hh b/pdns/arguments.hh
index a242fd0d4b..402608220a 100644
--- a/pdns/arguments.hh
+++ b/pdns/arguments.hh
@@ -71,54 +71,52 @@ typedef PDNSException ArgException;
     \endcode
 */
 
-
-
 class ArgvMap
 {
 public:
   ArgvMap();
-  void parse(int &argc, char **argv, bool lax=false); //!< use this to parse from argc and argv
-  void laxParse(int &argc, char **argv) //!< use this to parse from argc and argv
+  void parse(int& argc, char** argv, bool lax = false); //!< use this to parse from argc and argv
+  void laxParse(int& argc, char** argv) //!< use this to parse from argc and argv
   {
-    parse(argc,argv,true);
+    parse(argc, argv, true);
   }
-  void preParse(int &argc, char **argv, const string &arg); //!< use this to preparse a single var
-  bool preParseFile(const char *fname, const string &arg, const string& theDefault=""); //!< use this to preparse a single var in configuration
+  void preParse(int& argc, char** argv, const string& arg); //!< use this to preparse a single var
+  bool preParseFile(const char* fname, const string& arg, const string& theDefault = ""); //!< use this to preparse a single var in configuration
 
   bool file(const char* fname, bool lax = false); //!< Parses a file with parameters
   bool file(const char* fname, bool lax, bool included);
-  bool laxFile(const char *fname)
+  bool laxFile(const char* fname)
   {
-    return file(fname,true);
+    return file(fname, true);
   }
-  bool parseFile(const char *fname, const string& arg, bool lax); //<! parse one line
-  typedef map<string,string> param_t; //!< use this if you need to know the content of the map
-  bool parmIsset(const string &var); //!< Checks if a parameter is set to *a* value
-  bool mustDo(const string &var); //!< if a switch is given, if we must do something (--help)
-  int asNum(const string &var, int def=0); //!< return a variable value as a number or the default if the variable is empty
-  mode_t asMode(const string &var); //!< return value interpreted as octal number
-  uid_t asUid(const string &var); //!< return user id, resolves if necessary
-  gid_t asGid(const string &var); //!< return group id, resolves if necessary
-  double asDouble(const string &var); //!< return a variable value as a number
-  string &set(const string &); //!< Gives a writable reference and allocates space for it
-  string &set(const string &, const string &); //!< Does the same but also allows one to specify a help message
-  void setCmd(const string &, const string &); //!< Add a command flag
-  string &setSwitch(const string &, const string &); //!< Add a switch flag
-  string helpstring(string prefix=""); //!< generates the --help
+  bool parseFile(const char* fname, const string& arg, bool lax); //<! parse one line
+  typedef map<string, string> param_t; //!< use this if you need to know the content of the map
+  bool parmIsset(const string& var); //!< Checks if a parameter is set to *a* value
+  bool mustDo(const string& var); //!< if a switch is given, if we must do something (--help)
+  int asNum(const string& var, int def = 0); //!< return a variable value as a number or the default if the variable is empty
+  mode_t asMode(const string& var); //!< return value interpreted as octal number
+  uid_t asUid(const string& var); //!< return user id, resolves if necessary
+  gid_t asGid(const string& var); //!< return group id, resolves if necessary
+  double asDouble(const string& var); //!< return a variable value as a number
+  string& set(const string&); //!< Gives a writable reference and allocates space for it
+  string& set(const string&, const string&); //!< Does the same but also allows one to specify a help message
+  void setCmd(const string&, const string&); //!< Add a command flag
+  string& setSwitch(const string&, const string&); //!< Add a switch flag
+  string helpstring(string prefix = ""); //!< generates the --help
   string configstring(bool current, bool full); //!< generates the --config
-  bool contains(const string &var, const string &val);
-  bool isEmpty(const string &var); //!< checks if variable has value
-  void setDefault(const string &var, const string &value);
+  bool contains(const string& var, const string& val);
+  bool isEmpty(const string& var); //!< checks if variable has value
+  void setDefault(const string& var, const string& value);
   void setDefaults();
 
-  vector<string>list();
-  string getHelp(const string &item);
+  vector<string> list();
+  string getHelp(const string& item);
 
   const param_t::const_iterator begin(); //!< iterator semantics
   const param_t::const_iterator end(); //!< iterator semantics
-  const string &operator[](const string &); //!< iterator semantics
-  const vector<string>&getCommands();
-  void gatherIncludes(std::vector<std::string> &extraConfigs);
+  const string& operator[](const string&); //!< iterator semantics
+  const vector<string>& getCommands();
+  void gatherIncludes(std::vector<std::string>& extraConfigs);
 #ifdef RECURSOR
   void setSLog(Logr::log_t log)
   {
@@ -127,13 +125,13 @@ public:
 #endif
 private:
   void warnIfDeprecated(const string& var);
-  void parseOne(const string &unparsed, const string &parseOnly="", bool lax=false);
-  const string formatOne(bool running, bool full, const string &var, const string &help, const string& theDefault, const string& value);
-  map<string,string> d_params;
-  map<string,string> d_unknownParams;
-  map<string,string> helpmap;
-  map<string,string> defaultmap;
-  map<string,string> d_typeMap;
+  void parseOne(const string& unparsed, const string& parseOnly = "", bool lax = false);
+  const string formatOne(bool running, bool full, const string& var, const string& help, const string& theDefault, const string& value);
+  map<string, string> d_params;
+  map<string, string> d_unknownParams;
+  map<string, string> helpmap;
+  map<string, string> defaultmap;
+  map<string, string> d_typeMap;
   vector<string> d_cmds;
   std::set<string> d_cleared;
 #ifdef RECURSOR
@@ -141,4 +139,4 @@ private:
 #endif
 };
 
-extern ArgvMap &arg();
+extern ArgvMap& arg();