Console/Node.hh

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief Node public header */
  25
  26 /** \defgroup node_tree The console/config file-system node tree
  27
  28     The console/config node tree is the central data-structure of the library. Into this tree, all
  29     commands and parameters are entered. The tree is then exposed using a file-system like
  30     interface.
  31
  32     \autotoc
  33
  34     \section console_tree The tree
  35
  36     We will start by giving a more complete example. This example contains most of the stuff needed
  37     for using the console/config library.
  38
  39     \code
  40     // Define callback function.
  41     void mycommand(std::ostream & os, senf::console::ParseCommandInfo const & command)
  42     {
  43         // ...
  44         os << "!! Important message ...\n";
  45     }
  46
  47     class SomeClass
  48     {
  49     public:
  50         // Declare a directory node (proxy) for use by this class. This must be public so we can add
  51         // it to the node tree later.
  52         senf::console::ScopedDirectory<SomeClass> dir;
  53
  54         SomeClass() : dir(this)
  55         {
  56             // You may document the directory here or later when adding it to the tree
  57             dir.doc("Manager for something");
  58
  59             // Add a member function (the pointer-to-member is automatically bound to this instance)
  60             dir.add("member", &SomeClass::member)
  61                 .doc("Do the member operation");
  62         }
  63
  64         void member(std::ostream & os, senf::console::ParseCommandInfo const & command)
  65         {
  66             // ...
  67         }
  68     };
  69
  70     int main(int, char**)
  71     {
  72         // Provide global documentation
  73         senf::console::root()
  74             .doc("This is someServer server");
  75
  76         // Add a new directory to the root and document it. All the mutators return the node object
  77         // itself so operations can be chained.
  78         senf::console::DirectoryNode & mydir (
  79                 .mkdir("myserver")
  80                 .doc("My server specific directory"));
  81
  82         // Add a command to that directory
  83         mydir.add("mycommand", &mycommand)
  84             .doc("mycommand <foo> [<bar>]\n\n"
  85                  "If <bar> is given, flurgle the <foo>, otherwise burgle it");
  86
  87         // Create a SomeClass instance and add it's directory.
  88         SomeClass someClass;
  89         mydir.add("someClass", someClass.dir);
  90
  91         // Start the interactive console server
  92         senf::console::Server::start(senf::INet4SocketAddress(senf::INet4Address::None, 23232u))
  93             .name("someServer");
  94     }
  95     \endcode
  96
  97     \subsection console_nodes Node types
  98
  99     The console/config library tree consists of two basic node types:
 100
 101     \li senf::console::DirectoryNode provides internal nodes with an arbitrary number of children
 102     \li senf::console::CommandNode describes a command entry in the tree
 103
 104     senf::console::CommandNode is the base-class of all command nodes of which there are several,
 105     depending on the type of command.
 106
 107     There is a single root node, the senf::console::DirectoryNode called senf::console::root(). From
 108     this node, the tree is traversed.
 109
 110     All nodes are allocated on the heap and are managed using a smart pointer.
 111
 112     \subsection console_manipulate Manipulating the node tree
 113
 114     There are several ways to add nodes to the tree:
 115
 116     \li A senf::console::DirectoryNode can be added using senf::console::DirectoryNode::mkdir().
 117     \li An arbitrary node can be created and then (possibly later) added to the tree using the
 118         corresponding senf::console::DirectoryNode::add() overload.
 119     \li A senf::console::CommandNode is normally added to the tree by directly adding a callback
 120         using one of the overloaded senf::console::DirectoryNode::add() members.
 121
 122     When directly adding a node callback, the type of node added depends on the type of
 123     callback. The callback types which can be added are listed at \ref console_callbacks.
 124
 125     \code
 126     void callback(std::ostream & os, senf::console::ParseCommandInfo const & command) { ... }
 127     // ...
 128     myDirectory.add("foo",&callback);
 129     \endcode
 130
 131     Every node is identified among it's siblings by it's name. The name of the node is set when
 132     adding the node to the tree. If the name is empty or non-unique, a unique name will be
 133     automatically provided.
 134
 135     To remove a node from the tree, just use the nodes senf::console::GenericNode::unlink() or the
 136     parents senf::console::DirectoryNode::remove() member. This call removes the node from it's
 137     parent and returns a (smart) node pointer.
 138
 139     \li If you ignore the return value, the node (and it's children) will be deleted.
 140     \li Alternatively, you may store away the node and re-attach it later.
 141     \li An node (or subtree) can be moved to a different place by unlinking the node at it's old
 142         place and re-adding it at it's new location.
 143     \li To rename a node, unlink and re-add it with a different name.
 144
 145     \code
 146     myDirectory.add("bar", myDirectory.remove("foo"));
 147     \endcode
 148
 149     \subsection console_node_param Assigning additional node parameters
 150
 151     Depending on the node type added, additional node parameters may be set. For example, every node
 152     has a documentation parameter which is used by the online-help system. To assign these
 153     parameters, the node exposes corresponding member functions. Since
 154     senf::console::DirectoryNode::add() returns the newly added node by reference, additional
 155     parameters may just be added to the end of the add command:
 156     \code
 157     myDirectory.add("foo",&fooCallback).doc("The foo method");
 158     \endcode
 159     Since the parameter setters all return the node reference, additional parameters may just be
 160     added to the end of the command.
 161
 162     \subsection console_tree_traverse Traversing the tree
 163
 164     The simplest way to access tree elements is to save the return value of the
 165     senf::console::DirectoryNode::add() members. However, saving the reference will not ensure, that
 166     the node is not removed. If the node might be removed from the tree, you should use a smart
 167     pointer (either <tt>ptr</tt> or <tt>weak_ptr</tt>) to hold the node.
 168
 169     Another possibility is to traverse the tree explicitly. For this purpose, the operators '[]' and
 170     '()' have been overloaded in senf::console::DirectoryNode.
 171     \code
 172     senf::console::root().getDirectory("myDirectory").getCommand("foo")
 173     \\ or more concise but otherwise completely identical
 174     senf::console::root()["myDirectory"]("foo")
 175     \endcode
 176
 177     getDirectory and the '[]' operator will return a senf::console::DirectoryNode whereas getCommand
 178     and the '()' operator will return a senf::console::CommandNode. If the node is not found or is
 179     not of the correct type, an exception will be raised.
 180
 181     \section console_object_dir Assigning a directory to an object instance
 182
 183     Most objects will register several commands. So it makes sense for these objects to manage their
 184     own directory. Since directories are however allocated on the heap, they cannot be directly
 185     added to a class. To facilitate this usage, the senf::console::ScopedDirectory is used. This
 186     class provides a senf::console::DirectoryNode facade. Internally, it automatically creates a
 187     senf::console::DirectoryNode to which all calls are forwarded.
 188
 189     The senf::console::ScopedDirectory member should be declared public. This allows the user of the
 190     class to add the node to the tree.
 191  */
 192
 193 #ifndef HH_Node_
 194 #define HH_Node_ 1
 195
 196 // Custom includes
 197 #include <map>
 198 #include <boost/shared_ptr.hpp>
 199 #include <boost/weak_ptr.hpp>
 200 #include <boost/enable_shared_from_this.hpp>
 201 #include <boost/utility.hpp>
 202 #include <boost/range/iterator_range.hpp>
 203 #include <boost/typeof/typeof.hpp>
 204 #include <boost/type_traits/remove_reference.hpp>
 205 #include "../Utils/Exception.hh"
 206 #include "../Utils/mpl.hh"
 207 #include "../Utils/Logger/SenfLog.hh"
 208 #include "Parse.hh"
 209
 210 //#include "Node.mpp"
 211 ///////////////////////////////hh.p////////////////////////////////////////
 212
 213 #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
 214
 215 namespace senf {
 216 namespace console {
 217
 218     class DirectoryNode;
 219     class CommandNode;
 220
 221     /** \brief Config/console node tree base-class
 222
 223         GenericNode is the base class of all node objects. There are two basic node types derived
 224         from GenericNode:  DirectoryNode and CommandNode.
 225
 226         All nodes are dynamically allocated and automatically managed using reference counting.
 227
 228         All nodes are normally linked into a single tree which root node is
 229         senf::console::root(). Nodes may however be orphaned (not linked to the tree) either
 230         directly (the node has no parent) or indirectly (the node has a parent but is part of an
 231         orphaned subtree which is not linked to the root node).
 232
 233         Every active (non-orphaned) node (except the root() node) has a non-empty node name. This
 234         name is assigned to the node when adding the node to the tree.
 235
 236         \ingroup node_tree
 237       */
 238     class GenericNode
 239         : public boost::enable_shared_from_this<GenericNode>
 240     {
 241         SENF_LOG_CLASS_AREA();
 242     public:
 243         ///////////////////////////////////////////////////////////////////////////
 244         // Types
 245
 246         typedef boost::shared_ptr<GenericNode> ptr;
 247         typedef boost::shared_ptr<GenericNode const> cptr;
 248         typedef boost::weak_ptr<GenericNode> weak_ptr;
 249
 250         ///////////////////////////////////////////////////////////////////////////
 251
 252         virtual ~GenericNode();
 253
 254         std::string const & name() const; ///< Node name
 255         boost::shared_ptr<DirectoryNode> parent() const; ///< Parent node
 256                                         /**< May be null, if the node is the root node or if it is
 257                                              not linked to the tree */
 258
 259         std::string path() const;       ///< Node path
 260                                         /**< The node path is built by joining the names of all
 261                                              parent nodes with '/' chars. */
 262
 263         ptr unlink();                   ///< Remove node from it's parent directory
 264                                         /**< You may either discard the return value and thereby
 265                                              dispose the node or may re-attach the node at some
 266                                              other place using DirectoryNode::add(). */
 267
 268         bool active() const;            ///< \c true, if node is attached to the root() node
 269
 270         void help(std::ostream & output) const; /// Write help info to \a output
 271
 272         ptr thisptr();                  ///< Get smart pointer to node
 273         cptr thisptr() const;           ///< Get smart pointer to node (const)
 274
 275     protected:
 276         GenericNode();
 277
 278         void name(std::string const & name);
 279
 280 #ifndef DOXYGEN
 281     private:
 282 #else
 283     public:
 284 #endif
 285         virtual void v_help(std::ostream & output) const = 0;
 286                                         ///< Provide help information
 287                                         /**< This member must be implemented in derived classes
 288                                              to provide node specific help information. */
 289
 290     private:
 291         std::string name_;
 292         DirectoryNode * parent_;
 293
 294         friend class DirectoryNode;
 295     };
 296
 297     class SimpleCommandNode;
 298
 299     /** \brief Internal: Node creation helper traits
 300
 301         This class is used internally to find out the type of node to create for a specific argument
 302         type.
 303      */
 304     template <class Object>
 305     struct NodeCreateTraits
 306     {
 307         typedef BOOST_TYPEOF_TPL( senf_console_add_node(
 308                                       * static_cast<DirectoryNode *>(0),
 309                                       * static_cast<std::string const *>(0),
 310                                       * static_cast<Object const *>(0),
 311                                       0) ) result_type;
 312
 313         typedef typename boost::remove_reference<result_type>::type NodeType;
 314
 315         /// Internal
 316         struct Creator {
 317             static NodeType & create(DirectoryNode & node, std::string const & name,
 318                                      Object const & ob);
 319         };
 320     };
 321
 322     /** \brief Config/console tree directory node
 323
 324         This node type provides the internal and root nodes of the tree. It allows to add arbitrary
 325         children and supports directory traversal.
 326
 327         Nodes are normally not instantiated manually but are created by the DirectoryNode via
 328         mkdir() or add(). Special add() members however allow externally allocated node objects.
 329
 330         Nodes may be added to the tree only once, otherwise chaos will ensue. Since nodes are always
 331         managed dynamically, there is a special ScopedDirectory proxy template which provides a
 332         DirectoryNode facade. ScopedDirectory is used if a class wants to manage it's own directory
 333         as a data member.
 334
 335         Every node is assigned a (new) name when it is added to a directory. If the directory
 336         already has an entry of that name, the name is made unique by appending a suffix of the form
 337         '-n' where n is a number starting at 1. If the name is empty, int is set to 'unnamed' and
 338         then uniquified as above. Automatically providing unique names simplifies adding
 339         configuration/console support to generic components.
 340
 341         \ingroup node_tree
 342       */
 343     class DirectoryNode : public GenericNode
 344     {
 345         SENF_LOG_CLASS_AREA();
 346         typedef std::map<std::string, GenericNode::ptr> ChildMap;
 347     public:
 348         ///////////////////////////////////////////////////////////////////////////
 349         // Types
 350
 351         typedef boost::shared_ptr<DirectoryNode> ptr;
 352         typedef boost::shared_ptr<DirectoryNode const> cptr;
 353         typedef boost::weak_ptr<DirectoryNode> weak_ptr;
 354
 355         typedef boost::iterator_range<ChildMap::const_iterator> ChildrenRange;
 356         typedef ChildMap::const_iterator child_iterator;
 357
 358         ///////////////////////////////////////////////////////////////////////////
 359         ///\name Structors and default members
 360         ///\{
 361
 362         static ptr create();            ///< Create node object.
 363                                         /**< You should normally use either mkdir() or
 364                                              ScopedDirectory instead of create() */
 365
 366         ///\}
 367         ///////////////////////////////////////////////////////////////////////////
 368         ///\name Children
 369         ///\{
 370
 371         template <class NodeType>
 372         NodeType & add(std::string const & name, boost::shared_ptr<NodeType> node);
 373                                         ///< Add node to tree
 374                                         /**< Adds the \a node to the tree as a child of \a this
 375                                              node. The node is given the name \a name. If a node of
 376                                              that name already exists, a numeric suffix of the form
 377                                              '-n' is added to the name until the name is unique. If
 378                                              \a name is empty, it is set to 'unnamed'. */
 379
 380         template <class Object>
 381         typename NodeCreateTraits<Object>::NodeType & add (std::string const & name,
 382                                                            Object const & ob);
 383                                         ///< Generic child node factory
 384                                         /**< This member is used to create a new child node of the
 385                                              current directory. The type of node created depends on
 386                                              the type of argument passed.
 387
 388                                              The node type is selected by the NodeCreateTraits
 389                                              class. To allow adding a specific node type, you need
 390                                              to provide an overload for
 391                                              <tt>senf_console_add_node</tt> which must be visible at
 392                                              when you register the new node.
 393                                              \code
 394                                              MyNodeType & senf_console_add_node(
 395                                                  DirectoryNode & dir,
 396                                                  std::string const & name,
 397                                                  MySpecialObject const & ob,
 398                                                  int)
 399                                              {
 400                                                  return dir.add(name, MyNodeType::create(ob));
 401                                              }
 402                                              \endcode
 403                                              (Do not forget the last unnamed 'int' parameter which
 404                                              is not used but serves to disambiguate the
 405                                              overloads). */
 406
 407         GenericNode::ptr remove(std::string const & name);
 408                                         ///< Remove node \a name from the tree
 409                                         /**< The returned pointer may either be discarded, which
 410                                              will automatically dispose the removed node, or it may
 411                                              be saved and/or re-attached at some other place in the
 412                                              tree. */
 413
 414         GenericNode & get(std::string const & name) const;
 415                                         ///< Get child node
 416                                         /**< \throws UnknownNodeNameException if a child \a name
 417                                                  does not exist */
 418
 419         DirectoryNode & getDirectory(std::string const & name) const;
 420                                         ///< Get directory child node
 421                                         /**< Same as operator[]
 422                                              \throws UnknownNodeNameException if a child \a name
 423                                                  does not exist.
 424                                              \throws std::bad_cast if the child \a name is not a
 425                                                  directory node. */
 426
 427         DirectoryNode & operator[](std::string const & name) const;
 428                                         ///< Get directory child node
 429                                         /**< Same as getDirectory
 430                                              \throws UnknownNodeNameException if a child \a name
 431                                                  does not exist.
 432                                              \throws std::bad_cast if the child \a name is not a
 433                                                  directory node. */
 434
 435         CommandNode & getCommand(std::string const & name) const;
 436                                         ///< Get command child node
 437                                         /**< Same as operator()
 438                                              \throws UnknownNodeNameException if a child \a name
 439                                                  does not exist
 440                                              \throws std::bad_cast if the child \a name is not a
 441                                                  command node. */
 442
 443         CommandNode & operator()(std::string const & name) const;
 444                                         ///< Get command child node
 445                                         /**< Same as getCommand()
 446                                              \throws UnknownNodeNameException if a child \a name
 447                                                  does not exist
 448                                              \throws std::bad_cast if the child \a name is not a
 449                                                  command node. */
 450
 451         DirectoryNode & mkdir(std::string const & name);
 452                                         ///< Create sub-directory node
 453
 454         ChildrenRange children() const;
 455                                         ///< Return iterator range over all children.
 456                                         /**< The returned range is sorted by child name. */
 457
 458         ///\}
 459         ///////////////////////////////////////////////////////////////////////////
 460
 461         template <class ForwardRange>
 462         GenericNode & traverse(ForwardRange const & range);
 463                                         ///< Traverse node path starting at this node
 464                                         /**< The <tt>ForwardRange::value_type</tt> must be
 465                                              (convertible to) std::string. Each range element
 466                                              constitutes a step along the node traversal.
 467
 468                                              If the range starts with an empty element, the
 469                                              traversal is started at the root() node, otherwise it
 470                                              is started at \a this node. The traversal supports '.',
 471                                              '..' and ignores further empty elements. */
 472
 473         DirectoryNode & doc(std::string const & doc);
 474                                         ///< Set node documentation
 475
 476         ptr thisptr();
 477         cptr thisptr() const;
 478
 479     protected:
 480         DirectoryNode();
 481
 482     private:
 483         void add(GenericNode::ptr node);
 484         virtual void v_help(std::ostream & output) const;
 485
 486         ChildMap children_;
 487         std::string doc_;
 488
 489         friend DirectoryNode & root();
 490     };
 491
 492     BOOST_TYPEOF_REGISTER_TYPE(DirectoryNode);
 493
 494     /// Exception: Unknown node name
 495     struct UnknownNodeNameException : public senf::Exception
 496     { UnknownNodeNameException() : senf::Exception("Unknown node name") {}};
 497
 498 #ifndef DOXYGEN
 499     template <class Type>
 500     struct NodeCreateTraits< boost::shared_ptr<Type> >
 501     {};
 502 #endif
 503
 504     struct SyntaxErrorException : public senf::Exception
 505     {
 506         explicit SyntaxErrorException(std::string const & msg = "");
 507
 508         virtual char const * what() const throw();
 509     };
 510
 511     /** \brief Config/console tree command node
 512
 513         The CommandNode is the base-class for the tree leaf nodes. Concrete command node
 514         implementations are derived from this class.
 515
 516         To execute a command, CommandNode::operator()() or CommandNode::execute() is called.
 517
 518         \ingroup node_tree
 519       */
 520     class CommandNode : public GenericNode
 521     {
 522         SENF_LOG_CLASS_AREA();
 523     public:
 524         ///////////////////////////////////////////////////////////////////////////
 525         // Types
 526
 527         typedef boost::shared_ptr<CommandNode> ptr;
 528         typedef boost::shared_ptr<CommandNode const> cptr;
 529         typedef boost::weak_ptr<CommandNode> weak_ptr;
 530
 531         ///////////////////////////////////////////////////////////////////////////
 532
 533         void execute(std::ostream & output, ParseCommandInfo const & command) const;
 534                                         ///< Execute the command
 535                                         /**< Same as operator()()
 536                                              \param[in] output stream where result messages may be
 537                                                  written to
 538                                              \param[in] arguments command arguments. This is a
 539                                                  range of ranges of ArgumentToken instances. */
 540
 541         void operator()(std::ostream & output, ParseCommandInfo const & command) const;
 542                                         ///< Execute the command
 543                                         /**< Same as execute()
 544                                              \param[in] output stream where result messages may be
 545                                                  written to
 546                                              \param[in] arguments command arguments. This is a
 547                                                  range of ranges of ArgumentToken instances. */
 548
 549         ptr thisptr();
 550         cptr thisptr() const;
 551
 552     protected:
 553         CommandNode();
 554
 555 #ifndef DOXYGEN
 556     private:
 557 #endif
 558         virtual void v_execute(std::ostream & output, ParseCommandInfo const & command) const = 0;
 559                                         ///< Called to execute the command
 560                                         /**< \param[in] output stream where result messages may be
 561                                                  written to
 562                                              \param[in] arguments command arguments. This is a
 563                                                  range of ranges of ArgumentToken instances. */
 564
 565     private:
 566     };
 567
 568     /** \brief Most simple CommandNode implementation
 569
 570         This CommandNode implementation simply forwards the \a output and \a arguments arguments to
 571         an arbitrary callback.
 572
 573         \ingroup node_tree
 574      */
 575     class SimpleCommandNode : public CommandNode
 576     {
 577         SENF_LOG_CLASS_AREA();
 578     public:
 579         ///////////////////////////////////////////////////////////////////////////
 580         // Types
 581
 582         typedef boost::shared_ptr<SimpleCommandNode> ptr;
 583         typedef boost::shared_ptr<SimpleCommandNode const> cptr;
 584         typedef boost::weak_ptr<SimpleCommandNode> weak_ptr;
 585
 586         typedef boost::function<void (std::ostream &, ParseCommandInfo const &)> Function;
 587
 588         ///////////////////////////////////////////////////////////////////////////
 589         ///\name Structors and default members
 590         ///\{
 591
 592         static ptr create(Function const & fn);
 593
 594         ///\}
 595         ///////////////////////////////////////////////////////////////////////////
 596
 597         ptr thisptr();
 598         cptr thisptr() const;
 599
 600         SimpleCommandNode & doc(std::string const & doc);
 601
 602     protected:
 603         SimpleCommandNode(Function const & fn);
 604
 605     private:
 606         virtual void v_help(std::ostream & output) const;
 607         virtual void v_execute(std::ostream & output, ParseCommandInfo const & command) const;
 608
 609
 610         Function fn_;
 611         std::string doc_;
 612     };
 613
 614 #ifndef DOXYGEN
 615     template <class Function>
 616     SimpleCommandNode & senf_console_add_node(DirectoryNode & node, std::string const & name,
 617                                               Function const & fn, ...);
 618 #endif
 619
 620     BOOST_TYPEOF_REGISTER_TYPE(SimpleCommandNode);
 621
 622     DirectoryNode & root();
 623
 624 }}
 625
 626 ///////////////////////////////hh.e////////////////////////////////////////
 627 #include "Node.cci"
 628 #include "Node.ct"
 629 #include "Node.cti"
 630 #endif
 631
 632 \f
 633 // Local Variables:
 634 // mode: c++
 635 // fill-column: 100
 636 // comment-column: 40
 637 // c-file-style: "senf"
 638 // indent-tabs-mode: nil
 639 // ispell-local-dictionary: "american"
 640 // compile-command: "scons -u test"
 641 // End: