cmd_line.hpp

Go to the documentation of this file.

#ifndef STAN__IO__CMD_LINE_HPP
#define STAN__IO__CMD_LINE_HPP

#include <map>
#include <ostream>
#include <set>
#include <string>
#include <sstream>
#include <vector>

namespace stan {

  namespace io {
    
    void pad_help_option(std::ostream* o, 
                         const std::string& option = "",
                         unsigned int width = 20) {
      if (!o) return;
      *o << "  " << option;
      int padding = width - option.size();
      if (padding < 2) {
        *o << std::endl;
        padding = width + 2; // 2 is 
      }
      for (int i = 0; i < padding; ++i)
        *o << ' ';
    }

    void print_help_helper(std::ostream* o,
                           const std::string& key_val,
                           const std::string& msg,
                           const std::string& note = "") {
      if (!o) return;
      pad_help_option(o,key_val);
      *o << msg 
         << std::endl;
      if (note.size() > 0) {
        pad_help_option(o,"");
        *o << "    (" << note << ")" 
           << std::endl;
      }
      *o << std::endl;
    }

    void print_help_option(std::ostream* o,
                           const std::string& key,
                           const std::string& value_type,
                           const std::string& msg,
                           const std::string& note = "") {
      std::stringstream ss;
      ss << "--" << key;
      if (value_type.size() > 0)
        ss << "=<" << value_type << ">";
      print_help_helper(o,ss.str(),msg,note);
    }

    class cmd_line {
    private:
      std::string cmd_;
      std::map<std::string,std::string> key_val_;
      std::set<std::string> flag_;
      std::vector<std::string> bare_;
      void parse_arg(const std::string& s) {
        if (s.size() < 2
            || s[0] != '-'
            || s[1] != '-') {
          bare_.push_back(s);
          return;
        }
        for (size_t i = 2; i < s.size(); ++i) {
          if (s[i] == '=') {
            key_val_[s.substr(2,i - 2)] = s.substr(i + 1,s.size() - i - 1);
            return;
          } 
        }
        flag_.insert(s.substr(2,s.size()));
      }
    public:
      cmd_line(int argc, const char* argv[])
        : cmd_(argv[0]) {
        for (int i = 1; i < argc; ++i) 
          parse_arg(argv[i]);
      }

      std::string command() {
        return cmd_;
      }
      
      bool has_key(const std::string& key) const {
        return key_val_.find(key) != key_val_.end();
      }

      template <typename T>
      bool val(const std::string& key, T& x) const {
        if (!has_key(key))
          return false;
        std::stringstream s(key_val_.find(key)->second);
        s >> x;
        return true;
      }

      bool has_flag(const std::string& flag) const {
        return flag_.find(flag) != flag_.end();
      }

      size_t bare_size() const {
        return bare_.size();
      }

      template <typename T>
      bool bare(size_t n, T& x) const {
        if (n >= bare_.size())
          return false;
        std::stringstream s(bare_[n]);
        s >> x;
        return true;
      }


      void print(std::ostream& out) const {
        out << "COMMAND=" << cmd_ << '\n';
        size_t flag_count = 0;
        for (std::set<std::string>::const_iterator it = flag_.begin();
             it != flag_.end();
             ++it) {
          out << "FLAG " << flag_count << "=" << (*it) << '\n';
          ++flag_count;
        }
        size_t key_val_count = 0;
        for (std::map<std::string,std::string>::const_iterator it = key_val_.begin();
             it != key_val_.end();
             ++it) {
          out << "KEY " << key_val_count << "=" << (*it).first;
          out << " VAL " << key_val_count << "=" << (*it).second << '\n';
          ++key_val_count;
        }
        size_t bare_count = 0;
        for (size_t i = 0; i < bare_.size(); ++i) {
          out << "BARE ARG " << bare_count << "=" << bare_[i] << '\n';
          ++bare_count;
        }
      }

    };

    // explicit instantation for std::string to allow for spaces
    // in bare_[n]
    template <>
    bool cmd_line::bare<std::string>(size_t n, std::string& x) const {
      if (n >= bare_.size())
        return false;
      x = bare_[n];
      return true;
    }

    // explicit instantation for std::string to allow for spaces
    // in key_val_
    template <>
    bool cmd_line::val<std::string>(const std::string& key, std::string& x) const {
      if (!has_key(key))
        return false;
      x = key_val_.find(key)->second;
      return true;
    }


  }

}

#endif