class OverloadedCommandNode;
- /** \brief
+ /** \brief Documentation for a single argument
+
+ This struct is used by CommandOverload::argumentDoc()
+ */
+ struct ArgumentDoc {
+ std::string name; ///< Argument name
+ std::string type; ///< Argument type (string representation)
+ std::string defaultValue; ///< Default value (string representation) or empty string
+ std::string doc; ///< Documentation for this argument
+ };
+
+ /** \brief Base class for command overload of OverloadedCommandNode
+
+ This class is the base class of the commands which may be added to an
+ OverloadedCommandNode.
*/
class CommandOverload
: public senf::intrusive_refcount
// Types
typedef boost::intrusive_ptr<CommandOverload> ptr;
- typedef CommandNode::Arguments Arguments;
+ typedef boost::intrusive_ptr<CommandOverload const> cptr;
///////////////////////////////////////////////////////////////////////////
virtual ~CommandOverload();
- void operator()(std::ostream & os, Arguments const & arguments);
- void help(std::ostream & os);
-
- OverloadedCommandNode & node();
+ void execute(std::ostream & os, ParseCommandInfo const & command);
+ ///< Call the overload
+ /**< If the \a arguments are not acceptable for this
+ overload, a SyntaxErrorException must be thrown.
+ Same as operator()() */
+
+ void operator()(std::ostream & os, ParseCommandInfo const & command);
+ ///< Call the overload
+ /**< If the \a arguments are not acceptable for this
+ 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
+ /**< The information is returned in \e doc. \e doc must be
+ empty before this call.
+ \pre \a index < numArguments()
+ \param[in] index Argument index
+ \param[outp 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. */
+
+ unsigned overloadIndex() const; ///< Get index of overload in it's OverloadedCommandNode
protected:
CommandOverload();
#ifndef DOXYGEN
private:
#endif
- virtual void v_help(std::ostream & os) const = 0;
- virtual void v_execute(std::ostream & os, Arguments const & arguments) const = 0;
+ virtual unsigned v_numArguments() const = 0;
+ ///< Return the number of arguments
+ /**< This member must be implemented in the derived class to
+ return the number of arguments, the command expects. */
+
+ virtual void v_argumentDoc(unsigned index, ArgumentDoc & doc) const = 0;
+ ///< Return argument documentation
+ /**< The member must be implemented int the derived class to
+ return all documentation information for the \a
+ index'th parameter in \a doc. */
+
+ virtual std::string v_doc() const = 0;
+ ///< Return overload documentation
+ /**< This member must be implemented in the derived class to
+ return the overloads documentation string. */
+
+ virtual void v_execute(std::ostream & os, ParseCommandInfo const & command) const = 0;
+ ///< Execute the overload
+ /**< This member must be implemented in the derived class
+ o execute the overload. */
private:
OverloadedCommandNode * node_;
/** \brief Command node which allows multiple registered callbacks
- OverloadedCommand is like SimpleCommand but allows to register multiple commands to a single
- node. This works by calling each command in the list consecutively until no 'SyntaxError'
- exception is thrown.
+ OverloadedCommandNode is like SimpleCommandNode but allows to register multiple commands to
+ a single node. This works by calling each command in the list consecutively until no
+ '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.
+ \code
+ senf::console::DirectoryNode & dir (...);
+ senf::console::OverloadedCommandNode & cmd (
+ dir.add("cmd", senf::console::OverloadedCommandNode::create()) );
+ cmd.add(senf::console::SimpleCommandOverload::create(&callback));
+ cmd.add(senf::console::SimpleCommandOverload::create(&anotherCallback));
+ \endcode
+
+ However, this facility is normally used not directly but indirectly (and automatically) when
+ adding argument parsing callbacks.
\warning For this to work, the commands <b>must</b> do all syntax checking before doing any
operation
- \ingroup node_tree
+ \ingroup console_commands
*/
class OverloadedCommandNode
: public CommandNode
typedef boost::shared_ptr<OverloadedCommandNode const> cptr;
typedef boost::weak_ptr<OverloadedCommandNode> weak_ptr;
+ typedef OverloadedCommandNode node_type;
+ typedef OverloadedCommandNode & return_type;
+
///////////////////////////////////////////////////////////////////////////
///\name Structors and default members
///@{
///@}
///////////////////////////////////////////////////////////////////////////
+
+ template <class Command>
+ Command & add(boost::intrusive_ptr<Command> overload); ///< Add an additional overload
+
+ OverloadedCommandNode & doc(std::string const & doc);
+ ///< Assign global help for all overloads
- void add(CommandOverload::ptr overload);
+ unsigned overloadIndex(CommandOverload const & overload);
+ ///< Return the overload index for \a overload
+ /**< overloadIndex returns the index of \a overload in the
+ internal list of overloads. */
ptr thisptr();
cptr thisptr() const;
- OverloadedCommandNode & doc(std::string const & doc);
-
- protected:
-
private:
OverloadedCommandNode();
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;
typedef std::vector<CommandOverload::ptr> Overloads;
std::string doc_;
};
- /** \brief
+ /** \brief Basic command overload
+
+ This is an implementation of CommandOverload which allows to call an arbitrary callback with
+ the correct signature
+ (<tt>void (std::ostream &, senf::console::ParseCommandInfo const &)</tt>)
*/
class SimpleCommandOverload
: public CommandOverload
// Types
typedef boost::intrusive_ptr<SimpleCommandOverload> ptr;
- typedef boost::function<void (std::ostream &, Arguments const &)> Function;
+ 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);
-
- protected:
+ ///< Assign overload specific documentation
private:
- SimpleCommandOverload(Function fn);
+ explicit SimpleCommandOverload(Function fn);
- virtual void v_help(std::ostream & os) const;
- virtual void v_execute(std::ostream & os, Arguments const & arguments) const;
+ virtual unsigned v_numArguments() const;
+ virtual void v_argumentDoc(unsigned index, ArgumentDoc & doc) const;
+ virtual std::string v_doc() const;
+ virtual void v_execute(std::ostream & os, ParseCommandInfo const & command) const;
Function fn_;
std::string doc_;
///////////////////////////////hh.e////////////////////////////////////////
#include "OverloadedCommand.cci"
//#include "OverloadedCommand.ct"
-//#include "OverloadedCommand.cti"
+#include "OverloadedCommand.cti"
#endif
\f
projects / senf.git / blobdiff