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