Usage.h

Go to the documentation of this file.

#ifndef   MEOW_USAGE_H__
#define   MEOW_USAGE_H__

#include "utility.h"

#include <cstdlib>

#include <string>
#include <vector>
#include <map>

namespace meow {
class Usage {
private:
  typedef std::string         String;
  typedef std::vector<String> Strings;
  class Value {
  private:
    String       value_;
    String description_;
  public:
    Value() { }
    Value(String const& value, String const& description) {
      value_       = value;
      description_ = stringReplace(description, "<value>", value);
    }
    String usage() const {
      return stringPrintf("%8s%s : %s\n",
                          " ", value_.c_str(), description_.c_str());
    }
    String value() const {
      return value_;
    }
    bool operator==(Value const& b) const {
      return (value_ == b.value_);
    }
  };
  typedef std::vector<Value> Values;
  class Option {
  private:
    Strings values_;
    Values  values_accept_;
    String  value_default_;
    String  value_type_;
    String  description_;
    bool  has_value_;
    bool  has_setup_;
    bool must_setup_;
  public:
    Option() {
    }
    Option(String const& description) {
      has_setup_   = false;
      has_value_   = false;
      description_ = description;
      must_setup_  = false;
    }
    Option(String const& description,
           String const& type,
           String const& default_value,
           bool          must) {
      has_setup_     = false;
      has_value_     = true;
      description_   = description;
      value_type_    = type;
      value_default_ = default_value;
      must_setup_    = must;
    }
    Strings const& values() const {
      return values_;
    }
    String value(size_t index) const {
      if (!has_value_) return "";
      if (!has_setup_ || index >= values_.size()) return value_default_;
      return values_[index];
    }
    ssize_t valueAdd(String const& value) {
      if (!has_value_) {
        has_setup_ = true;
        return 0;
      }
      if (values_accept_.size() > 0 &&
          std::find(values_accept_.begin(), values_accept_.end(),
                    Value(value, "")) == values_accept_.end())
        return -1;
      values_.push_back(value);
      has_setup_ = true;
      return values_.size() - 1;
    }
    bool valueAcceptAdd(String const& value, String const& description) {
      if (!has_value_) return false;
      if (std::find(values_accept_.begin(), values_accept_.end(),
                    Value(value, "")) == values_accept_.end()) {
        values_accept_.push_back(Value(value, description));
      }
      return true;
    }
    bool valueAcceptChk(String const& value) {
      if (!has_value_) return false;
      return (values_accept_.empty() ||
              std::find(values_accept_.begin(), values_accept_.end(),
                        Value(value, "")) != values_accept_.end());
    }
    bool hasSetup() const{ return has_setup_; }
    bool hasValue() const{ return has_value_; }
    bool chkSetup() const{ return !(must_setup_ && !has_setup_); }

    String usage(String opt, bool detail) const {
      String ret(stringPrintf("%s%s ", (opt.size() > 1 ? "--" : "-"), opt));
      if (!detail) {
        if (has_value_) ret += value_type_;
        if (!must_setup_) ret = "[" + ret + "]";
      }
      else {
        if (has_value_) {
          ret += value_type_ + " ";
          String default_string("");
          if (value_default_ != "")
            default_string = "defalut='" + value_default_ + "'";
          String optional_string("");
          if (!must_setup_)
            optional_string = "optional";
          String tmp;
          if (default_string.size() + optional_string.size() > 0) {
            if (default_string.size() > 0 && optional_string.size() > 0) {
              ret += "(" + optional_string + ", " + default_string + ")";
            }
            else {
              ret += "(" + optional_string + default_string + ")";
            }
          }
        }
        ret += "\n";
        String accept_string;
        for (size_t i = 0; i < values_accept_.size(); i++) {
          if (i > 0)
            accept_string += (i + 1 < values_accept_.size() ? ", " : " or ");
          accept_string += "'" + values_accept_[i].value() + "'";
        }
        if (accept_string.size() == 0) accept_string = "... (anything)";
        ret += "        " + stringReplace(stringReplace(description_,
                                                        "<type>",
                                                        value_type_),
                                          "<values>",
                                          accept_string) + "\n";
        for (size_t i = 0; i < values_accept_.size(); i++) {
          ret += values_accept_[i].usage();
        }
        ret += "\n";
      }
      return ret;
    }
  };
  typedef std::map<String, Option> Options;
  typedef Options::      iterator  OptionsIterator;
  typedef Options::const_iterator  OptionsIteratorK;

  String            name_;
  Options        options_;
  Strings    usage_begin_;
  Strings      usage_end_;
  Strings proc_arguments_;
public:
  Usage() {
  }

  Usage(String const& name) {
    name_ = name;
  }


  Usage(Usage const& usage) {
    name_           = usage.name_;
    options_        = usage.options_;
    longOptions_    = usage.long_options_;
    usage_begin_    = usage.usage_begin_;
    usage_end_      = usage.usage_end_;
    proc_arguments_ = usage.proc_arguments_;
  }

  bool import(Usage const& usage) {
    for (OptionsIteratorK
         it = usage.options_.begin(); it != usage.options_.end(); ++it) {
      if (options_.find(it->first) != options_.end())
        return false;
    }
    for (OptionsIteratorK
         it = usage.options_.begin(); it != usage.options_.end(); ++it) {
      options_.insert(std::pair<String, Option>(it->first, it->second));
    }
    for (size_t i = 0; i < usage.usage_begin_.size(); ++i)
      usage_begin_.push_back(usage.usage_begin_[i]);
    for (size_t i = 0; i < usage.usage_end_.size(); ++i)
      usage_end_.push_back(usage.usage_end_[i]);
    return true;
  }

  bool update(Usage const& usage) {
    for (OptionsIteratorK
         it = usage.options_.begin(); it != usage.options_.end(); ++it) {
      OptionsIterator my = options_.find(it->first);
      if (my == options_.end()) continue;
      for (size_t i = 0, I = it->second.values().size(); i < I; ++i) {
        my->second.valueAdd(it->second.value(i));
      }
    }
    return true;
  }

  bool optionAdd(String opt, String const& des) {
    if (options_.find(opt) != options_.end()) return false;
    options_.insert(std::pair<String, Option>(opt, Option(des));
    return true;
  }

  bool optionAdd(String opt, String const& des,
                 String const& val_type,
                 String const& val_default,
                 bool must) {
    if (options_.find(opt) != options_.end()) return false;
    options_.insert(std::pair<String, Option>(
        opt, Option(des, val_type, val_defalut, must)));
    return true;
  }

  bool optionValueAcceptAdd(String opt, String const& val, String const& des) {
    OptionsIterator o = options_.find(opt);
    if (o == options_.end()) return false;
    return o->second.valueAcceptAdd(val, des);
  }

  bool hasOptionSetup(String opt) const {
    OptionsIteratorK o = options_.find(opt);
    return (o != options_.end() && o->second.hasSetup());
  }

  size_t optionValuesSize(String opt) const {
    OptionsIteratorK o = options_.find(opt);
    if (o == options_.end()) return 0;
    return o->second.values().size();
  }

  String optionValue(String opt, size_t index) const {
    OptionsIteratorK o = options_.find(opt);
    if (o == options_.end()) return String();
    return o->second.value(index);
  }

  size_t procArgsSize() const {
    return proc_arguments_.size();
  }

  String procArg(size_t index) const {
    if (index >= proc_arguments_.size()) {
      return String();
    }
    return proc_arguments_[index];
  }

  Strings const& procArgs() const{
    return proc_arguments_;
  }

  void usageBeginAdd(String const& des) {
    usage_begin_.push_back(stringReplace(des, "<name>", name_));
  }

  void usageEndAdd(String const& des) {
    usage_end_.push_back(stringReplace(des, "<name>", name_));
  }

  String usage() const{
    Usage::String out = stringPrintf("USAGE\n    %s", name_.c_str());
    for (OptionsIterator
         it = options_.begin(); it != options_.end(); ++it)
      out += " " + it->second.usage(it->first, false);
    out += "\n\nDESCRIPTION\n";
    for (size_t i = 0; i < usage_begin_.size(); ++i) {
      out += "    " + usage_begin_[i] + "\n\n";
    }
    for (OptionsIteratorK
         it = options_.begin(); it != options_.end(); ++it) {
      out += it->second.usage(it->first, true);
    }
    for (size_t i = 0; i < usage_end_.size(); ++i) {
      out += "    " + usage_end_[i] + "\n\n";
    }
    return out;
  }

  bool arguments(int argc, char** argv, String* errmsg) {
    String  zzz;
    String& err = (errmsg == NULL ? zzz : *errmsg);
    for (int i = 0; i < argc; ++i) {
      if (argv[i][0] == '-') {
        String opt;
        if (argv[i][1] == '-') { // long option
          if (argv[i][2] == '\0' || argv[i][3] == '\0') {
            err = stringPrintf("Invalid option '%s'", argv[i]);
            return false;
          }
          opt = String(argv[i] + 2);
        }
        else { // short option
          if (argv[i][1] == '\0' || argv[i][2] != '\0') {
            err = stringPrintf("Invalid option '%s'", argv[i]);
            return false;
          }
          opt = String(argv[i] + 1);
        }
        OptionsIterator o = options_.find(opt);
        if (o == options_.end()) {
          err = stringPrintf("Unknown option '%s'", argv[i]);
          return false;
        }
        if (o->second.hasValue()) {
          if (i + 1 >= argc) {
            err = stringPrintf("Option '%s' need a value", argv[i]);
            return false;
          }
          if (o->second.valueAdd(argv[i + 1]) == false) {
            err = stringPrintf("Invalid value '%s' of options '%s'",
                               argv[i + 1], argv[i]);
            return false;
          }
          ++i;
        }
        else {
          o->second.valueAdd("");
        }
      }
      else {
        proc_arguments_.push_back(String(argv[i] + (argv[i][0]=='\\' ? 1:0)));
      }
    }
    for (OptionsIteratorK it = options_.begin(); it != options_.end(); ++it) {
      if (it->second.chkSetup() == false) {
        err += stringPrintf("No specify argument to '%s%s'\n",
                            (it->first.size() > 1 ? "--" : "-"), it->first);
        return false;
      }
    }
    return true;
  }
};

} // meow

#endif // MEOW_USAGE_H__