X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FUtils%2FConsole%2FOverloadedCommand.hh;h=fb3c24e6fe5084dba2b8d1007e3909e87e9e1933;hb=5b2e9a63a43027c71ac470ac9bdecb72e8974951;hp=3be6b42ab875cf78a43a814f4b4f01864de0163f;hpb=601d1f509f5bb24df167a4dd5a20da67a0af9af8;p=senf.git

diff --git a/senf/Utils/Console/OverloadedCommand.hh b/senf/Utils/Console/OverloadedCommand.hh
index 3be6b42..fb3c24e 100644
--- a/senf/Utils/Console/OverloadedCommand.hh
+++ b/senf/Utils/Console/OverloadedCommand.hh
@@ -1,6 +1,6 @@
 // $Id$
 //
-// Copyright (C) 2008 
+// Copyright (C) 2008
 // Fraunhofer Institute for Open Communication Systems (FOKUS)
 // Competence Center NETwork research (NET), St. Augustin, GERMANY
 //     Stefan Bund <g0dil@berlios.de>
@@ -30,10 +30,11 @@
 #include "Node.hh"
 #include <boost/intrusive_ptr.hpp>
 #include <boost/range/iterator_range.hpp>
-#include "../../Utils/intrusive_refcount.hh"
+#include <senf/Utils/intrusive_refcount.hh>
+#include <boost/optional.hpp>
 
 //#include "OverloadedCommand.mpp"
-///////////////////////////////hh.p////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace senf {
 namespace console {
@@ -61,28 +62,28 @@ namespace console {
         : public senf::intrusive_refcount
     {
     public:
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         // Types
 
         typedef boost::intrusive_ptr<CommandOverload> ptr;
         typedef boost::intrusive_ptr<CommandOverload const> cptr;
 
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
 
         virtual ~CommandOverload();
 
         void execute(boost::any & rv, std::ostream & os, ParseCommandInfo const & command);
                                         ///< Call the overload
                                         /**< If the \a arguments are not acceptable for this
-                                             overload, a SyntaxErrorException must be thrown. 
+                                             overload, a SyntaxErrorException must be thrown.
                                              Same as operator()() */
 
         void operator()(boost::any & rv, std::ostream & os, ParseCommandInfo const & command);
                                         ///< Call the overload
                                         /**< If the \a arguments are not acceptable for this
-                                             overload, a SyntaxErrorException must be thrown. 
+                                             overload, a SyntaxErrorException must be thrown.
                                              Same as execute() */
-        
+
         unsigned numArguments() const;  ///< Number of arguments this overload takes
         void argumentDoc(unsigned index, ArgumentDoc & doc) const;
                                         ///< Get information on argument \a index
@@ -93,7 +94,7 @@ namespace console {
                                              \param[out] doc Argument documentation */
 
         std::string doc() const;        ///< Get overload documentation
-        
+
         OverloadedCommandNode & node() const; ///< Access owning node
                                         /**< \pre The command \e must have been added to an
                                              OverloadedCommandNode. */
@@ -141,7 +142,7 @@ namespace console {
         'SyntaxErrorException' exception is thrown.
 
         This works by first adding an OverloadedCommandNode to the directory in question and then
-        adding commands to that node. Commands are derived from CommandOverload. 
+        adding commands to that node. Commands are derived from CommandOverload.
         \code
         senf::console::DirectoryNode & dir (...);
         senf::console::OverloadedCommandNode & cmd (
@@ -164,7 +165,7 @@ namespace console {
         typedef std::vector<CommandOverload::ptr> Overloads;
 
     public:
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         // Types
 
         typedef boost::shared_ptr<OverloadedCommandNode> ptr;
@@ -176,15 +177,15 @@ namespace console {
 
         typedef boost::iterator_range<Overloads::const_iterator> OverloadsRange;
 
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         ///\name Structors and default members
-        ///@{
+        //\{
 
         static ptr create();
 
-        ///@}
-        ///////////////////////////////////////////////////////////////////////////
-        
+        //\}
+        //-////////////////////////////////////////////////////////////////////////
+
         template <class Command>
         Command & add(boost::intrusive_ptr<Command> overload); ///< Add an additional overload
 
@@ -203,6 +204,9 @@ namespace console {
         ptr thisptr();
         cptr thisptr() const;
 
+        static OverloadedCommandNode & insertOverload(DirectoryNode & dir, std::string const & name,
+                                                      CommandOverload::ptr overload);
+
     private:
         OverloadedCommandNode();
 
@@ -219,29 +223,29 @@ namespace console {
     /** \brief Basic command overload
 
         This is an implementation of CommandOverload which allows to call an arbitrary callback with
-        the correct signature 
+        the correct signature
         (<tt>void (std::ostream &, senf::console::ParseCommandInfo const &)</tt>)
       */
     class SimpleCommandOverload
         : public CommandOverload
     {
     public:
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         // Types
 
         typedef boost::intrusive_ptr<SimpleCommandOverload> ptr;
         typedef boost::function<void (std::ostream &, ParseCommandInfo const &)> Function;
 
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         ///\name Structors and default members
-        ///@{
+        //\{
 
         static SimpleCommandOverload::ptr create(Function fn);
                                         ///< Create new SimpleCommandOverload
                                         /**< \param[in] fn callback to call */
 
-        ///@}
-        ///////////////////////////////////////////////////////////////////////////
+        //\}
+        //-////////////////////////////////////////////////////////////////////////
 
         SimpleCommandOverload & doc(std::string const & doc);
                                         ///< Assign overload specific documentation
@@ -259,9 +263,30 @@ namespace console {
         std::string doc_;
     };
 
+    class SimpleOverloadAttributor
+        : public detail::NodeFactory
+    {
+    public:
+        typedef OverloadedCommandNode node_type;
+        typedef OverloadedCommandNode & result_type;
+
+        explicit SimpleOverloadAttributor(SimpleCommandOverload::Function fn);
+
+        SimpleOverloadAttributor const & doc(std::string const & doc) const;
+        SimpleOverloadAttributor const & shortdoc(std::string const & doc) const;
+        SimpleOverloadAttributor const & overloadDoc(std::string const & doc) const;
+
+        OverloadedCommandNode & create(DirectoryNode & dir, std::string const & name) const;
+
+    private:
+        SimpleCommandOverload::ptr overload_;
+        mutable boost::optional<std::string> doc_;
+        mutable boost::optional<std::string> shortdoc_;
+    };
+
 }}
 
-///////////////////////////////hh.e////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 #include "OverloadedCommand.cci"
 //#include "OverloadedCommand.ct"
 #include "OverloadedCommand.cti"