Menu.h

#ifndef PFLIB_TOOL_MENU_H
#define PFLIB_TOOL_MENU_H
 
#include <stdio.h>
#include <string.h>
 
#include <list>
#include <string>
#include <vector>
#include <functional>
#include <iostream>
#include <iomanip>
 
#ifndef PFLIB_TEST_MENU
#include "pflib/Exception.h"
#endif
 
class BaseMenu {
 public:
  static std::string readline(const std::string& prompt,
                              const std::string& defval,
                              bool preserve_last_blank = false);
 
  static std::string readline_nosplit(const std::string& prompt,
                                      const std::string& defval);
  static std::string readline(const std::string& prompt);
 
  static std::string readline(const std::string& prompt, const std::vector<std::string>& opts);
 
  static int readline_int(const std::string& prompt);
 
  static int readline_int(const std::string& prompt, int aval);
 
  static double readline_float(const std::string& prompt);
 
  static bool readline_bool(const std::string& prompt, bool aval);
 
  static std::string readline_cmd();
 
  static void add_to_command_queue(const std::string& str);
  
 protected:
  void add_to_history(const std::string& cmd) const;
 
  static std::list<std::string> cmdTextQueue_;
 
  static std::vector<std::string> cmd_options_;
 
  static const std::vector<std::string>* rl_comp_opts_;
 
 private:
  static char* matcher(const char* text, int state);
};  // BaseMenu
 
template <typename T, typename H = T*>
class Menu : public BaseMenu {
 public:
  using TargetType = T;
  using TargetHandle = H;
  using SingleTargetCommand = std::function<void(TargetHandle)>;
  using MultipleTargetCommands = std::function<void(const std::string&, TargetHandle)>;
 
  using RenderFuncType = std::function<void(TargetHandle)>;
 
  Menu* line(const char* name, const char* desc, SingleTargetCommand ex) {
    lines_.emplace_back(name,desc,ex);
    return this;
  }
 
  Menu* line(const char* name, const char* desc, MultipleTargetCommands ex) {
    lines_.emplace_back(name,desc,ex);
    return this;
  }
 
  Menu* submenu(const char* name, const char* desc, RenderFuncType f = 0) {
    auto sb = new Menu(f);
    lines_.emplace_back(name,desc,sb); // Line takes ownership
    return sb;
  }
 
  static Menu* root() {
    static Menu root;
    return &root;
  }
 
  void render() {
    // go through menu options and add exit
    for (Line& l : lines_) l.render();
    lines_.emplace_back("EXIT","leave this menu");
  }
 
  static void run(TargetHandle tgt) {
    root()->render();
    root()->steer(tgt);
  }
  
  Menu(const Menu&) = delete;
  void operator=(const Menu&) = delete;
 
  Menu(RenderFuncType f = 0) : render_func_{f} {}
 
  void steer(TargetHandle p_target) const {
    this->cmd_options_ = this->command_options(); // we are the captain now
    const Line* theMatch = 0;
    do {
      if (render_func_ != 0) {
        this->render_func_(p_target);
      }
      // if cmd text queue is empty, then print menu for interactive user
      if (this->cmdTextQueue_.empty()) {
        printf("\n");
        for (const auto& l : lines_) 
          std::cout << l << std::endl;
      }
      std::string request = readline_cmd();
      theMatch = 0;
      // check for a unique match...
      int nmatch = 0;
      for (size_t i = 0; i < lines_.size(); i++)
        if (strcasecmp(request.c_str(), lines_[i].name()) == 0) {
          theMatch = &(lines_[i]);
          nmatch++;
        }
      if (nmatch > 1) theMatch = 0;
      // ok
      if (theMatch == 0)
        printf("  Command '%s' not understood.\n\n", request.c_str());
      else {
        add_to_history(theMatch->name());
        if (theMatch->execute(p_target)) {
          // resume control when the chosen line was a submenu
          this->cmd_options_ = this->command_options();
        }
      }
    } while (theMatch == 0 or not theMatch->empty());
  }
 
  static Menu* menu(const char* name, const char* desc, 
      RenderFuncType render_func = 0) {
    return root()->submenu(name,desc,render_func);
  }
 
 private:
  virtual std::vector<std::string> command_options() const {
    std::vector<std::string> v;
    v.reserve(lines_.size());
    for (const auto& l : lines_) v.push_back(l.name());
    return v;
  }
 
 private:
  class Line {
   public:
    Line(const char* n, const char* d, SingleTargetCommand f)
        : name_(n), desc_(d), sub_menu_{0}, cmd_(f), mult_cmds_{0} {}
    Line(const char* n, const char* d, MultipleTargetCommands f)
        : name_(n), desc_(d), sub_menu_{0}, mult_cmds_{f} {}
    Line(const char* n, const char* d, Menu* m)
        : name_(n), desc_(d), sub_menu_(m), cmd_(0), mult_cmds_{0} {}
    Line(const char* n, const char* d)
        : name_(n), desc_(d), sub_menu_{0}, cmd_(0), mult_cmds_{0} {}
 
    Line(Line&& l) noexcept 
      : name_{l.name_},
        desc_{l.desc_},
        sub_menu_{l.sub_menu_},
        cmd_{l.cmd_},
        mult_cmds_{l.mult_cmds_}
    {
      l.sub_menu_ = 0;
    }
 
    Line(const Line& l) = default;
 
    ~Line() {
      if (sub_menu_) delete sub_menu_;
    }
 
    bool execute(TargetHandle p) const {
      if (sub_menu_) {
        sub_menu_->steer(p);
        return true;
      } else if (cmd_ or mult_cmds_) {
        try {
          if (cmd_) cmd_(p);
          else mult_cmds_(name_,p);
#ifndef PFLIB_TEST_MENU
        } catch(const pflib::Exception& e) {
          std::cerr << " pflib ERR [" << e.name()
            << "] : " << e.message() << std::endl;
#endif
        } catch(const std::exception& e) {
          std::cerr << " Unknown Exception " << e.what() << std::endl;
        }
      }
      // empty and command lines don't need the parent menu
      // to reset the command options
      return false;
    }
 
    bool empty() const {
      return !sub_menu_ and cmd_ == 0 and mult_cmds_ == 0;
    }
 
    void render() {
      if (sub_menu_) sub_menu_->render();
    }
 
    const char* name() const { return name_; }
    const char* desc() const { return desc_; }
    friend std::ostream& operator<<(std::ostream& s, const Line& l) {
      return (s << "  " << std::left << std::setw(12) << l.name() 
                << " " << l.desc());
    }
   private:
    const char* name_;
    const char* desc_;
    Menu* sub_menu_;
    SingleTargetCommand cmd_;
    MultipleTargetCommands mult_cmds_;
  };  // Line
 
 private:
  std::vector<Line> lines_;
  RenderFuncType render_func_;
};  // Menu
 
#endif  // PFLIB_TOOL_MENU_H