include/library/command.hpp

   1 #ifndef _library_command__hpp__included__
   2 #define _library_command__hpp__included__
   3
   4 #include <stdexcept>
   5 #include <string>
   6 #include <set>
   7 #include <map>
   8 #include <list>
   9 #include "threads.hpp"
  10
  11 namespace command
  12 {
  13 class base;
  14 class factory_base;
  15
  16 threads::lock& get_cmd_lock();
  17
  18 /**
  19  * A set of commands.
  20  */
  21 class set
  22 {
  23 public:
  24 /**
  25  * Create a new set.
  26  */
  27         set() throw(std::bad_alloc);
  28 /**
  29  * Destroy a set.
  30  */
  31         ~set() throw();
  32 /**
  33  * Add a command to set.
  34  */
  35         void do_register(const std::string& name, factory_base& cmd) throw(std::bad_alloc)
  36         {
  37                 threads::alock h(get_cmd_lock());
  38                 do_register_unlocked(name, cmd);
  39         }
  40 /**
  41  * Remove a command from set.
  42  */
  43         void do_unregister(const std::string& name, factory_base& cmd) throw(std::bad_alloc)
  44         {
  45                 threads::alock h(get_cmd_lock());
  46 //              do_unregister_unlocked(name, cmd);
  47         }
  48 /**
  49  * Add a notification callback and call ccb on all.
  50  *
  51  * Parameter ccb: The create callback function.
  52  * Parameter dcb: The destroy callback function.
  53  * Parameter tcb: The terminate callback function.
  54  * Returns: Callback handle.
  55  */
  56         uint64_t add_callback(std::function<void(set& s, const std::string& name, factory_base& cmd)> ccb,
  57                 std::function<void(set& s, const std::string& name)> dcb, std::function<void(set& s)> tcb)
  58                 throw(std::bad_alloc)
  59         {
  60                 threads::alock h(get_cmd_lock());
  61                 return add_callback_unlocked(ccb, dcb, tcb);
  62         }
  63 /**
  64  * Drop a notification callback and call dcb on all.
  65  *
  66  * Parameter handle: The handle of callback to drop.
  67  */
  68         void drop_callback(uint64_t handle) throw()
  69         {
  70                 threads::alock h(get_cmd_lock());
  71                 drop_callback_unlocked(handle);
  72         }
  73 /**
  74  * Obtain list of all commands so far.
  75  */
  76         std::map<std::string, factory_base*> get_commands()
  77         {
  78                 threads::alock h(get_cmd_lock());
  79                 return get_commands_unlocked();
  80         }
  81 /**
  82  * Unlocked versions of other functions.
  83  */
  84         void do_register_unlocked(const std::string& name, factory_base& cmd) throw(std::bad_alloc);
  85         void do_unregister_unlocked(const std::string& name, factory_base& cmd) throw(std::bad_alloc);
  86         uint64_t add_callback_unlocked(std::function<void(set& s, const std::string& name, factory_base& cmd)> ccb,
  87                 std::function<void(set& s, const std::string& name)> dcb, std::function<void(set& s)> tcb)
  88                 throw(std::bad_alloc);
  89         void drop_callback_unlocked(uint64_t handle) throw();
  90         std::map<std::string, factory_base*> get_commands_unlocked();
  91 private:
  92         char dummy;
  93 };
  94
  95 /**
  96  * A group of commands (with aliases).
  97  */
  98 class group
  99 {
 100 public:
 101 /**
 102  * Create a new command group. This also places some builtin commands in that new group.
 103  */
 104         group() throw(std::bad_alloc);
 105 /**
 106  * Destroy a group.
 107  */
 108         ~group() throw();
 109 /**
 110  * Look up and invoke a command. The command will undergo alias expansion and recursion checking.
 111  *
 112  * parameter cmd: Command to exeucte.
 113  */
 114         void invoke(const std::string& cmd) throw();
 115 /**
 116  * Get set of aliases.
 117  */
 118         std::set<std::string> get_aliases() throw(std::bad_alloc);
 119 /**
 120  * Get alias
 121  */
 122         std::string get_alias_for(const std::string& aname) throw(std::bad_alloc);
 123 /**
 124  * Set alias
 125  */
 126         void set_alias_for(const std::string& aname, const std::string& avalue) throw(std::bad_alloc);
 127 /**
 128  * Is alias name valid.
 129  */
 130         bool valid_alias_name(const std::string& aname) throw(std::bad_alloc);
 131 /**
 132  * Register a command.
 133  */
 134         void do_register(const std::string& name, base& cmd) throw(std::bad_alloc)
 135         {
 136                 threads::alock h(get_cmd_lock());
 137                 do_register_unlocked(name, cmd);
 138         }
 139 /**
 140  * Unregister a command.
 141  */
 142         void do_unregister(const std::string& name, base& cmd) throw(std::bad_alloc)
 143         {
 144                 threads::alock h(get_cmd_lock());
 145                 do_unregister_unlocked(name, cmd);
 146         }
 147 /**
 148  * Add all commands (including future ones) in given set.
 149  */
 150         void add_set(set& s) throw(std::bad_alloc)
 151         {
 152                 threads::alock h(get_cmd_lock());
 153                 add_set_unlocked(s);
 154         }
 155 /**
 156  * Drop a set of commands.
 157  */
 158         void drop_set(set& s) throw()
 159         {
 160                 threads::alock h(get_cmd_lock());
 161                 drop_set_unlocked(s);
 162         }
 163 /**
 164  * Set the output stream.
 165  */
 166         void set_output(std::ostream& s);
 167 /**
 168  * Set the OOM panic routine.
 169  */
 170         void set_oom_panic(void (*fn)());
 171 /**
 172  * Unlocked versions.
 173  */
 174         void do_register_unlocked(const std::string& name, base& cmd) throw(std::bad_alloc);
 175         void do_unregister_unlocked(const std::string& name, base& cmd) throw(std::bad_alloc);
 176         void add_set_unlocked(set& s) throw(std::bad_alloc);
 177         void drop_set_unlocked(set& s) throw();
 178 private:
 179         std::set<std::string> command_stack;
 180         std::map<std::string, std::list<std::string>> aliases;
 181         std::ostream* output;
 182         void (*oom_panic_routine)();
 183         base* builtin[1];
 184 };
 185
 186 /**
 187  * A command.
 188  */
 189 class base
 190 {
 191 public:
 192 /**
 193  * Register a new command.
 194  *
 195  * parameter group: The group command will be part of.
 196  * parameter cmd: The command to register.
 197  * parameter dynamic: Should the object be freed when its parent group dies?
 198  * throws std::bad_alloc: Not enough memory.
 199  */
 200         base(group& group, const std::string& cmd, bool dynamic) throw(std::bad_alloc);
 201
 202 /**
 203  * Deregister a command.
 204  */
 205         virtual ~base() throw();
 206
 207 /**
 208  * Invoke a command.
 209  *
 210  * parameter arguments: Arguments to command.
 211  * throws std::bad_alloc: Not enough memory.
 212  * throws std::runtime_error: Command execution failed.
 213  */
 214         virtual void invoke(const std::string& arguments) throw(std::bad_alloc, std::runtime_error) = 0;
 215 /**
 216  * Get short help for command.
 217  */
 218         virtual std::string get_short_help() throw(std::bad_alloc);
 219
 220 /**
 221  * Get long help for command.
 222  */
 223         virtual std::string get_long_help() throw(std::bad_alloc);
 224 /**
 225  * Get name of command.
 226  */
 227         const std::string& get_name() { return commandname; }
 228 /**
 229  * Notify that the parent group died.
 230  *
 231  * Note: Assumed to be called with global lock held.
 232  */
 233         void group_died() throw();
 234 private:
 235         base(const base&);
 236         base& operator=(const base&);
 237         std::string commandname;
 238         group* in_group;
 239         bool is_dynamic;
 240 };
 241
 242 /**
 243  * A command factory.
 244  */
 245 class factory_base
 246 {
 247 public:
 248         factory_base() throw() {}
 249 /**
 250  * Register a new command.
 251  *
 252  * parameter _set: The set command will be part of.
 253  * parameter cmd: The command to register.
 254  * throws std::bad_alloc: Not enough memory.
 255  */
 256         void _factory_base(set& _set, const std::string& cmd) throw(std::bad_alloc);
 257 /**
 258  * Destructor.
 259  */
 260         virtual ~factory_base() throw();
 261 /**
 262  * Make a new command.
 263  */
 264         virtual base* make(group& grp) = 0;
 265 /**
 266  * Notify that the parent set died.
 267  *
 268  * Note: Assumed to be called with global lock held.
 269  */
 270         void set_died() throw();
 271 private:
 272         factory_base(const factory_base&);
 273         factory_base& operator=(const factory_base&);
 274         std::string commandname;
 275         set* in_set;
 276 };
 277
 278 /**
 279  * Mandatory filename
 280  */
 281 struct arg_filename
 282 {
 283 /**
 284  * The filename itself.
 285  */
 286         std::string v;
 287 /**
 288  * Return the filename.
 289  *
 290  * returns: The filename.
 291  */
 292         operator std::string() { return v; }
 293 };
 294
 295 /**
 296  * Run command function helper.
 297  *
 298  * parameter fn: Function pointer to invoke.
 299  * parameter a: The arguments to pass.
 300  */
 301 template<typename... args>
 302 void invoke_fn(void (*fn)(args... arguments), const std::string& a);
 303
 304 /**
 305  * Warp function pointer as command.
 306  */
 307 template<typename... args>
 308 class _fnptr : public base
 309 {
 310 public:
 311 /**
 312  * Create a new command.
 313  *
 314  * parameter group: The group command will be part of.
 315  * parameter name: Name of the command
 316  * parameter description Description for the command
 317  * parameter help: Help for the command.
 318  * parameter fn: Function to call on command.
 319  * parameter dynamic: Should the object be freed when its parent group dies?
 320  */
 321         _fnptr(group& group, const std::string& name, const std::string& _description,
 322                 const std::string& _help, void (*_fn)(args... arguments), bool dynamic = false) throw(std::bad_alloc)
 323                 : base(group, name, dynamic)
 324         {
 325                 description = _description;
 326                 help = _help;
 327                 fn = _fn;
 328         }
 329 /**
 330  * Destroy a commnad.
 331  */
 332         ~_fnptr() throw()
 333         {
 334         }
 335 /**
 336  * Invoke a command.
 337  *
 338  * parameter a: Arguments to function.
 339  */
 340         void invoke(const std::string& a) throw(std::bad_alloc, std::runtime_error)
 341         {
 342                 invoke_fn(fn, a);
 343         }
 344 /**
 345  * Get short description.
 346  *
 347  * returns: Description.
 348  * throw std::bad_alloc: Not enough memory.
 349  */
 350         std::string get_short_help() throw(std::bad_alloc)
 351         {
 352                 return description;
 353         }
 354 /**
 355  * Get long help.
 356  *
 357  * returns: help.
 358  * throw std::bad_alloc: Not enough memory.
 359  */
 360         std::string get_long_help() throw(std::bad_alloc)
 361         {
 362                 return help;
 363         }
 364 private:
 365         void (*fn)(args... arguments);
 366         std::string description;
 367         std::string help;
 368 };
 369
 370 /**
 371  * Function pointer command factory.
 372  */
 373 template<typename... args>
 374 class fnptr : public factory_base
 375 {
 376 public:
 377 /**
 378  * Create a new command.
 379  *
 380  * parameter _set: The set command will be part of.
 381  * parameter name: Name of the command
 382  * parameter description Description for the command
 383  * parameter help: Help for the command.
 384  * parameter fn: Function to call on command.
 385  */
 386         fnptr(set& _set, const std::string& _name, const std::string& _description,
 387                 const std::string& _help, void (*_fn)(args... arguments)) throw(std::bad_alloc)
 388         {
 389                 description = _description;
 390                 name = _name;
 391                 help = _help;
 392                 fn = _fn;
 393                 _factory_base(_set, name);
 394         }
 395 /**
 396  * Destroy a commnad.
 397  */
 398         ~fnptr() throw()
 399         {
 400         }
 401 /**
 402  * Make a command.
 403  */
 404         base* make(group& grp) throw(std::bad_alloc)
 405         {
 406                 return new _fnptr<args...>(grp, name, description, help, fn, true);
 407         }
 408 private:
 409         void (*fn)(args... arguments);
 410         std::string description;
 411         std::string help;
 412         std::string name;
 413 };
 414
 415 /**
 416  * Generic byname factory.
 417  */
 418 template<typename T>
 419 class byname_factory : public factory_base
 420 {
 421 public:
 422 /**
 423  * Create a new factory.
 424  */
 425         byname_factory(set& s, const std::string& _name)
 426         {
 427                 name = _name;
 428                 _factory_base(s, name);
 429         }
 430 /**
 431  * Destroy.
 432  */
 433         ~byname_factory() throw()
 434         {
 435         }
 436 /**
 437  * Make a command.
 438  */
 439         base* make(group& grp) throw(std::bad_alloc)
 440         {
 441                 return new T(grp, name);
 442         }
 443 private:
 444         std::string name;
 445 };
 446 }
 447 #endif