Menu.h

#ifndef PFLIB_TOOL_MENU_H
#define PFLIB_TOOL_MENU_H
 
#include <stdio.h>
#include <string.h>
 
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <string>
#include <vector>
 
#include "pflib/Exception.h"
#include "pflib/logging/Logging.h"
 
namespace pflib::menu {
 
class BaseMenu {
  static std::string history_filepath_;
 
 public:
  static void set_history_filepath(std::string fp);
 
  static void open_history();
 
  static void close_history();
 
  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,
                              const std::string& def = "");
 
  static std::string default_path(const std::string& name,
                                  const std::string& extension = "");
 
  static std::string output_directory;
 
  static std::string readline_path(const std::string& name,
                                   const std::string& extension = "");
 
  static std::string timestamp_format;
 
  static int readline_int(const std::string& prompt);
 
  static int readline_int(const std::string& prompt, int aval,
                          bool ashex = false);
 
  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_;
 
  static ::pflib::logging::logger the_log_;
 
 private:
  static char* matcher(const char* text, int state);
};  // BaseMenu
 
template <typename T>
class Menu : public BaseMenu {
 public:
  using TargetHandle = T;
  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,
             unsigned int category = 0) {
    lines_.emplace_back(name, desc, ex, category);
    return this;
  }
 
  Menu* line(const char* name, const char* desc, MultipleTargetCommands ex,
             unsigned int category = 0) {
    lines_.emplace_back(name, desc, ex, category);
    return this;
  }
 
  std::shared_ptr<Menu> submenu(const char* name, const char* desc,
                                RenderFuncType f = 0,
                                unsigned int category = 0) {
    auto sb = std::make_shared<Menu>(f, 0, name, this);
    lines_.emplace_back(name, desc, sb, category);
    return sb;
  }
 
  static Menu* root() {
    static Menu root;
    return &root;
  }
 
  void build() {
    // go through menu options and add exit
    for (Line& l : lines_) l.build();
    lines_.emplace_back("EXIT", "leave this menu");
    lines_.emplace_back("HELP", "print help for this menu",
                        [this](TargetHandle tgt) { this->render(tgt); });
    lines_.emplace_back("PWD", "print current menu path",
                        [this](TargetHandle tgt) {
                          pflib_log(info) << "Current menu: ";
                          this->print_path();
                          std::cout << std::endl;
                        });
  }
 
  static void run(TargetHandle tgt) {
    BaseMenu::open_history();
    root()->build();
    root()->steer(tgt);
    BaseMenu::close_history();
  }
 
  Menu(const Menu&) = delete;
  void operator=(const Menu&) = delete;
 
  Menu(RenderFuncType f = 0, unsigned int hidden_categories = 0,
       const char* name = "", Menu* parent = nullptr)
      : render_func_{f},
        hidden_categories_{hidden_categories},
        name_(name),
        parent_(parent) {}
 
  void hide(unsigned int categories) {
    hidden_categories_ = categories;
    for (auto& l : lines_) {
      l.hide(categories);
    }
  }
 
  void print(std::ostream& s, int indent = 0) const {
    for (const auto& l : lines_) {
      if ((l.category() & hidden_categories_) == 0) {
        l.print(s, indent);
      }
    }
  }
 
  void print_path(std::ostream& s = std::cout) const {
    if (parent_ != nullptr) {
      parent_->print_path(s);
      s << name_ << "/";
    } else {
      s << "/";  // root menu
    }
  }
 
  void render(TargetHandle tgt) const {
    if (render_func_) {
      render_func_(tgt);
    }
    std::cout << "\n";
    for (const auto& l : lines_) {
      if ((l.category() & hidden_categories_) == 0) {
        std::cout << l << std::endl;
      }
    }
  }
 
  void enter(TargetHandle tgt) const {
    if (cmdTextQueue_.empty()) {
      // copy over command options for tab complete
      this->cmd_options_ = this->command_options();
      this->render(tgt);
    }
  }
 
  void steer(TargetHandle p_target) const {
    enter(p_target);
    const Line* theMatch = 0;
    do {
      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
          enter(p_target);
        }
      }
    } while (theMatch == 0 or not theMatch->empty());
  }
 
  static std::shared_ptr<Menu> menu(const char* name, const char* desc,
                                    RenderFuncType render_func = 0,
                                    unsigned int category = 0) {
    return root()->submenu(name, desc, render_func, category);
  }
 
 private:
  virtual std::vector<std::string> command_options() const {
    std::vector<std::string> v;
    v.reserve(lines_.size());
    for (const auto& l : lines_) {
      if ((l.category() & hidden_categories_) == 0) {
        v.push_back(l.name());
      }
    }
    return v;
  }
 
 private:
  class Line {
   public:
    Line(const char* n, const char* d, SingleTargetCommand f,
         unsigned int category = 0)
        : name_(n),
          desc_(d),
          sub_menu_{nullptr},
          cmd_(f),
          mult_cmds_{0},
          category_{category} {}
    Line(const char* n, const char* d, MultipleTargetCommands f,
         unsigned int category = 0)
        : name_(n),
          desc_(d),
          sub_menu_{nullptr},
          mult_cmds_{f},
          category_{category} {}
    Line(const char* n, const char* d, std::shared_ptr<Menu> m,
         unsigned int category = 0)
        : name_(n),
          desc_(d),
          sub_menu_(m),
          cmd_(0),
          mult_cmds_{0},
          category_{category} {}
    Line(const char* n, const char* d)
        : name_(n),
          desc_(d),
          sub_menu_{nullptr},
          cmd_(0),
          mult_cmds_{0},
          category_{0} {}
 
    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);
        } catch (const pflib::Exception& e) {
          pflib_log(error) << "[" << e.name() << "] : " << e.message();
        } catch (const std::exception& e) {
          pflib_log(error) << "Unknown Exception " << e.what();
        }
      }
      // 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 build() {
      if (sub_menu_) sub_menu_->build();
    }
 
    void hide(unsigned int categories) {
      if (sub_menu_) sub_menu_->hide(categories);
    }
 
    const char* name() const { return name_; }
    const char* desc() const { return desc_; }
    unsigned int category() const { return category_; }
 
    friend std::ostream& operator<<(std::ostream& s, const Line& l) {
      return (s << "  " << std::left << std::setw(12) << l.name() << " "
                << l.desc());
    }
 
    void print(std::ostream& s, int indent = 0) const {
      for (std::size_t i{0}; i < indent; i++) s << " ";
      s << *this << "\n";
      if (sub_menu_) {
        sub_menu_->print(s, indent + 2);
      }
    }
 
   private:
    const char* name_;
    const char* desc_;
    std::shared_ptr<Menu> sub_menu_;
    SingleTargetCommand cmd_;
    MultipleTargetCommands mult_cmds_;
    unsigned int category_;
 
  };  // Line
 
 private:
  std::vector<Line> lines_;
  RenderFuncType render_func_;
  unsigned int hidden_categories_;
  std::string name_;
  Menu* parent_;
};  // Menu
 
}  // namespace pflib::menu
 
#endif  // PFLIB_TOOL_MENU_H