request.hxx

#include <json/json.h>

#include <iostream>
#include <sstream>
#include <iomanip>
#include <map>
#include <vector>

namespace Request {
  class KeyParserBase {
  public:
    KeyParserBase (std::string name)
      : name_ (name),
        required_ (false)
    {}

    // Destructor
    virtual ~KeyParserBase () {}

    const std::string & name () const {
      return name_;
    }

    void display (std::ostream & cout) const {
      cout << "  " << name_ << " " << metavar_ << std::endl;

      if (description_ != "")
        cout << "      " << description_ << std::endl;

      if (isVector())
        cout << "      multiple values allowed" << std::endl;

      if (default_ != "")
        cout << "      default: " << default_ << std::endl;

      if (required_)
        cout << "      required" << std::endl;

      cout << std::endl;
    }

    KeyParserBase * metavar (std::string metavar) {
      metavar_ = metavar;
      return this;
    }

    KeyParserBase * description (std::string description) {
      description_ = description;
      return this;
    }

    KeyParserBase * required (bool req = true) {
      required_ = req;
      return this;
    }

    virtual bool isVector () const {
      return false;
    }

    virtual void parse (std::istream & cin) = 0;

    virtual void set (const Json::Value & json) = 0;

  protected:
    std::string default_;

  private:
    const std::string name_;
    std::string description_;
    std::string metavar_;
    bool required_;
  };

  template <typename T>
  void setValue (const Json::Value & json, T & destination) {
    std::istringstream iss (json.asString());
    iss >> destination;
  }

  template <typename T>
  class Key : public KeyParserBase {
  public:
    Key (std::string name, T & destination)
      : KeyParserBase (name),
        destination_ (destination)
    {
      std::ostringstream defaultStr;
      defaultStr << std::boolalpha << destination;
      default_ = defaultStr.str();
    }

    virtual void parse (std::istream & cin) {
      cin >> std::boolalpha >> destination_;
    }

    virtual void set (const Json::Value & json) {
      setValue (json, destination_);
    }

  private:
    T & destination_;
  };

  template <typename T>
  class Key<std::vector<T> > : public KeyParserBase {
  public:
    typedef std::vector<T>  Vector;

    Key (std::string name, Vector & destination)
      : KeyParserBase (name),
        destination_ (destination)
    {
      Json::Value defaults;

      auto it = destination.begin();
      auto end = destination.end();
      for ( ; it != end ; ++it) {
        defaults.append (*it);
      }

      default_ = Json::FastWriter().write (defaults);
    }

    virtual bool isVector () const {
      return true;
    }

    virtual void parse (std::istream & cin) {
      T val;
      cin >> std::boolalpha >> val;
      destination_.push_back (val);
    }

    virtual void set (const Json::Value & json) {
      destination_.resize (json.size());
      for (int i = 0 ; i<json.size() ; ++i) {
        setValue (json[i], destination_[i]);
      }
    }

  private:
    Vector & destination_;
  };


  class CommandParser {
  public:
    CommandParser (std::string name, std::string description = "")
      : prompt_ (name + "> "),
        description_ (description),
        name_ (name)
    { }

    virtual ~CommandParser () {
      auto it = keys_.begin();
      auto end = keys_.end();
      for ( ; it != end ; ++it) {
        delete (it->second);
      }
    }

    void parse (std::istream & cin, std::ostream & cout, bool echo = false) {
      defaults();
      do {
        cout << prompt_ << std::flush;
        std::string line;
        std::getline (cin, line);

        if (echo) {
          cout << line << std::endl;
        }

        if (line == "") {
          break;
        }

        std::istringstream input (line);
        std::string key;
        input >> key;

        KeyMap::const_iterator it = keys_.find(key);
        if (it != keys_.end()) {
          it->second->parse (input);
        } else {
          cout << "Unknown key: `" << key << "'" << std::endl;
        }

      } while (! cin.eof());
      run (cout);
    }

    void parseJson (const Json::Value & request, std::ostream & cout) {
      defaults();

      auto it = keys_.begin();
      auto end = keys_.end();
      for ( ; it != end ; ++it){
        Json::Value arg = request[it->first];
        if (! arg.isNull()) {
          it->second->set (arg);
        }
      }

      run(cout);
    }

  protected:
    const std::string & name () {
      return name_;
    }

    void setDescription (std::string description) {
      description_ = description;
    }

    virtual void defaults () {}

    virtual void run (std::ostream & cout) = 0;

    CommandParser & add (KeyParserBase * key) {
      keys_[key->name()] = (key);
      return *this;
    }

    std::string prompt_;

  private:
    void help (std::ostream & cout) const {
      cout << description_ << std::endl
           << std::endl
           << "Arguments:" << std::endl;
      auto it = keys_.begin();
      auto end = keys_.end();
      for ( ; it != end ; ++it) {
        it->second->display(cout);
      }
    }

    void display (std::ostream & cout) {
      cout << std::setw(20) << std::left << name_
           << " " << description_ << std::endl;
    }

    typedef std::map<std::string, KeyParserBase*> KeyMap;

    std::string description_;
    const std::string name_;
    KeyMap keys_;

    friend class Parser;
  };

  class Parser {
  public:
    Parser (std::string description = "")
      : description_ (description),
        echo_ (false)
    { }

    ~Parser () {
      auto it = commands_.begin();
      auto end = commands_.end();
      for ( ; it != end ; ++it) {
        delete it->second;
      }
    }

    Parser & prompt (std::string p) {
      prompt_ = p;
      return *this;
    }

    Parser & echo (bool activate = true) {
      echo_ = activate;
      return *this;
    }

    Parser & add (CommandParser * command) {
      commands_[command->name()] = command;
      return *this;
    }

    void help (std::ostream & cout) {
      cout << description_ << std::endl
           << "Commands:" << std::endl
           << "  " << std::setw(20) << std::left << "help"
           << " Display this help" << std::endl
           << "  " << std::setw(20) << std::left << "help COMMAND"
           << " Display help about COMMAND" << std::endl;

      auto it = commands_.begin();
      auto end = commands_.end();
      for ( ; it != end ; ++it) {
        cout << "  ";
        it->second->display(cout);
      }
    }

    void parse (std::istream & cin, std::ostream & cout) {
      do {
        cout << prompt_ << std::flush;

        std::string line;
        std::getline (cin, line);

        if (echo_) {
          cout << line << std::endl;
        }

        if (line == "") {
          continue;
        }

        std::istringstream input (line);
        std::string command;
        input >> command;

        bool helpRequested = false;
        if (command == "help") {
          input >> command;
          if (command == "help") {
            help(cout);
            continue;
          } else {
            helpRequested = true;
          }
        }

        CommandMap::const_iterator it = commands_.find (command);
        if (it != commands_.end()) {
          if (helpRequested)
            it->second->help (cout);
          else
            it->second->parse (cin, cout, echo_);
        } else {
          cout << "Unknown command: `" << command << "'" << std::endl;
        }

      } while (! cin.eof());
    }

    void parseJson (std::istream & cin, std::ostream & cout, bool verbose=false) {
      if (verbose)
        std::cerr << "Receiving client request:" << std::endl;

      std::stringstream request;
      while (true) {
        std::string line;
        std::getline (cin, line);
        if (line == "")
          break;

        if (verbose)
          std::cerr << line << std::endl;

        request << line << std::endl;
      }

      Json::Value json;
      request >> json;

      if (verbose)
        std::cerr << "Processing request... ";
      cout << "Server response:" << std::endl << std::flush;

      std::string command = json["command"].asString();
      CommandMap::const_iterator it = commands_.find (command);
      if (it != commands_.end()) {
        it->second->parseJson (json, cout);
      } else {
        cout << "Unknown command: `" << command << "'" << std::endl;
      }

      if (verbose)
        std::cerr << "done." << std::endl << std::endl;
    }

  private:
    typedef std::map<std::string, CommandParser*> CommandMap;
    CommandMap  commands_;
    std::string description_;
    std::string prompt_;
    bool        echo_;
  };

  template <typename T>
  Key<T>* key (std::string name, T & destination) {
    return new Key<T> (name, destination);
  }
}