include/core/command.hpp

   1 #ifndef _command__hpp__included__
   2 #define _command__hpp__included__
   3
   4 #include <stdexcept>
   5 #include <string>
   6 #include <set>
   7
   8
   9 /**
  10  * A command.
  11  */
  12 class command
  13 {
  14 public:
  15 /**
  16  * Register a new command.
  17  *
  18  * parameter cmd: The command to register.
  19  * throws std::bad_alloc: Not enough memory.
  20  */
  21         command(const std::string& cmd) throw(std::bad_alloc);
  22
  23 /**
  24  * Deregister a command.
  25  */
  26         virtual ~command() throw();
  27
  28 /**
  29  * Invoke a command.
  30  *
  31  * parameter arguments: Arguments to command.
  32  * throws std::bad_alloc: Not enough memory.
  33  * throws std::runtime_error: Command execution failed.
  34  */
  35         virtual void invoke(const std::string& arguments) throw(std::bad_alloc, std::runtime_error) = 0;
  36
  37 /**
  38  * Look up and invoke a command. The command will undergo alias expansion and recursion checking.
  39  *
  40  * parameter cmd: Command to exeucte.
  41  */
  42         static void invokeC(const std::string& cmd) throw();
  43 /**
  44  * Get set of aliases.
  45  */
  46         static std::set<std::string> get_aliases() throw(std::bad_alloc);
  47 /**
  48  * Get alias
  49  */
  50         static std::string get_alias_for(const std::string& aname) throw(std::bad_alloc);
  51 /**
  52  * Set alias
  53  */
  54         static void set_alias_for(const std::string& aname, const std::string& avalue) throw(std::bad_alloc);
  55 /**
  56  * Is alias name valid.
  57  */
  58         static bool valid_alias_name(const std::string& aname) throw(std::bad_alloc);
  59 /**
  60  * Get short help for command.
  61  */
  62         virtual std::string get_short_help() throw(std::bad_alloc);
  63
  64 /**
  65  * Get long help for command.
  66  */
  67         virtual std::string get_long_help() throw(std::bad_alloc);
  68 private:
  69         command(const command&);
  70         command& operator=(const command&);
  71         std::string commandname;
  72 };
  73
  74 /**
  75  * Mandatory filename
  76  */
  77 struct arg_filename
  78 {
  79 /**
  80  * The filename itself.
  81  */
  82         std::string v;
  83 /**
  84  * Return the filename.
  85  *
  86  * returns: The filename.
  87  */
  88         operator std::string() { return v; }
  89 };
  90
  91 /**
  92  * Run command function helper.
  93  *
  94  * parameter fn: Function pointer to invoke.
  95  * parameter a: The arguments to pass.
  96  */
  97 template<typename... args>
  98 void invoke_command_fn(void (*fn)(args... arguments), const std::string& a);
  99
 100 /**
 101  * Warp function pointer as command.
 102  */
 103 template<typename... args>
 104 class function_ptr_command : public command
 105 {
 106 public:
 107 /**
 108  * Create a new command.
 109  *
 110  * parameter name: Name of the command
 111  * parameter description Description for the command
 112  * parameter help: Help for the command.
 113  * parameter fn: Function to call on command.
 114  */
 115         function_ptr_command(const std::string& name, const std::string& _description, const std::string& _help,
 116                 void (*_fn)(args... arguments)) throw(std::bad_alloc)
 117                 : command(name)
 118         {
 119                 description = _description;
 120                 help = _help;
 121                 fn = _fn;
 122         }
 123 /**
 124  * Destroy a commnad.
 125  */
 126         ~function_ptr_command() throw()
 127         {
 128         }
 129 /**
 130  * Invoke a command.
 131  *
 132  * parameter a: Arguments to function.
 133  */
 134         void invoke(const std::string& a) throw(std::bad_alloc, std::runtime_error)
 135         {
 136                 invoke_command_fn(fn, a);
 137         }
 138 /**
 139  * Get short description.
 140  *
 141  * returns: Description.
 142  * throw std::bad_alloc: Not enough memory.
 143  */
 144         std::string get_short_help() throw(std::bad_alloc)
 145         {
 146                 return description;
 147         }
 148 /**
 149  * Get long help.
 150  *
 151  * returns: help.
 152  * throw std::bad_alloc: Not enough memory.
 153  */
 154         std::string get_long_help() throw(std::bad_alloc)
 155         {
 156                 return help;
 157         }
 158 private:
 159         void (*fn)(args... arguments);
 160         std::string description;
 161         std::string help;
 162 };
 163
 164 #endif