Utils/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 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     \li senf::console::LinkNode is a link to another node. It works much like a symlink on POSIX
 104         systems.
 105
 106     senf::console::CommandNode is the base-class of all command nodes of which there are several,
 107     depending on the type of command.
 108
 109     There is a single root node, the senf::console::DirectoryNode called senf::console::root(). From
 110     this node, the tree is traversed.
 111
 112     All nodes are allocated on the heap and are managed using a smart pointer.
 113
 114     \subsection console_manipulate Manipulating the node tree
 115
 116     There are several ways to add nodes to the tree:
 117
 118     \li A senf::console::DirectoryNode can be added using senf::console::DirectoryNode::mkdir().
 119     \li An arbitrary node can be created and then (possibly later) added to the tree using the
 120         corresponding senf::console::DirectoryNode::add() overload.
 121     \li A senf::console::CommandNode is normally added to the tree by directly adding a callback
 122         using one of the overloaded senf::console::DirectoryNode::add() members. See \ref
 123         console_commands.
 124     \li A senf::console::LinkNode is created by senf::console::DirectoryNode::link()
 125
 126     When directly adding a node callback, the type of node added depends on the type of
 127     callback. The callback types which can be added are listed at \ref console_callbacks.
 128
 129     \code
 130     void callback(std::ostream & os, senf::console::ParseCommandInfo const & command) { ... }
 131     // ...
 132     myDirectory.add("foo",&callback);
 133     \endcode
 134
 135     Every node is identified among it's siblings by it's name. The name of the node is set when
 136     adding the node to the tree. If the name is empty or non-unique, a unique name will be
 137     automatically provided.
 138
 139     To remove a node from the tree, just use the nodes senf::console::GenericNode::unlink() or the
 140     parents senf::console::DirectoryNode::remove() member. This call removes the node from it's
 141     parent and returns a (smart) node pointer.
 142
 143     \li If you ignore the return value, the node (and it's children) will be deleted.
 144     \li Alternatively, you may store away the node and re-attach it later.
 145     \li An node (or subtree) can be moved to a different place by unlinking the node at it's old
 146         place and re-adding it at it's new location.
 147     \li To rename a node, unlink and re-add it with a different name.
 148
 149     \code
 150     myDirectory.add("bar", myDirectory.remove("foo"));
 151     \endcode
 152
 153     \subsection console_node_param Assigning additional node parameters
 154
 155     Depending on the node type added, additional node parameters may be set. For example, every node
 156     has a documentation parameter which is used by the online-help system. To assign these
 157     parameters, the node exposes corresponding member functions. Since
 158     senf::console::DirectoryNode::add() returns the newly added node by reference, additional
 159     parameters may just be added to the end of the add command:
 160     \code
 161     myDirectory.add("foo",&fooCallback).doc("The foo method");
 162     \endcode
 163     Since the parameter setters all return the node reference, additional parameters may just be
 164     added to the end of the command.
 165
 166     \subsection console_tree_traverse Traversing the tree
 167
 168     The simplest way to access tree elements is to save the return value of the
 169     senf::console::DirectoryNode::add() members. However, saving the reference will not ensure, that
 170     the node is not removed. If the node might be removed from the tree, you should use a smart
 171     pointer (either <tt>ptr</tt> or <tt>weak_ptr</tt>) to hold the node.
 172
 173     Another possibility is to traverse the tree explicitly. For this purpose, the operators '[]' and
 174     '()' have been overloaded in senf::console::DirectoryNode.
 175     \code
 176     senf::console::root().getDirectory("myDirectory").getCommand("foo")
 177     \\ or more concise but otherwise completely identical
 178     senf::console::root()["myDirectory"]("foo")
 179     \endcode
 180
 181     getDirectory and the '[]' operator will return a senf::console::DirectoryNode whereas getCommand
 182     and the '()' operator will return a senf::console::CommandNode. If the node is not found or is
 183     not of the correct type, an exception will be raised.
 184
 185     \section console_object_dir Assigning a directory to an object instance
 186
 187     Most objects will register several commands. So it makes sense for these objects to manage their
 188     own directory. Since directories are however allocated on the heap, they cannot be directly
 189     added to a class. To facilitate this usage, the senf::console::ScopedDirectory is used. This
 190     class provides a senf::console::DirectoryNode facade. Internally, it automatically creates a
 191     senf::console::DirectoryNode to which all calls are forwarded.
 192
 193     The senf::console::ScopedDirectory member should be declared public. This allows the user of the
 194     class to add the node to the tree.
 195  */
 196
 197 #ifndef HH_SENF_Scheduler_Console_Node_
 198 #define HH_SENF_Scheduler_Console_Node_ 1
 199
 200 // Custom includes
 201 #include <map>
 202 #include <boost/shared_ptr.hpp>
 203 #include <boost/weak_ptr.hpp>
 204 #include <boost/enable_shared_from_this.hpp>
 205 #include <boost/utility.hpp>
 206 #include <boost/range/iterator_range.hpp>
 207 #include <boost/typeof/typeof.hpp>
 208 #include <boost/type_traits/remove_reference.hpp>
 209 #include "../../Utils/Exception.hh"
 210 #include "../../Utils/mpl.hh"
 211 #include "../../Utils/Logger/SenfLog.hh"
 212 #include "../../Utils/type_traits.hh"
 213 #include "Parse.hh"
 214
 215 //#include "Node.mpp"
 216 ///////////////////////////////hh.p////////////////////////////////////////
 217
 218 namespace senf {
 219 namespace console {
 220
 221     class LinkNode;
 222     class DirectoryNode;
 223     class CommandNode;
 224
 225     DirectoryNode & root();
 226
 227     /** \brief Config/console node tree base-class
 228
 229         GenericNode is the base class of all node objects. There are two basic node types derived
 230         from GenericNode:  DirectoryNode and CommandNode.
 231
 232         All nodes are dynamically allocated and automatically managed using reference counting.
 233
 234         All nodes are normally linked into a single tree which root node is
 235         senf::console::root(). Nodes may however be orphaned (not linked to the tree) either
 236         directly (the node has no parent) or indirectly (the node has a parent but is part of an
 237         orphaned subtree which is not linked to the root node).
 238
 239         Every active (non-orphaned) node (except the root() node) has a non-empty node name. This
 240         name is assigned to the node when adding the node to the tree.
 241
 242         \ingroup node_tree
 243       */
 244     class GenericNode
 245         : public boost::enable_shared_from_this<GenericNode>
 246     {
 247         SENF_LOG_CLASS_AREA();
 248     public:
 249         ///////////////////////////////////////////////////////////////////////////
 250         // Types
 251
 252         typedef boost::shared_ptr<GenericNode> ptr;
 253         typedef boost::shared_ptr<GenericNode const> cptr;
 254         typedef boost::weak_ptr<GenericNode> weak_ptr;
 255
 256         ///////////////////////////////////////////////////////////////////////////
 257
 258         virtual ~GenericNode();
 259
 260         std::string const & name() const; ///< Node name
 261         boost::shared_ptr<DirectoryNode> parent() const; ///< Parent node
 262                                         /**< May be null, if the node is the root node or if it is
 263                                              not linked to the tree */
 264
 265         std::string path() const;       ///< Node path
 266                                         /**< The node path is built by joining the names of all
 267                                              parent nodes with '/' chars. */
 268         std::string path(DirectoryNode const & root) const;
 269                                         ///< Node path up to \a root
 270                                         /**< The node path is built by joining the names of all
 271                                              parent nodes up to \a root with '/' chars. */
 272
 273         ptr unlink();                   ///< Remove node from it's parent directory
 274                                         /**< You may either discard the return value and thereby
 275                                              dispose the node or may re-attach the node at some
 276                                              other place using DirectoryNode::add(). */
 277
 278         bool active() const;            ///< \c true, if node is attached to the root() node
 279
 280         void help(std::ostream & output) const; /// Write help info to \a output
 281
 282         ptr thisptr();                  ///< Get smart pointer to node
 283         cptr thisptr() const;           ///< Get smart pointer to node (const)
 284
 285         bool isChildOf(DirectoryNode & parent) const;
 286                                         ///< \c true, if node is a child of \a parent
 287                                         /**< Will also return \c true, if \a parent is the current
 288                                              node. */
 289
 290         bool operator== (GenericNode & other) const;
 291                                         ///< \c true, if this and \a other are the same node
 292         bool operator!= (GenericNode & other) const;
 293                                         ///< \c true, if this and \a other are different nodes
 294
 295         bool isDirectory() const;       ///< \c true, if this is a directory node
 296         bool isLink() const;            ///< \c true, if this is a link node
 297         bool isCommand() const;         ///< \c true, if this is a command node
 298
 299         GenericNode const & followLink() const; ///< Follow link if \c this node is a link node
 300         GenericNode & followLink();     ///< Follow link if \c this node is a link node
 301
 302     protected:
 303         GenericNode();
 304
 305         void name(std::string const & name);
 306
 307 #ifndef DOXYGEN
 308     private:
 309 #else
 310     public:
 311 #endif
 312         virtual void v_help(std::ostream & output) const = 0;
 313                                         ///< Provide help information
 314                                         /**< This member must be implemented in derived classes
 315                                              to provide node specific help information. */
 316
 317     private:
 318         std::string name_;
 319         DirectoryNode * parent_;
 320
 321         friend class DirectoryNode;
 322     };
 323
 324     /** \brief Config/console tree link node
 325
 326         A LinkNode references another node and provides an additional alias name for that node. A
 327         LinkNode works like a mixture of UNIX symlinks and hardlinks: It is an explicit link like a
 328         UNIX symlink but references another node directly (not via it's path) like a UNIX
 329         hardlink. Therefore, a LinkNode works across chroot().
 330       */
 331     class LinkNode
 332         : public GenericNode
 333     {
 334     public:
 335         ///////////////////////////////////////////////////////////////////////////
 336         // Types
 337
 338         typedef boost::shared_ptr<LinkNode> ptr;
 339         typedef boost::shared_ptr<LinkNode const> cptr;
 340         typedef boost::weak_ptr<LinkNode> weak_ptr;
 341
 342         ///////////////////////////////////////////////////////////////////////////
 343         ///\name Structors and default members
 344         ///@{
 345
 346         static ptr create(GenericNode & node); ///< Create new link node.
 347                                         /**< You should normally use DirectoryNode::link() to
 348                                              create a link node. */
 349
 350         ///@}
 351         ///////////////////////////////////////////////////////////////////////////
 352
 353         GenericNode & follow() const;   ///< Access the referenced node
 354
 355     protected:
 356
 357     private:
 358         explicit LinkNode(GenericNode & node);
 359
 360         virtual void v_help(std::ostream &) const;
 361
 362         GenericNode::ptr node_;
 363     };
 364
 365     class SimpleCommandNode;
 366
 367     /** \brief Internal: Node creation helper traits
 368
 369         This class is used internally to find out the type of node to create for a specific argument
 370         type.
 371      */
 372     template <class Object>
 373     struct NodeCreateTraits
 374     {
 375         typedef BOOST_TYPEOF_TPL( senf_console_add_node(
 376                                       * static_cast<DirectoryNode *>(0),
 377                                       * static_cast<std::string const *>(0),
 378                                       * static_cast<Object *>(0),
 379                                       0) ) base_type;
 380         typedef typename senf::remove_cvref<base_type>::type value_type;
 381
 382         typedef typename value_type::node_type NodeType;
 383         typedef typename value_type::return_type result_type;
 384
 385         /// Internal
 386         struct Creator {
 387             static result_type create(DirectoryNode & node, std::string const & name,
 388                                       Object & ob);
 389         };
 390     };
 391
 392     /** \brief Config/console tree directory node
 393
 394         This node type provides the internal and root nodes of the tree. It allows to add arbitrary
 395         children and supports directory traversal.
 396
 397         Nodes are normally not instantiated manually but are created by the DirectoryNode via
 398         mkdir() or add(). Special add() members however allow externally allocated node objects.
 399
 400         Nodes may be added to the tree only once, otherwise chaos will ensue. Since nodes are always
 401         managed dynamically, there is a special ScopedDirectory proxy template which provides a
 402         DirectoryNode facade. ScopedDirectory is used if a class wants to manage it's own directory
 403         as a data member.
 404
 405         Every node is assigned a (new) name when it is added to a directory. If the directory
 406         already has an entry of that name, the name is made unique by appending a suffix of the form
 407         '-n' where n is a number starting at 1. If the name is empty, int is set to 'unnamed' and
 408         then uniquified as above. Automatically providing unique names simplifies adding
 409         configuration/console support to generic components.
 410
 411         \ingroup node_tree
 412       */
 413     class DirectoryNode : public GenericNode
 414     {
 415         SENF_LOG_CLASS_AREA();
 416         typedef std::map<std::string, GenericNode::ptr> ChildMap;
 417     public:
 418         ///////////////////////////////////////////////////////////////////////////
 419         // Types
 420
 421         typedef boost::shared_ptr<DirectoryNode> ptr;
 422         typedef boost::shared_ptr<DirectoryNode const> cptr;
 423         typedef boost::weak_ptr<DirectoryNode> weak_ptr;
 424
 425         typedef boost::iterator_range<ChildMap::const_iterator> ChildrenRange;
 426         typedef ChildMap::const_iterator child_iterator;
 427
 428         typedef DirectoryNode node_type;
 429         typedef DirectoryNode & return_type;
 430
 431         ///////////////////////////////////////////////////////////////////////////
 432         ///\name Structors and default members
 433         ///\{
 434
 435         static ptr create();            ///< Create node object.
 436                                         /**< You should normally use either mkdir() or
 437                                              ScopedDirectory instead of create() */
 438
 439         ///\}
 440         ///////////////////////////////////////////////////////////////////////////
 441         ///\name Children
 442         ///\{
 443
 444         template <class NodeType>
 445         NodeType & add(std::string const & name, boost::shared_ptr<NodeType> node);
 446                                         ///< Add node to tree
 447                                         /**< Adds the \a node to the tree as a child of \a this
 448                                              node. The node is given the name \a name. If a node of
 449                                              that name already exists, a numeric suffix of the form
 450                                              '-n' is added to the name until the name is unique. If
 451                                              \a name is empty, it is set to 'unnamed'. */
 452
 453         template <class Object>
 454         typename NodeCreateTraits<Object>::result_type add(std::string const & name,
 455                                                            Object const & ob);
 456                                         ///< Generic child node factory
 457                                         /**< This member is used to create a new child node of the
 458                                              current directory. The type of node created depends on
 459                                              the type of argument passed.
 460
 461                                              The node type is selected by the NodeCreateTraits
 462                                              class. To allow adding a specific node type, you need
 463                                              to provide an overload for
 464                                              <tt>senf_console_add_node</tt> which must be visible at
 465                                              when you register the new node.
 466                                              \code
 467                                              MyNodeType & senf_console_add_node(
 468                                                  DirectoryNode & dir,
 469                                                  std::string const & name,
 470                                                  MySpecialObject const & ob,
 471                                                  int)
 472                                              {
 473                                                  return dir.add(name, MyNodeType::create(ob));
 474                                              }
 475                                              \endcode
 476                                              (Do not forget the last unnamed 'int' parameter which
 477                                              is not used but serves to disambiguate the
 478                                              overloads). */
 479
 480         template <class Object>
 481         typename NodeCreateTraits<Object>::result_type add(std::string const & name,
 482                                                            Object & ob);
 483                                         ///< Generic child node factory
 484                                         /**< \see add() */
 485
 486         GenericNode::ptr remove(std::string const & name);
 487                                         ///< Remove node \a name from the tree
 488                                         /**< The returned pointer may either be discarded, which
 489                                              will automatically dispose the removed node, or it may
 490                                              be saved and/or re-attached at some other place in the
 491                                              tree. */
 492
 493         bool hasChild(std::string const & name) const;
 494                                         ///< \c true, if there is a child with name \a name
 495
 496         GenericNode & get(std::string const & name) const;
 497                                         ///< Get child node automatically dereferencing links
 498                                         /**< \throws UnknownNodeNameException if a child \a name
 499                                                  does not exist */
 500         GenericNode & getLink(std::string const & name) const;
 501                                         ///< Get child node without dereferencing links
 502                                         /**< \throws UnknownNodeNameException if a child \a name
 503                                                  does not exist */
 504
 505         DirectoryNode & getDirectory(std::string const & name) const;
 506                                         ///< Get directory child node (dereferencing links)
 507                                         /**< Same as operator[]
 508                                              \throws UnknownNodeNameException if a child \a name
 509                                                  does not exist.
 510                                              \throws std::bad_cast if the child \a name is not a
 511                                                  directory node. */
 512
 513         DirectoryNode & operator[](std::string const & name) const;
 514                                         ///< Get directory child node (dereferencing links)
 515                                         /**< Same as getDirectory
 516                                              \throws UnknownNodeNameException if a child \a name
 517                                                  does not exist.
 518                                              \throws std::bad_cast if the child \a name is not a
 519                                                  directory node. */
 520
 521         CommandNode & getCommand(std::string const & name) const;
 522                                         ///< Get command child node (dereferencing links)
 523                                         /**< Same as operator()
 524                                              \throws UnknownNodeNameException if a child \a name
 525                                                  does not exist
 526                                              \throws std::bad_cast if the child \a name is not a
 527                                                  command node. */
 528
 529         CommandNode & operator()(std::string const & name) const;
 530                                         ///< Get command child node (dereferencing links)
 531                                         /**< Same as getCommand()
 532                                              \throws UnknownNodeNameException if a child \a name
 533                                                  does not exist
 534                                              \throws std::bad_cast if the child \a name is not a
 535                                                  command node. */
 536
 537         DirectoryNode & mkdir(std::string const & name);
 538                                         ///< Create sub-directory node
 539
 540         ChildrenRange children() const; ///< Return iterator range over all children.
 541                                         /**< The returned range is sorted by child name. */
 542
 543         ChildrenRange completions(std::string const & s) const;
 544                                         ///< Return iterator range of completions for \a s
 545                                         /**< The returned range is sorted by child name. */
 546
 547         void link(std::string const & name, GenericNode & target);
 548                                         ///< Create a child node which is a link to target. \a s
 549                                         /**< The new link node will be a child of the node for which this member function is called. */
 550
 551         ///\}
 552         ///////////////////////////////////////////////////////////////////////////
 553
 554         DirectoryNode & doc(std::string const & doc); ///< Set node documentation
 555
 556         ptr thisptr();
 557         cptr thisptr() const;
 558
 559     protected:
 560         DirectoryNode();
 561
 562     private:
 563         void add(GenericNode::ptr node);
 564         virtual void v_help(std::ostream & output) const;
 565
 566         ChildMap children_;
 567         std::string doc_;
 568
 569         friend DirectoryNode & root();
 570     };
 571
 572     /// Exception: Unknown node name
 573     struct UnknownNodeNameException : public senf::Exception
 574     { UnknownNodeNameException() : senf::Exception("Unknown node name") {}};
 575
 576 #ifndef DOXYGEN
 577     template <class Type>
 578     struct NodeCreateTraits< boost::shared_ptr<Type> >
 579     {};
 580 #endif
 581
 582     /** \brief Config/console tree command node
 583
 584         The CommandNode is the base-class for the tree leaf nodes. Concrete command node
 585         implementations are derived from this class.
 586
 587         To execute a command, CommandNode::operator()() or CommandNode::execute() is called.
 588
 589         Subclass instances of this node type are automatically created when adding commands to the
 590         tree. See \ref console_commands.
 591
 592         \ingroup node_tree
 593       */
 594     class CommandNode : public GenericNode
 595     {
 596         SENF_LOG_CLASS_AREA();
 597     public:
 598         ///////////////////////////////////////////////////////////////////////////
 599         // Types
 600
 601         typedef boost::shared_ptr<CommandNode> ptr;
 602         typedef boost::shared_ptr<CommandNode const> cptr;
 603         typedef boost::weak_ptr<CommandNode> weak_ptr;
 604
 605         ///////////////////////////////////////////////////////////////////////////
 606
 607         void execute(std::ostream & output, ParseCommandInfo const & command) const;
 608                                         ///< Execute the command
 609                                         /**< Same as operator()()
 610                                              \param[in] output stream where result messages may be
 611                                                  written to
 612                                              \param[in] arguments command arguments. This is a
 613                                                  range of ranges of Token instances. */
 614
 615         void operator()(std::ostream & output, ParseCommandInfo const & command) const;
 616                                         ///< Execute the command
 617                                         /**< Same as execute()
 618                                              \param[in] output stream where result messages may be
 619                                                  written to
 620                                              \param[in] arguments command arguments. This is a
 621                                                  range of ranges of Token instances. */
 622
 623         ptr thisptr();
 624         cptr thisptr() const;
 625
 626     protected:
 627         CommandNode();
 628
 629 #ifndef DOXYGEN
 630     private:
 631 #endif
 632         virtual void v_execute(std::ostream & output, ParseCommandInfo const & command) const = 0;
 633                                         ///< Called to execute the command
 634                                         /**< \param[in] output stream where result messages may be
 635                                                  written to
 636                                              \param[in] arguments command arguments. This is a
 637                                                  range of ranges of Token instances. */
 638
 639     private:
 640     };
 641
 642     /** \brief Most simple CommandNode implementation
 643
 644         This CommandNode implementation simply forwards the \a output and \a arguments arguments to
 645         an arbitrary callback. Thus, it allows to add callbacks with the signature
 646         \code
 647         void callback(std::ostream & os, senf::console::ParseCommandInfo const & command)
 648         { ... }
 649         \endcode
 650         to the tree.
 651
 652         \ingroup console_commands
 653      */
 654     class SimpleCommandNode : public CommandNode
 655     {
 656         SENF_LOG_CLASS_AREA();
 657     public:
 658         ///////////////////////////////////////////////////////////////////////////
 659         // Types
 660
 661         typedef boost::shared_ptr<SimpleCommandNode> ptr;
 662         typedef boost::shared_ptr<SimpleCommandNode const> cptr;
 663         typedef boost::weak_ptr<SimpleCommandNode> weak_ptr;
 664
 665         typedef boost::function<void (std::ostream &, ParseCommandInfo const &)> Function;
 666
 667         typedef SimpleCommandNode node_type;
 668         typedef SimpleCommandNode & return_type;
 669
 670         ///////////////////////////////////////////////////////////////////////////
 671         ///\name Structors and default members
 672         ///\{
 673
 674         static ptr create(Function const & fn);
 675
 676         ///\}
 677         ///////////////////////////////////////////////////////////////////////////
 678
 679         ptr thisptr();
 680         cptr thisptr() const;
 681
 682         SimpleCommandNode & doc(std::string const & doc);
 683
 684     protected:
 685         SimpleCommandNode(Function const & fn);
 686
 687     private:
 688         virtual void v_help(std::ostream & output) const;
 689         virtual void v_execute(std::ostream & output, ParseCommandInfo const & command) const;
 690
 691
 692         Function fn_;
 693         std::string doc_;
 694     };
 695
 696 #ifndef DOXYGEN
 697
 698     SimpleCommandNode & senf_console_add_node(DirectoryNode & node, std::string const & name,
 699                                               SimpleCommandNode::Function fn, int);
 700
 701 #endif
 702
 703 }}
 704
 705 #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
 706
 707 BOOST_TYPEOF_REGISTER_TYPE(senf::console::DirectoryNode)
 708 BOOST_TYPEOF_REGISTER_TYPE(senf::console::SimpleCommandNode)
 709
 710
 711 ///////////////////////////////hh.e////////////////////////////////////////
 712 #include "Node.cci"
 713 //#include "Node.ct"
 714 #include "Node.cti"
 715 #endif
 716
 717
 718 // Local Variables:
 719 // mode: c++
 720 // fill-column: 100
 721 // comment-column: 40
 722 // c-file-style: "senf"
 723 // indent-tabs-mode: nil
 724 // ispell-local-dictionary: "american"
 725 // compile-command: "scons -u test"
 726 // End: