X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Console%2FNode.hh;h=0349831a82b2c7fe572900fa07a69ae451a9cba9;hb=fa5eaa97c8593e3587c87f25adb14f7f91f31f37;hp=961a1b8bc38867a7a14fae0cf1bb14a6f5c030d9;hpb=30c1daf8a1c404209210f76a9a54bcfde443603b;p=senf.git diff --git a/Console/Node.hh b/Console/Node.hh index 961a1b8..0349831 100644 --- a/Console/Node.hh +++ b/Console/Node.hh @@ -23,7 +23,7 @@ /** \file \brief Node public header */ -/** \defgroup node_tree The console/config file-system node tree +/** \defgroup node_tree The node tree The console/config node tree is the central data-structure of the library. Into this tree, all commands and parameters are entered. The tree is then exposed using a file-system like @@ -38,7 +38,7 @@ \code // Define callback function. - void mycommand(std::ostream & os, senf::console::Arguments const & args) + void mycommand(std::ostream & os, senf::console::ParseCommandInfo const & command) { // ... os << "!! Important message ...\n"; @@ -61,7 +61,7 @@ .doc("Do the member operation"); } - void member(std::ostream & os, senf::console::Arguments const & args) + void member(std::ostream & os, senf::console::ParseCommandInfo const & command) { // ... } @@ -117,13 +117,14 @@ \li An arbitrary node can be created and then (possibly later) added to the tree using the corresponding senf::console::DirectoryNode::add() overload. \li A senf::console::CommandNode is normally added to the tree by directly adding a callback - using one of the overloaded senf::console::DirectoryNode::add() members. + using one of the overloaded senf::console::DirectoryNode::add() members. See \ref + console_commands. When directly adding a node callback, the type of node added depends on the type of callback. The callback types which can be added are listed at \ref console_callbacks. \code - void callback(std::ostream & os, senf::console::Arguments const & args) { ... } + void callback(std::ostream & os, senf::console::ParseCommandInfo const & command) { ... } // ... myDirectory.add("foo",&callback); \endcode @@ -132,8 +133,9 @@ adding the node to the tree. If the name is empty or non-unique, a unique name will be automatically provided. - To remove a node from the tree, just use the nodes senf::console::GenericNode::unlink() - member. This call removes the node from it's parent and returns a (smart) node pointer. + To remove a node from the tree, just use the nodes senf::console::GenericNode::unlink() or the + parents senf::console::DirectoryNode::remove() member. This call removes the node from it's + parent and returns a (smart) node pointer. \li If you ignore the return value, the node (and it's children) will be deleted. \li Alternatively, you may store away the node and re-attach it later. @@ -142,7 +144,7 @@ \li To rename a node, unlink and re-add it with a different name. \code - myDirectory.add("bar", myDirectory("foo").unlink()); + myDirectory.add("bar", myDirectory.remove("foo")); \endcode \subsection console_node_param Assigning additional node parameters @@ -168,11 +170,14 @@ Another possibility is to traverse the tree explicitly. For this purpose, the operators '[]' and '()' have been overloaded in senf::console::DirectoryNode. \code + senf::console::root().getDirectory("myDirectory").getCommand("foo") + \\ or more concise but otherwise completely identical senf::console::root()["myDirectory"]("foo") \endcode - The '[]' operator will return a senf::console::DirectoryNode whereas '()' will return a - senf::console::CommandNode. If the node is not found or is not of the correct type, an exception - will be raised. + + getDirectory and the '[]' operator will return a senf::console::DirectoryNode whereas getCommand + and the '()' operator will return a senf::console::CommandNode. If the node is not found or is + not of the correct type, an exception will be raised. \section console_object_dir Assigning a directory to an object instance @@ -201,13 +206,12 @@ #include "../Utils/Exception.hh" #include "../Utils/mpl.hh" #include "../Utils/Logger/SenfLog.hh" +#include "../Utils/type_traits.hh" #include "Parse.hh" //#include "Node.mpp" ///////////////////////////////hh.p//////////////////////////////////////// -#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() - namespace senf { namespace console { @@ -303,15 +307,17 @@ namespace console { typedef BOOST_TYPEOF_TPL( senf_console_add_node( * static_cast(0), * static_cast(0), - * static_cast(0), - 0) ) result_type; + * static_cast(0), + 0) ) base_type; + typedef typename senf::remove_cvref::type value_type; - typedef typename boost::remove_reference::type NodeType; + typedef typename value_type::node_type NodeType; + typedef typename value_type::return_type result_type; /// Internal struct Creator { - static NodeType & create(DirectoryNode & node, std::string const & name, - Object const & ob); + static result_type create(DirectoryNode & node, std::string const & name, + Object & ob); }; }; @@ -351,6 +357,9 @@ namespace console { typedef boost::iterator_range ChildrenRange; typedef ChildMap::const_iterator child_iterator; + typedef DirectoryNode node_type; + typedef DirectoryNode & return_type; + /////////////////////////////////////////////////////////////////////////// ///\name Structors and default members ///\{ @@ -374,7 +383,7 @@ namespace console { \a name is empty, it is set to 'unnamed'. */ template - typename NodeCreateTraits::NodeType & add (std::string const & name, + typename NodeCreateTraits::result_type add(std::string const & name, Object const & ob); ///< Generic child node factory /**< This member is used to create a new child node of the @@ -400,6 +409,12 @@ namespace console { is not used but serves to disambiguate the overloads). */ + template + typename NodeCreateTraits::result_type add(std::string const & name, + Object & ob); + ///< Generic child node factory + /**< \see add() */ + GenericNode::ptr remove(std::string const & name); ///< Remove node \a name from the tree /**< The returned pointer may either be discarded, which @@ -407,46 +422,74 @@ namespace console { be saved and/or re-attached at some other place in the tree. */ + bool hasChild(std::string const & name) const; + ///< \c true, if there is a child with name \a name + + GenericNode & get(std::string const & name) const; + ///< Get child node + /**< \throws UnknownNodeNameException if a child \a name + does not exist */ + + DirectoryNode & getDirectory(std::string const & name) const; + ///< Get directory child node + /**< Same as operator[] + \throws UnknownNodeNameException if a child \a name + does not exist. + \throws std::bad_cast if the child \a name is not a + directory node. */ + DirectoryNode & operator[](std::string const & name) const; ///< Get directory child node - /**< \throws UnknownNodeNameException if a child \a name + /**< Same as getDirectory + \throws UnknownNodeNameException if a child \a name does not exist. \throws std::bad_cast if the child \a name is not a directory node. */ - CommandNode & operator()(std::string const & name) const; + CommandNode & getCommand(std::string const & name) const; ///< Get command child node - /**< \throws UnknownNodeNameException if a child \a name + /**< Same as operator() + \throws UnknownNodeNameException if a child \a name does not exist \throws std::bad_cast if the child \a name is not a command node. */ - GenericNode & get(std::string const & name) const; - ///< Get child node - /**< \throws UnknownNodeNameException if a child \a name - does not exist */ + CommandNode & operator()(std::string const & name) const; + ///< Get command child node + /**< Same as getCommand() + \throws UnknownNodeNameException if a child \a name + does not exist + \throws std::bad_cast if the child \a name is not a + command node. */ DirectoryNode & mkdir(std::string const & name); ///< Create sub-directory node - ChildrenRange children() const; - ///< Return iterator range over all children. + ChildrenRange children() const; ///< Return iterator range over all children. + /**< The returned range is sorted by child name. */ + + ChildrenRange completions(std::string const & s) const; + ///< Return iterator range of completions for \a s /**< The returned range is sorted by child name. */ ///\} /////////////////////////////////////////////////////////////////////////// template - GenericNode & traverse(ForwardRange const & range); + GenericNode & traverse(ForwardRange const & range, bool autocomplete=false); ///< Traverse node path starting at this node - /**< The FordwareRange::value_type must be + /**< The ForwardRange::value_type must be (convertible to) std::string. Each range element constitutes a step along the node traversal. If the range starts with an empty element, the traversal is started at the root() node, otherwise it is started at \a this node. The traversal supports '.', - '..' and ignores further empty elements. */ + '..' and ignores further empty elements. + + If \a autocomplete is set to \c true, invalid path + components which can be uniquely completed will be + completed automatically while traversing the tree. */ DirectoryNode & doc(std::string const & doc); ///< Set node documentation @@ -467,8 +510,6 @@ namespace console { friend DirectoryNode & root(); }; - BOOST_TYPEOF_REGISTER_TYPE(DirectoryNode); - /// Exception: Unknown node name struct UnknownNodeNameException : public senf::Exception { UnknownNodeNameException() : senf::Exception("Unknown node name") {}}; @@ -479,20 +520,15 @@ namespace console { {}; #endif - struct SyntaxErrorException : public senf::Exception - { - explicit SyntaxErrorException(std::string const & msg = ""); - - virtual char const * what() const throw(); - }; - /** \brief Config/console tree command node The CommandNode is the base-class for the tree leaf nodes. Concrete command node implementations are derived from this class. - To execute a command, CommandNode::operator()() is called. This abstract virtual function - must be implemented in a derived class. + To execute a command, CommandNode::operator()() or CommandNode::execute() is called. + + Subclass instances of this node type are automatically created when adding commands to the + tree. See \ref console_commands. \ingroup node_tree */ @@ -507,13 +543,20 @@ namespace console { typedef boost::shared_ptr cptr; typedef boost::weak_ptr weak_ptr; - typedef ParseCommandInfo::ArgumentsRange Arguments; - /////////////////////////////////////////////////////////////////////////// - void operator()(std::ostream & output, Arguments const & arguments) const; + void execute(std::ostream & output, ParseCommandInfo const & command) const; ///< Execute the command - /**< \param[in] output stream where result messages may be + /**< Same as operator()() + \param[in] output stream where result messages may be + written to + \param[in] arguments command arguments. This is a + range of ranges of ArgumentToken instances. */ + + void operator()(std::ostream & output, ParseCommandInfo const & command) const; + ///< Execute the command + /**< Same as execute() + \param[in] output stream where result messages may be written to \param[in] arguments command arguments. This is a range of ranges of ArgumentToken instances. */ @@ -527,7 +570,7 @@ namespace console { #ifndef DOXYGEN private: #endif - virtual void v_execute(std::ostream & output, Arguments const & arguments) const = 0; + virtual void v_execute(std::ostream & output, ParseCommandInfo const & command) const = 0; ///< Called to execute the command /**< \param[in] output stream where result messages may be written to @@ -537,14 +580,17 @@ namespace console { private: }; - typedef CommandNode::Arguments Arguments; - /** \brief Most simple CommandNode implementation This CommandNode implementation simply forwards the \a output and \a arguments arguments to - an arbitrary callback. + an arbitrary callback. Thus, it allows to add callbacks with the signature + \code + void callback(std::ostream & os, senf::console::ParseCommandInfo const & command) + { ... } + \endcode + to the tree. - \ingroup node_tree + \ingroup console_commands */ class SimpleCommandNode : public CommandNode { @@ -557,7 +603,10 @@ namespace console { typedef boost::shared_ptr cptr; typedef boost::weak_ptr weak_ptr; - typedef boost::function Function; + typedef boost::function Function; + + typedef SimpleCommandNode node_type; + typedef SimpleCommandNode & return_type; /////////////////////////////////////////////////////////////////////////// ///\name Structors and default members @@ -578,7 +627,7 @@ namespace console { private: virtual void v_help(std::ostream & output) const; - virtual void v_execute(std::ostream & output, Arguments const & arguments) const; + virtual void v_execute(std::ostream & output, ParseCommandInfo const & command) const; Function fn_; @@ -586,17 +635,22 @@ namespace console { }; #ifndef DOXYGEN - template + SimpleCommandNode & senf_console_add_node(DirectoryNode & node, std::string const & name, - Function const & fn, ...); -#endif + SimpleCommandNode::Function fn, int); - BOOST_TYPEOF_REGISTER_TYPE(SimpleCommandNode); +#endif DirectoryNode & root(); }} +#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() + +BOOST_TYPEOF_REGISTER_TYPE(senf::console::DirectoryNode) +BOOST_TYPEOF_REGISTER_TYPE(senf::console::SimpleCommandNode) + + ///////////////////////////////hh.e//////////////////////////////////////// #include "Node.cci" #include "Node.ct"