interactive_common_cli.hpp

Go to the documentation of this file.

#ifndef IROHA_CLI_INTERACTIVE_COMMON_CLI_HPP
#define IROHA_CLI_INTERACTIVE_COMMON_CLI_HPP

#include <algorithm>
#include <ciso646>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

#include <boost/optional.hpp>

namespace parser {
  boost::optional<std::string> parseFirstCommand(std::string line);
}

namespace iroha_cli {
  namespace interactive {

    enum MenuContext {
      MAIN,
      RESULT
    };

    struct ParamData {
      std::string message;

      std::string cache;
    };

    // Description of parameters
    using ParamsDescription = std::vector<ParamData>;
    // map for command - command description relationship
    using DescriptionMap = std::unordered_map<std::string, std::string>;
    // Points in a menu
    using MenuPoints = std::vector<std::string>;
    // map for command - ParamsDescription relationship
    using ParamsMap = std::unordered_map<std::string, ParamsDescription>;

    // ------ Common commands short name ---------
    const std::string SAVE_CODE = "save";
    const std::string SEND_CODE = "send";
    const std::string BACK_CODE = "b";

    DescriptionMap getCommonDescriptionMap();

    ParamsMap getCommonParamsMap(const std::string &default_ip,
                                 int default_port);

    ParamsDescription makeParamsDescription(
        const std::vector<std::string> &params);

    void handleEmptyCommand();

    void handleUnknownCommand(std::string &command);

    void addBackOption(MenuPoints &menu);

    bool isBackOption(std::string line);

    void printEnd();

    void printCommandParameters(std::string &command,
                                const ParamsDescription &parameters);

    void printMenu(const std::string &message, MenuPoints menu_points);

    boost::optional<std::string> promptString(const std::string &message);

    boost::optional<std::string> promptString(const ParamData &param);

    boost::optional<std::vector<std::string>> parseParams(
        std::string line, std::string command_name, ParamsMap &params_map);

    size_t addMenuPoint(std::vector<std::string> &menu_points,
                        const std::string &description,
                        const std::string &command_short_name);

    template <typename K, typename V>
    std::size_t getNextIndex(std::unordered_map<K, V> parsers_map) {
      return parsers_map.size() == 0 ? 1 : parsers_map.size();
    }

    template <typename K, typename V>
    boost::optional<V &> findInHandlerMap(
        K command_name, std::unordered_map<K, V> &params_map) {
      auto it = params_map.find(command_name);
      if (it == params_map.end()) {
        // Command not found, report error
        handleUnknownCommand(command_name);
        return boost::none;
      }
      return it->second;
    }

    boost::optional<std::pair<std::string, uint16_t>> parseIrohaPeerParams(
        std::vector<std::string> params,
        const std::string &default_ip,
        int default_port);

    template <typename T, typename V, typename C>
    boost::optional<T> handleParse(
        C class_pointer,
        std::string &line,
        std::unordered_map<std::string, V> &parsers_map,
        ParamsMap &params_map) {
      auto raw_command = parser::parseFirstCommand(line);
      if (not raw_command) {
        handleEmptyCommand();
        return boost::none;
      }
      auto command_name = raw_command.value();
      auto parser = findInHandlerMap(command_name, parsers_map);
      if (not parser) {
        std::cout << "Parser for command not found" << std::endl;
        return boost::none;
      }
      auto params = parseParams(line, command_name, params_map);
      if (not params) {
        std::cout << "Parse params returned no value" << std::endl;
        return boost::none;
      }
      return (class_pointer->*parser.value())(params.value());
    }

    template <typename V>
    void addCliCommand(MenuPoints &menu_points,
                       std::unordered_map<std::string, V> &parsers_map,
                       const std::string &command_name,
                       const std::string &command_description,
                       V parser) {
      // Add menu point and get the index in menu of current command
      auto index = std::to_string(
          addMenuPoint(menu_points, command_description, command_name));
      // Add parser for this command
      parsers_map[index] = parser;
      parsers_map[command_name] = parser;
    }

    template <typename V>
    MenuPoints formMenu(std::unordered_map<std::string, V> &parsers_map,
                        ParamsMap &paramsMap,
                        const DescriptionMap descriptionMap) {
      // Add menu point and get the index in menu of current command
      MenuPoints menu_points;
      std::for_each(descriptionMap.begin(),
                    descriptionMap.end(),
                    [&parsers_map, &menu_points, &paramsMap](auto val) {
                      auto command_name = val.first;
                      auto command_description = val.second;

                      auto index = std::to_string(addMenuPoint(
                          menu_points, command_description, command_name));
                      parsers_map[index] = parsers_map.at(command_name);
                      ;
                      paramsMap[index] = paramsMap.at(command_name);
                    });
      return menu_points;
    }

  }  // namespace interactive
}  // namespace iroha_cli

#endif  // IROHA_CLI_INTERACTIVE_COMMON_CLI_HPP