CommandLine.h

Go to the documentation of this file.

#ifndef MUTILS_COMMANDLINE_H
#define MUTILS_COMMANDLINE_H

#include <cctype>
#include "mutils/util.h"

namespace mutils {

// Forward reference.
class Options;

class CommandLine
{
public:
  typedef std::vector<std::string> Arguments;

  struct Option {
    char        shortName;  
    std::string longName;   
    std::string valueName;  
    std::string scopeName;  
    std::string sectName;   
    std::string keyName;    
    std::string helpText;   

    std::string keyword() const {
      std::string shortStr(1, shortName);
      std::string key = (!keyName.empty() ? keyName  :
                         longName.empty() ? shortStr : longName);
      if (keyName == nullStr || keyName.empty()) {
        std::string::size_type pos = 0;
        while (pos < key.size()) {
          key[pos] = toupper(key[pos]);
          pos = key.find_first_of('-', pos);
          if (pos != npos) { key.erase(pos, 1); }
        }
      }
      return key;
    }

    std::string source() const {
      std::string src = "CommandLine[";
      if (! longName.empty()) {
        src += "--";
        src += longName;
      } else {
        src += '-';
        src += toupper(shortName);
      }
      src += ']';
      return src;
    }
  };

  CommandLine() : validOpts_(nullptr) { }

  ~CommandLine() { }

  void init(int argc, char *argv[], const std::vector<Option> *opts);

  const std::string& driver() const { return driver_; }

  const Arguments& arguments() const { return args_; }

  unsigned getOption(const Option &option, Arguments *values = nullptr,
                     unsigned nMax = -1) const;

  unsigned getOption(char shortName, Arguments *values = nullptr,
                     unsigned nMax = -1) const;

  unsigned getOption(const std::string &longName,
                     Arguments *values = nullptr,
                     unsigned nMax = -1) const;

  size_t popOption(const Option &option);

  size_t popOption(char shortName);

  size_t popOption(const std::string &longName);

  long getInteger(char shortName) const;

  long getInteger(char shortName, long defValue) const;

  double getDouble(char shortName, double defValue) const;

  std::string getString(char shortName, const std::string &defValue) const;

  void merge(Options &options) const;

  void usage(FILE *f, const std::vector<Option> &opts,
             const char *args = "",
             bool quiet = false, bool basename = true) const;

private:
  typedef std::multimap<char, std::string> ShortMap;

  typedef std::multimap<std::string, std::string> LongMap;

  bool parseShort(const char *name, const char *next);

  bool parseLong(const char *name, const char *next);

  const std::vector<Option> *validOpts_;

  ShortMap shortOpts_;

  LongMap longOpts_;

  std::string driver_;

  Arguments args_;
};

}  // namespace mutils

#endif  // MUTILS_COMMANDLINE_H