SomeClass() : dir(this)
{
+ namespace fty = senf::console::factory;
// You may document the directory here or later when adding it to the tree
dir.doc("Manager for something");
// Add a member function (the pointer-to-member is automatically bound to this instance)
- dir.add("member", &SomeClass::member)
- .doc("Do the member operation");
+ dir.add("member", fty::Command(&SomeClass::member, this)
+ .doc("Do the member operation"));
}
void member(std::ostream & os, senf::console::ParseCommandInfo const & command)
int main(int, char**)
{
+ namespace fty = senf::console::factory;
+
// Provide global documentation
senf::console::root()
.doc("This is someServer server");
// Add a new directory to the root and document it. All the mutators return the node object
// itself so operations can be chained.
senf::console::DirectoryNode & mydir ( senf::console::root()
- .mkdir("myserver")
- .doc("My server specific directory"));
+ .add("myserver", fty::Directory()
+ .doc("My server specific directory")));
// Add a command to that directory
- mydir.add("mycommand", &mycommand)
+ mydir.add("mycommand", fty::Command(&mycommand)
.doc("mycommand <foo> [<bar>]\n\n"
- "If <bar> is given, flurgle the <foo>, otherwise burgle it");
+ "If <bar> is given, flurgle the <foo>, otherwise burgle it"));
// Create a SomeClass instance and add it's directory.
SomeClass someClass;
\code
void callback(std::ostream & os, senf::console::ParseCommandInfo const & command) { ... }
// ...
- myDirectory.add("foo",&callback);
+ myDirectory.add("foo",fty::Command(&callback));
\endcode
Every node is identified among it's siblings by it's name. The name of the node is set when
Depending on the node type added, additional node parameters may be set. For example, every node
has a documentation parameter which is used by the online-help system. To assign these
parameters, the node exposes corresponding member functions. Since
- senf::console::DirectoryNode::add() returns the newly added node by reference, additional
- parameters may just be added to the end of the add command:
+ senf::console::DirectoryNode::add() returns the newly added node by reference. Additional
+ parameters may be added after the factory call:
\code
- myDirectory.add("foo",&fooCallback).doc("The foo method");
+ myDirectory.add("foo", fty::Command(&fooCallback).doc("The foo method") );
\endcode
Since the parameter setters all return the node reference, additional parameters may just be
added to the end of the command.
#include <boost/range/iterator_range.hpp>
#include <boost/any.hpp>
#include <senf/Utils/Exception.hh>
-#include <senf/Utils/mpl.hh>
#include <senf/Utils/Logger/SenfLog.hh>
-#include <senf/Utils/type_traits.hh>
-#include "Parse.hh"
//#include "Node.mpp"
///////////////////////////////hh.p////////////////////////////////////////
Recursively dumps the console directory structure starting at \a dir. By default, dumps the
complete tree beginning at the root node.
-
+
In contrast to the console 'lr' command, links are dumped by showing the \e absolute path
to the target node.
*/
This node type provides the internal and root nodes of the tree. It allows to add arbitrary
children and supports directory traversal.
- Nodes are normally not instantiated manually but are created by the DirectoryNode via
- mkdir() or add(). Special add() members however allow externally allocated node objects.
+ Nodes are normally not instantiated manually but are created using factory calls. Special
+ add() members however allow externally allocated node objects.
Nodes may be added to the tree only once, otherwise chaos will ensue. Since nodes are always
managed dynamically, there is a special ScopedDirectory proxy template which provides a
\throws std::bad_cast if the child \a name is not a
command node. */
- DirectoryNode & mkdir(std::string const & name);
- ///< Create sub-directory node
- DirectoryNode & provideDirectory(std::string const & name);
- ///< Return subdirectory, possibly creating it
-
ChildrenRange children() const; ///< Return iterator range over all children.
/**< The returned range is sorted by child name. */
///< Return iterator range of completions for \a s
/**< The returned range is sorted by child name. */
- void link(std::string const & name, GenericNode & target);
- ///< Create a child node which is a link to target. \a s
- /**< The new link node will be a child of the node for which this member function is called. */
-
///\}
///////////////////////////////////////////////////////////////////////////
\param[in] command command arguments. This is a
range of ranges of Token instances. */
- void execute(boost::any & rv, std::ostream & output, ParseCommandInfo const & command)
+ void execute(boost::any & rv, std::ostream & output, ParseCommandInfo const & command)
const;
///< Execute the command
/**< \param[out] rv command return value
std::string shortdoc_;
};
+ DirectoryNode & provideDirectory(DirectoryNode & dir, std::string const & name);
+
#ifndef DOXYGEN
namespace factory {
-
+
class SimpleCommand
: public detail::NodeFactory
{
SimpleCommandNode::ptr node_;
};
+ class Directory
+ : public detail::NodeFactory
+ {
+ public:
+ typedef DirectoryNode node_type;
+ typedef DirectoryNode & result_type;
+
+ Directory();
+
+ DirectoryNode & create(DirectoryNode & dir, std::string const & name) const;
+
+ Directory const & doc(std::string const & doc) const;
+ Directory const & shortdoc(std::string const & doc) const;
+
+ private:
+ DirectoryNode::ptr node_;
+ };
+
+ class Link
+ : public detail::NodeFactory
+ {
+ public:
+ typedef LinkNode node_type;
+ typedef LinkNode & result_type;
+
+ explicit Link(GenericNode & target);
+
+ LinkNode & create(DirectoryNode & dir, std::string const & name) const;
+
+ private:
+ LinkNode::ptr node_;
+ };
+
}
#endif