class OverloadedCommandNode;
- /** \brief
+ /** \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;
///////////////////////////////////////////////////////////////////////////
virtual ~CommandOverload();
- void operator()(std::ostream & os, Arguments const & arguments);
- void help(std::ostream & os);
+ 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() */
- OverloadedCommandNode & node();
+ void help(std::ostream & os); ///< Provide help for this specific overload
+
+ OverloadedCommandNode & node(); ///< Access owning node
+ /**< \pre The command \e must have been added to an
+ OverloadedCommandNode. */
protected:
CommandOverload();
private:
#endif
virtual void v_help(std::ostream & os) const = 0;
- virtual void v_execute(std::ostream & os, Arguments const & arguments) 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
///@}
///////////////////////////////////////////////////////////////////////////
-
- 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
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:
SimpleCommandOverload(Function fn);
virtual void v_help(std::ostream & os) const;
- virtual void v_execute(std::ostream & os, Arguments const & arguments) 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