class OverloadedCommandNode;
+ 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
// 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 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. */
- void help(std::ostream & os); ///< Provide help for this specific overload
+ overload, a SyntaxErrorException must be thrown.
+ Same as operator()() */
- OverloadedCommandNode & node(); ///< Access owning node
+ 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_;
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
///@{
OverloadedCommandNode & doc(std::string const & doc);
///< Assign global help for all overloads
+ unsigned overloadIndex(CommandOverload const & overload);
+
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;
/** \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 &, Arguments const &)</tt>)
+ 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
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_;