Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Albatross's Rapid Numeric Menu Development Header

By: a guest on Oct 2nd, 2012  |  syntax: C++  |  size: 4.02 KB  |  views: 76  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. //Albatross's Rapid Numeric Menu Development Header. Keep out of reach of the people in CIS 29.
  2.  
  3. #ifndef NUMERICMENU_H
  4. #define NUMERICMENU_H
  5.  
  6. #include <iostream>
  7. #include <string>
  8. #include <vector>
  9.  
  10. #if __cplusplus < 201103L && __cplusplus != 1
  11. #error This program relies on C++11 features. Please retry compilation with these features enabled.
  12. #endif
  13.  
  14. namespace nmenu {
  15.  
  16.     class MenuBase {
  17.     public:
  18.         MenuBase() {
  19.             prev = nullptr;
  20.         }
  21.         MenuBase(std::string naem, MenuBase* togoto = nullptr) {
  22.             prev = togoto;
  23.             descript=naem;
  24.         }
  25.  
  26.         virtual void exec() = 0;
  27.         virtual std::string name() {
  28.             return descript;
  29.         }
  30.         virtual void set_name(std::string naem) {
  31.             descript = naem;
  32.         }
  33.         virtual void set_return(MenuBase* returnto) {
  34.             prev = returnto;
  35.         }
  36.  
  37.     protected:
  38.         std::string descript;
  39.         MenuBase* prev;
  40.     };
  41.  
  42.     template <typename T>
  43.     class MenuItem : public MenuBase {
  44.     public:
  45.         void exec() {
  46.             action();
  47.             if (prev != nullptr)
  48.                 prev->exec();
  49.         }
  50.         explicit MenuItem(std::string naem, T tocall, MenuBase* previous = nullptr) : MenuBase(naem,previous) {
  51.             action = tocall;
  52.         }
  53.     protected:
  54.         T action;
  55.     };
  56.  
  57.     template <typename T>
  58.     class MenuItem<T*> : public MenuBase {
  59.     public:
  60.         void exec() {
  61.             if (action != nullptr)
  62.                 (*action)();
  63.             if (prev != nullptr)
  64.                 prev->exec();
  65.         }
  66.         explicit MenuItem(std::string naem, T* tocall, MenuBase* previous = nullptr) : MenuBase(naem,previous) {
  67.             action = tocall;
  68.         }
  69.     protected:
  70.         T* action;
  71.     };
  72.  
  73.     class MenuExit : public MenuBase {
  74.     public:
  75.         void exec() {
  76.             std::cout << message;
  77.         }
  78.         explicit MenuExit(std::string naem, std::string finaltext = "") : MenuBase(naem) {
  79.             message = finaltext;
  80.         }
  81.     protected:
  82.         std::string message;
  83.     };
  84.  
  85.     template <>
  86.     class MenuItem<void> : public MenuBase {
  87.     public:
  88.         void exec() {
  89.             if (prev != nullptr)
  90.                 prev->exec();
  91.         }
  92.         explicit MenuItem(std::string naem, MenuBase* previous = nullptr) : MenuBase(naem, previous) {
  93.             set_name(naem);
  94.         }
  95.     protected:
  96.     };
  97.  
  98.     class MenuList : public MenuBase {
  99.     public:
  100.         explicit MenuList(std::string naem = "", MenuBase* previ = nullptr) : MenuBase(naem, previ) {}
  101.  
  102.         void exec() {
  103.             if(callables.empty()) {
  104.                 std::cout << "This menu is empty.\n";
  105.                 if (prev != nullptr)
  106.                     prev->exec();
  107.                 return;
  108.             }
  109.             for (size_t i = 0; i < callables.size(); ++i) {
  110.                 if (callables[i]->name().empty())
  111.                     std::cout << i << " - ???\n";
  112.                 else
  113.                     std::cout << i << " - " << callables[i]->name() << '\n';
  114.             }
  115.  
  116.             std::cout << "Choose an option: ";
  117.             size_t i;
  118.             do {
  119.                 std::cin >> i;
  120.                 if (i >= callables.size())
  121.                 std::cout << "Invalid option. Please choose an option between 0 and " << callables.size() -1 << ": ";
  122.             } while (i >= callables.size());
  123.             callables[i]->exec();
  124.         }
  125.  
  126.         void connect(MenuBase* node) {
  127.             if (node != nullptr)
  128.                 callables.push_back(node);
  129.         }
  130.         void disconnect(size_t item) {
  131.             if (item < callables.size()) {
  132.                 callables.erase(callables.begin() + item);
  133.             }
  134.         }
  135.         void disconnect_last() {
  136.             callables.pop_back();
  137.         }
  138.         void disconnect_all() {
  139.             callables.clear();
  140.         }
  141.  
  142.     private:
  143.         std::vector<MenuBase*> callables;
  144.     };
  145.  
  146.  
  147. }
  148.  
  149. #endif // NUMERICMENU_H