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>
#include <algorithm>

extern "C" {
#include <unistd.h>
}

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;
      if (values_accept_.size() == 0) return true;
      return (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(unsigned char opt, bool detail) const {
      String ret(stringPrintf("-%c ", 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<unsigned char, Option> Options;
  typedef Options::const_iterator OptionsIterator;
  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_;
    usage_begin_    = usage.usage_begin_;
    usage_end_      = usage.usage_end_;
    proc_arguments_ = usage.proc_arguments_;
  }

  bool import(Usage const& usage) {
    for (OptionsIterator
         it = usage.options_.begin(); it != usage.options_.end(); ++it) {
      if (options_.find(it->first) != options_.end())
        return false;
    }
    for (OptionsIterator
         it = usage.options_.begin(); it != usage.options_.end(); ++it) {
      options_[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 (OptionsIterator
         it = usage.options_.begin(); it != usage.options_.end(); ++it) {
      if (options_.find(it->first) == options_.end()) continue;
      for(size_t i = 0, I = it->second.values().size(); i < I; i++){
        options_[it->first].valueAdd(it->second.value(i));
      }
    }
    return true;
  }

  bool optionAdd(unsigned char opt, String const& des) {
    if (options_.find(opt) != options_.end()) return false;
    options_[opt] = Option(des);
    return true;
  }

  bool optionAdd(unsigned char opt, String const& des,
                 String const& val_type,
                 String const& val_default,
                 bool must) {
    if (options_.find(opt) != options_.end()) return false;
    options_[opt] = Option(des, val_type, val_default, must);
    return true;
  }

  bool optionValueAcceptAdd(unsigned char opt,
                            String const& val,
                            String const& des) {
    if (options_.find(opt) == options_.end()) return false;
    return options_[opt].valueAcceptAdd(val, des);
  }

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

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

  String optionValue(unsigned char opt, size_t index) const {
    if (options_.find(opt) == options_.end()) {
      return String();
    }
    return options_.find(opt)->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 (OptionsIterator
         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){
    opterr = 0;
    String s;
    OptionsIterator it;
    String zzz;
    String& err = (errmsg == NULL ? zzz : *errmsg);
    for (it = options_.begin(); it != options_.end(); ++it) {
      s += (char)(it->first);
      if (it->second.hasValue()) s += ":";
    }
    bool succ = true;
    for (int opt; (opt = getopt(argc, argv, s.c_str())) != -1; ) {
      if (options_.find(opt) == options_.end()) {
        if(options_.find(optopt) == options_.end()){
          err += stringPrintf("Unknown option '-%c'\n", optopt);
        }else{
          err += stringPrintf("No specify argument to '-%c'\n",
                              optopt);
        }
        succ = false;
        continue;
      }
      if (options_[opt].valueAdd(optarg == NULL ? "" : optarg) < 0) {
        err += stringPrintf("Option argument '%s' to '-%c' is not allowed\n"
                            , optarg, opt);
        succ = false;
        continue;
      }
    }
    for (it = options_.begin(); it != options_.end(); it++) {
      if (it->second.chkSetup() == false) {
        err += stringPrintf("No specify argument to '-%c'\n",
                            it->first);
        succ = false;
        continue;
      }
    }
    for (int i = optind; i < argc; i++) {
      proc_arguments_.push_back(String(argv[i]));
    }
    return succ;
  }
};

} // meow

#endif // MEOW_USAGE_H__