class OverloadedCommandNode;
- /** \brief
+ struct ArgumentDoc {
+ std::string name;
+ std::string type;
+ std::string defaultValue;
+ std::string doc;
+ };
+
+ /** \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;
+ void argumentDoc(unsigned index, ArgumentDoc & doc) const;
+ std::string doc() const;
+
+ OverloadedCommandNode & node() const; ///< Access owning node
+ /**< \pre The command \e must have been added to an
+ OverloadedCommandNode. */
+ unsigned overloadIndex() const;
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;
+ virtual void v_argumentDoc(unsigned index, ArgumentDoc & doc) const = 0;
+ virtual std::string v_doc() const = 0;
+ virtual void v_execute(std::ostream & os, ParseCommandInfo const & command) const = 0;
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 mostly 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
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
///@{
///@}
///////////////////////////////////////////////////////////////////////////
-
- void add(CommandOverload::ptr overload);
+
+ template <class Command>
+ Command & add(boost::intrusive_ptr<Command> overload); ///< Add an additional overload
ptr thisptr();
cptr thisptr() const;
OverloadedCommandNode & doc(std::string const & doc);
+ ///< Assign global help for all overloads
+
+ unsigned overloadIndex(CommandOverload const & overload);
protected:
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);
+ ///< Assign overload specific documentation
protected:
private:
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