senf/Utils/Console/ParsedCommand.hh

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief ParsedCommand public header */
  25
  26 #ifndef HH_SENF_Scheduler_Console_ParsedCommand_
  27 #define HH_SENF_Scheduler_Console_ParsedCommand_ 1
  28
  29 // Custom includes
  30
  31 #define BOOST_PARAMETER_MAX_ARITY 6
  32
  33 #include <vector>
  34 #include <boost/type_traits/function_traits.hpp>
  35 #include <boost/type_traits/is_member_function_pointer.hpp>
  36 #include <boost/mpl/if.hpp>
  37 #include <boost/utility.hpp>
  38 #include <boost/parameter/keyword.hpp>
  39 #include <boost/parameter/parameters.hpp>
  40 #include <senf/config.hh>
  41 #include "OverloadedCommand.hh"
  42 #include "Traits.hh"
  43 #include <senf/Utils/type_traits.hh>
  44
  45 #include "ParsedCommand.ih"
  46 #include "ParsedCommand.mpp"
  47 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  48
  49 namespace senf {
  50 namespace console {
  51
  52     namespace detail { class ArgumentInfoBase; }
  53
  54     /** \brief CommandOverload implementation with automatic argument parsing
  55
  56         ParsedCommandOverloadBase implements a CommandOverload implementation supporting automatic
  57         parsing of arguments. This is \e not a node, it's a CommandOverload which is then added to
  58         an OverloadedCommandNode instance.
  59
  60         Automatic argument parsing and return value processing consists of several components:
  61         \li \ref overload_add Adding overload instances to the tree
  62         \li (Advanced) \ref overload_parse
  63         \li (Advanced) \ref overload_format
  64
  65         \section overload_add Adding argument parsing callbacks to the tree
  66
  67         To add overloads to the tree, use the senf::console::factory::Command factory:
  68         \code
  69         namespace fty = senf::console::factory;
  70
  71         std::string taskStatus(int id);
  72
  73         senf::console::root().add("taskStatus", fty::Command(&taskStatus));
  74         \endcode
  75
  76         There are quite a number of additional parameters available to be set. These parameters are
  77         documented in ParsedArgumentAttributor. Parameters are set by adding them as additional
  78         calls after adding the node:
  79
  80         \code
  81         senf::console::root().add("taskStatus", fty::Command(&taskStatus)
  82             .doc("Query the current task status")
  83             .arg( name = "id",
  84                   description = "numeric id of task to check, -1 for the current task."
  85                   default_value = -1 ) );
  86         \endcode
  87
  88         You may also add an additional \c std::ostream & Argument as first argument to the
  89         callback. If this argument is present, the stream connected to the console which issued the
  90         command will be passed there. This allows writing arbitrary messages to the console.
  91
  92         Additionally, overloading is supported by registering multiple commands under the same
  93         name. So, elaborating on above example:
  94         \code
  95         std::string taskStatus(int id);
  96         std::string taskStatus(std::string const & name);
  97
  98         senf::console::root()
  99             .add("taskStatus", fty::Command(static_cast<std::string (*)(int)>(
 100                                                 &taskStatus))
 101             .doc("Query the current task status")
 102             .overloadDoc("Query status by id")
 103             .arg( name = "id",
 104                   description = "numeric id of task to check, -1 for the current task."
 105                   default_value = -1 ) );
 106         senf::console::root()
 107             .add("taskStatus", fty::Command(static_cast<std::string (*)(std::string const &)>(
 108                                                  &taskStatus))
 109             .overloadDoc("Query status by name")
 110             .arg( name = "name",
 111                   description = "name of task to check" ) );
 112         \endcode
 113
 114         We can see here, that taking the address of an overloaded function requires a cast. If you
 115         can give unique names to each of the C++ overloads (not the overloads in the console), you
 116         should do so to make the unwieldy casts unnecessary.
 117
 118         \section overload_parse Custom parameter parsers
 119
 120         By default, parameters are parsed using \c boost::lexical_cast and therefore using \c
 121         iostreams. This means, that any type which can be read from a stream can automatically be
 122         used as argument type.
 123
 124         However, argument parsing can be configured by specializing
 125         senf::console::ArgumentTraits. See that class for more information.
 126
 127         \section overload_format Custom return-value formatters
 128
 129         By default, return values are streamed to an ostream. This automatically allows any
 130         streamable type to be used as return value. To add new types or customize the formating, the
 131         senf::console::ReturnValueTraits template needs to be specialized for that type. See
 132         that class for more information.
 133
 134         \ingroup console_commands
 135      */
 136     class ParsedCommandOverloadBase
 137         : public CommandOverload
 138     {
 139     public:
 140         typedef boost::intrusive_ptr<ParsedCommandOverloadBase> ptr;
 141
 142         detail::ArgumentInfoBase & arg(unsigned n) const;
 143
 144         void doc(std::string const & d);
 145
 146     protected:
 147         ParsedCommandOverloadBase();
 148
 149         template <class Type> void addParameter();
 150
 151     private:
 152         virtual unsigned v_numArguments() const;
 153         virtual void v_argumentDoc(unsigned index, ArgumentDoc & doc) const;
 154         virtual std::string v_doc() const;
 155
 156         typedef std::vector<detail::ArgumentInfoBase::ptr> Parameters;
 157         Parameters parameters_;
 158         std::string doc_;
 159     };
 160
 161     /** \brief Parsed command overload
 162
 163         ParsedCommandOverload provides the command overload added to an OverloadedCommandNode for an
 164         automatically parsed command.
 165
 166         This class is normally instantiated automatically when adding a function or member-function
 167         pointer as callback to the tree. Manually instantiation this type of overload is \e not
 168         simple, since the function signature has to be manipulated correctly to support the optional
 169         \c std::ostream first argument.
 170
 171         \implementation This class is specialized for each supported number of command arguments.
 172
 173         \todo Implement automatic binding of member functions for parser and formatter
 174      */
 175     template <class FunctionTraits, class ReturnType, unsigned arity>
 176     class ParsedCommandOverload : public ParsedCommandOverloadBase
 177     {
 178     public:
 179         typedef boost::intrusive_ptr<ParsedCommandOverload> ptr;
 180     };
 181
 182 #ifndef DOXYGEN
 183
 184 #   define BOOST_PP_ITERATION_PARAMS_1                                  \
 185         (4, (0, SENF_CONSOLE_MAX_COMMAND_ARITY,                         \
 186              SENF_ABSOLUTE_INCLUDE_PATH(Utils/Console/ParsedCommand.mpp), \
 187              1))
 188 #   include BOOST_PP_ITERATE()
 189
 190 #endif
 191
 192     /** \brief Generic ParsedCommandOverloadBase attributes
 193
 194         Attributes for parsed commands are not set directly on the node. They are set via a special
 195         attributor temporary returned when adding a parsed command to the tree.
 196
 197         This class is the base class for those attributors. It provides members which do not depend
 198         in any way on the exact type of command added.
 199
 200         \see \ref console_autoparse
 201      */
 202     class ParsedCommandAttributorBase
 203         : public detail::NodeFactory
 204     {
 205     public:
 206         typedef OverloadedCommandNode node_type;
 207         typedef OverloadedCommandNode & result_type;
 208
 209     protected:
 210         ParsedCommandAttributorBase(ParsedCommandOverloadBase::ptr overload, unsigned index);
 211         ParsedCommandAttributorBase(ParsedCommandAttributorBase const & other, unsigned index);
 212
 213         void argName(std::string const & name);
 214         void argDoc(std::string const & doc);
 215         void typeName(std::string const & doc);
 216         void defaultDoc(std::string const & doc);
 217
 218         ParsedCommandOverloadBase & overload() const;
 219         void overloadDoc(std::string const & doc);
 220         void nodeDoc(std::string const & doc);
 221         void shortDoc(std::string const & doc);
 222
 223     private:
 224         OverloadedCommandNode & create(DirectoryNode & dir, std::string const & name) const;
 225
 226         ParsedCommandOverloadBase::ptr overload_;
 227         unsigned index_;
 228         boost::optional<std::string> doc_;
 229         boost::optional<std::string> shortdoc_;
 230
 231         friend class senf::console::DirectoryNode;
 232     };
 233
 234     /** \brief Non argument dependent ParsedCommandBase attributes
 235
 236         Attributes for parsed commands are not set directly on the node. They are set via a special
 237         attributor temporary returned when adding a parsed command to the tree.
 238
 239         This class adds all those members, which do depend on the type of command added (and thereby
 240         on that commands signature) but do not depend on the type of any single argument.
 241
 242         \see \ref console_autoparse
 243      */
 244     template <class Overload>
 245     class ParsedCommandAttributor
 246         : public ParsedCommandAttributorBase
 247     {
 248     public:
 249         Overload & overload() const;    ///< Get the command overload
 250
 251     protected:
 252         ParsedCommandAttributor(typename Overload::ptr overload, unsigned index);
 253         ParsedCommandAttributor(ParsedCommandAttributorBase const & other, unsigned index);
 254
 255     private:
 256     };
 257
 258     /** \brief Keyword argument tags
 259
 260         The tags defined in this namespace are used as keyword arguments via the <a
 261         href="http://www.boost.org/doc/libs/release/libs/parameter/doc/html/index.html">Boost.Parameter</a>
 262         library.
 263
 264         For the keyword tags, the standard C++ scoping rules apply
 265         \code
 266         namespace fty=senf::console::factory;
 267
 268         // Either qualify them with their complete namespace
 269         dir.add(..., fty::Command(...)
 270             .arg( senf::console::kw::name = "name" ) );
 271
 272         // Or use a namespace alias
 273         namespace kw = senf::console::kw;
 274         dir.add(..., fty::Command(...)
 275             .arg( kw::name = "name" ) );
 276
 277         // Or import the keywords into the current namespace (beware of name collisions)
 278         using namespace senf::console::kw;
 279         dir.add(..., fty::Command(...)
 280             .arg( name = "name" ) );
 281         \endcode
 282
 283         The second alternative is preferred, the <tt>using namespace</tt> directive may be used as
 284         long as the keyword names do not clash with another visible symbol.
 285
 286         \section kw_attributes Argument attribute values
 287
 288         The keywords are used to set argument attributes.  The keywords \ref default_value and \ref
 289         parser influence, how an argument is parsed/interpreted whereas \ref name, \ref description,
 290         \ref type_name and \ref default_doc are used to change the arguments documentation:
 291         \code
 292         void command(int);
 293
 294         dir.add("command", fty::Command(&command)
 295             .arg( kw::name          = "name",
 296                   kw::description   = "description",
 297                   kw::default_value = 1,
 298                   kw::type_name     = "type_name",
 299                   kw::default_doc   = "default_doc" ) );
 300         \endcode
 301         Will create the following documentation:
 302         \htmlonly
 303         <pre>
 304         Usage:
 305             command [name:type_name]
 306
 307         With:
 308             name      description
 309                 default: default_doc
 310         </pre>
 311         \endhtmlonly
 312
 313         \see \ref senf::console::ParsedArgumentAttributor::arg()
 314
 315         \ingroup console_commands
 316      */
 317     namespace kw {
 318         BOOST_PARAMETER_KEYWORD(type, name) ///< Argument name
 319                                         /**< Sets the displayed name of the argument. */
 320         BOOST_PARAMETER_KEYWORD(type, description) ///< One-line argument description
 321                                         /**< This description is shown in the argument
 322                                              reference. If several overloads have same-named
 323                                              arguments, only one of them should be documented. This
 324                                              documentation then applies to all arguments of that
 325                                              name. */
 326         BOOST_PARAMETER_KEYWORD(type, default_value) ///< Argument default value
 327                                         /**< If a default value is specified for an argument, that
 328                                              argument is optional. If an overload is called with
 329                                              fewer arguments than defined, optional values will be
 330                                              used beginning at the last optional argument and going
 331                                              forward until all arguments have values assigned. E.g.,
 332                                              an overload with 5 parameters \a a - \a e with two
 333                                              defaults attached:
 334                                              <pre>
 335                                              command a:int [b:int] c:int [d:int] e:int
 336                                              </pre>
 337                                              When calling the overload, the arguments will be
 338                                              assigned in the following way:
 339                                              <table class="senf fixedwidth">
 340                                              <tr>
 341                                                <td style="whitespace:no-wrap"><tt>command 1 2</tt></td>
 342                                                <td colspan="5">SyntaxErrorException: invalid number of
 343                                                  arguments</td>
 344                                              </tr>
 345                                              <tr>
 346                                                <td style="white-space:nowrap"><tt>command 1 2 3</tt></td>
 347                                                <td style="width:6em">\a a = 1</td><td style="width:6em">\a b = \e default</td><td style="width:6em">\a c = 2</td><td style="width:6em">\a d = \e default</td><td style="width:6em">\a e = 3</td>
 348                                              </tr>
 349                                              <tr>
 350                                                <td style="white-space:nowrap"><tt>command 1 2 3 4</tt></td>
 351                                                <td>\a a = 1</td><td>\a b = 2</td><td>\a c = 3</td><td>\a d = \e default</td><td>\a e = 4</td>
 352                                              </tr>
 353                                              <tr>
 354                                                <td style="white-space:nowrap"><tt>command 1 2 3 4 5</tt></td>
 355                                                <td>\a a = 1</td><td>\a b = 2</td><td>\a c = 3</td><td>\a d = 4</td><td>\a e = 5</td>
 356                                              </tr>
 357                                              <tr>
 358                                                <td style="white-space:nowrap"><tt>command 1 2 3 4 5 6</tt></td>
 359                                                <td colspan="5">SyntaxErrorException: invalid number of
 360                                                  arguments</td>
 361                                              </tr>
 362                                              </table>
 363                                              So, if you use default values as you are used to,
 364                                              assigning default values to consecutive trailing
 365                                              arguments, they work like they do in C++ and most other
 366                                              languages */
 367         BOOST_PARAMETER_KEYWORD(type, type_name) ///< Type name of this arguments type
 368                                         /**< By default, the type of an argument is extracted from
 369                                              the C++ type name by taking the last component of the
 370                                              fully scoped name. This value can be changed by setting
 371                                              this attribute. */
 372         BOOST_PARAMETER_KEYWORD(type, default_doc) ///< String rep of default value
 373                                         /**< By default, the default value is documented by
 374                                              converting the value to it's string representation
 375                                              using the corresponding return value formatter which by
 376                                              default uses \c boost::lexical_cast / \c iostreams. The
 377                                              displayed value can be changed by setting this
 378                                              attribute. */
 379         BOOST_PARAMETER_KEYWORD(type, parser) ///< Argument parser
 380                                         /**< The argument parser is used to convert the argument
 381                                              token list returned by the console/config parser into
 382                                              the appropriate value. If not set explicitly, this
 383                                              conversion is supplied by the ArgumentTraits
 384                                              class.
 385
 386                                              Setting the \a parser attribute allows to use a custom
 387                                              parser. The parser is an arbitrary callable object with
 388                                              the signature
 389                                              \code
 390                                              void parser(senf::console::ParseCommandInfo::TokensRange const & tokens, value_type & out);
 391                                              \endcode
 392                                              where \c value_type is the type of the overload
 393                                              parameter. The parser must read and parse the complete
 394                                              \a tokens range and return the parsed value in \a
 395                                              out. If the parser fails, it must raise a
 396                                              senf::console::SyntaxErrorException. */
 397     }
 398
 399     /** \brief Derived class dependent ParsedCommandBase attributes
 400
 401         Attributes for parsed commands are not set directly on the node. They are set via a special
 402         attributor temporary returned when adding a parsed command to the tree.
 403
 404         This class adds all those members, which do not depend on any specific argument but which
 405         need to return the correct attributor type.
 406
 407         \see \ref console_autoparse
 408      */
 409     template <class Overload, class Self, class ReturnType=typename Overload::traits::result_type>
 410     class ParsedArgumentAttributorBase
 411         : public ParsedCommandAttributor<Overload>
 412     {
 413     public:
 414         Self doc(std::string const & doc); ///< Set documentation for all overloads
 415         Self shortdoc(std::string const & doc); ///< Set short documentation for all overloads
 416         Self overloadDoc(std::string const & doc); ///< Set overload specific documentation
 417         Self formatter(typename Overload::Formatter formatter);
 418                                         ///< Set return value formatter
 419                                         /**< This member is only available, if the \a ReturnType of
 420                                              the installed callback is not \c void.
 421
 422                                              If \a ReturnType is not \c void, the \a formatter must
 423                                              be a callable with a signature compatible with
 424                                              \code
 425                                              void formatter(ReturnType const & value, std::ostream & os);
 426                                              \endcode
 427                                              The \a formatter takes the return value of the call \a
 428                                              value and writes it properly formated to \a os. */
 429
 430     protected:
 431         ParsedArgumentAttributorBase(typename Overload::ptr overload, unsigned index);
 432         ParsedArgumentAttributorBase(ParsedCommandAttributorBase const & other, unsigned index);
 433
 434     private:
 435     };
 436
 437 #ifndef DOXYGEN
 438
 439     template <class Overload, class Self>
 440     class ParsedArgumentAttributorBase<Overload, Self, void>
 441         : public ParsedCommandAttributor<Overload>
 442     {
 443     public:
 444         Self doc(std::string const & doc); ///< Set documentation for all overloads
 445         Self shortdoc(std::string const & doc); ///< Set short documentation for all overloads
 446         Self overloadDoc(std::string const & doc); ///< Set overload specific documentation
 447
 448     protected:
 449         ParsedArgumentAttributorBase(typename Overload::ptr overload, unsigned index);
 450         ParsedArgumentAttributorBase(ParsedCommandAttributorBase const & other, unsigned index);
 451
 452     private:
 453     };
 454
 455 #endif
 456
 457     /** \brief Argument dependent ParsedCommandBase attributes
 458
 459         Attributes for parsed commands are not set directly on the node. They are set via a special
 460         attributor temporary returned when adding a parsed command to the tree.
 461
 462         This class adds all those members, which depend on a specific argument. Each call to \c arg
 463         will advance to the next argument.
 464
 465         \see \ref console_autoparse
 466      */
 467     template <class Overload, unsigned index, bool flag>
 468     class ParsedArgumentAttributor
 469         : public ParsedArgumentAttributorBase< Overload,
 470                                                 ParsedArgumentAttributor<Overload, index, flag> >
 471     {
 472         typedef boost::parameter::parameters<
 473             kw::type::name,
 474             kw::type::description,
 475             kw::type::default_value,
 476             kw::type::type_name,
 477             kw::type::default_doc,
 478             kw::type::parser> arg_params;
 479
 480     public:
 481         typedef typename senf::function_traits_arg_type<
 482             typename Overload::traits, int(index) >::type arg_type;
 483         typedef typename senf::remove_cvref< arg_type >::type value_type;
 484         typedef ParsedArgumentAttributor<Overload, index+1> next_type;
 485
 486         next_type arg() const;          ///< Set argument attributes
 487                                         /**< This member changes the attributes for the current
 488                                              argument. The attributes are passed to arg() as keyword
 489                                              arguments using the <a
 490                                              href="http://www.boost.org/doc/libs/release/libs/parameter/doc/html/index.html">Boost.Parameter</a>
 491                                              library.
 492                                              \code
 493                                              ...
 494                                                  .arg( kw::name          = "name",
 495                                                        kw::default_value = 1 )
 496                                              ...
 497                                              \endcode
 498                                              The valid keywords are defined in the senf::console::kw
 499                                              namespace.
 500
 501                                              Each call to arg() will increment the argument index
 502                                              and advance to the next argument. This member is only
 503                                              present, if there is an argument at the current
 504                                              index. */
 505
 506 #ifndef DOXYVEN
 507
 508 #       define BOOST_PP_ITERATION_PARAMS_1                                                        \
 509             (4, (1, BOOST_PARAMETER_MAX_ARITY,                                                    \
 510                  SENF_ABSOLUTE_INCLUDE_PATH(Utils/Console/ParsedCommand.mpp),                     \
 511                  5))
 512 #       include BOOST_PP_ITERATE()
 513
 514 #endif
 515
 516     private:
 517         explicit ParsedArgumentAttributor(typename Overload::ptr overload);
 518         explicit ParsedArgumentAttributor(ParsedCommandAttributorBase const & other);
 519
 520         template <class ArgumentPack>
 521         next_type argInfo(ArgumentPack const & args);
 522         template <class Kw, class ArgumentPack>
 523         void argInfo(Kw const &, ArgumentPack const &, boost::mpl::false_);
 524
 525         template <class ArgumentPack>
 526         void argInfo(boost::parameter::keyword<kw::type::name> const &,
 527                      ArgumentPack const & args, boost::mpl::true_);
 528         template <class ArgumentPack>
 529         void argInfo(boost::parameter::keyword<kw::type::description> const &,
 530                      ArgumentPack const & args, boost::mpl::true_);
 531         template <class ArgumentPack>
 532         void argInfo(boost::parameter::keyword<kw::type::default_value> const &,
 533                      ArgumentPack const & args, boost::mpl::true_);
 534         template <class ArgumentPack>
 535         void argInfo(boost::parameter::keyword<kw::type::type_name> const &,
 536                      ArgumentPack const & args, boost::mpl::true_);
 537         template <class ArgumentPack>
 538         void argInfo(boost::parameter::keyword<kw::type::default_doc> const &,
 539                      ArgumentPack const & args, boost::mpl::true_);
 540         template <class ArgumentPack>
 541         void argInfo(boost::parameter::keyword<kw::type::parser> const &,
 542                      ArgumentPack const & args, boost::mpl::true_);
 543
 544         next_type next() const;
 545
 546         void defaultValue(value_type const & value);
 547         template <class Fn> void parser(Fn fn);
 548
 549         template <class O, unsigned i, bool f>
 550         friend class ParsedArgumentAttributor;
 551
 552         friend class detail::ParsedCommandAddNodeAccess;
 553     };
 554
 555 #ifndef DOXYGEN
 556
 557     template <class Overload, unsigned index>
 558     class ParsedArgumentAttributor<Overload, index, false>
 559         : public ParsedArgumentAttributorBase< Overload,
 560                                                 ParsedArgumentAttributor<Overload, index, false> >
 561     {
 562     public:
 563         typedef OverloadedCommandNode node_type;
 564         typedef ParsedArgumentAttributor return_type;
 565
 566     private:
 567         explicit ParsedArgumentAttributor(typename Overload::ptr overload);
 568         explicit ParsedArgumentAttributor(ParsedCommandAttributorBase const & other);
 569
 570         template <class O, unsigned i, bool f>
 571         friend class ParsedArgumentAttributor;
 572
 573         friend class detail::ParsedCommandAddNodeAccess;
 574     };
 575
 576 #endif
 577
 578 namespace factory {
 579
 580 #ifdef DOXYGEN
 581
 582     /** \brief OverloadedCommandNode factory
 583
 584         This factory will create new OverloadedCommandNode instances <em>or add new overloads</em>
 585         to an existing OverloadedCommandNode. The factory supports automatic argument parsing.
 586
 587         Commands are added to the tree using
 588         \code
 589         namespace fty = senf::console::factory;
 590         node.add("name", fty::Command(function));
 591         \endcode
 592
 593         The Command factory supports the following features:
 594         \li Automatic argument parsing
 595         \li Automatic binding of member functions. Pass the owning instance as second argument to
 596             the factory
 597         \li Conversion to a compatible signature. Pass the signature as template argument to the
 598             factory
 599
 600         If the signature of the command added matches
 601         \code
 602         void (std::ostream &, senf::console::ParsedCommandInfo const &)
 603         \endcode
 604         The command is added using manual argument parsing, otherwise it is added using automatic
 605         argument parsing.
 606
 607         See the <a href="classsenf_1_1console_1_1factory_1_1Command-members.html">List of all
 608         members</a> for additional attributes.
 609
 610         \note This class is for exposition only, the real interface consists of several overloaded
 611             factory functions.
 612
 613         \see \ref console_manualparse \n
 614             \ref console_autoparse
 615      */
 616     class Command : public ParsedArgumentAttributor
 617     {
 618     public:
 619         typedef OverloadedCommandNode node_type;
 620         typedef unspecified result_type;
 621
 622         Command(unspecified fn);        ///< Create a node calling \a fn
 623         template <class Signature>
 624         Command(unspecified fn);        ///< Create a node calling \a fn with signature \a Signature
 625                                         /**< The given \a Signature must be compatible with \a fn
 626                                              for each argument and the return value. */
 627
 628         Command(member_function_pointer fn, Owner const * owner);
 629                                         ///< Create a node calling member function \a fn on \a owner
 630         template <class Signature>
 631         Command(member_function_pointer fn, Owner const * owner);
 632                                         ///< Create a node calling member function \a fn on \a owner
 633                                         ///  with the given \a Signature
 634                                         /**< The given \a Signature must be compatible with \a fn
 635                                              for each argument and the return value. */
 636
 637     };
 638
 639 #else
 640
 641     template <class Signature>
 642     SimpleOverloadAttributor
 643     Command(boost::function<Signature> fn,
 644             typename boost::enable_if_c<detail::ParsedCommandTraits<Signature>::is_simple>::type * = 0);
 645
 646     template <class Function>
 647     SimpleOverloadAttributor
 648     Command(Function fn,
 649             typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_simple>::type * = 0);
 650
 651     template <class Owner, class Member>
 652     SimpleOverloadAttributor
 653     Command(Member memfn, Owner * owner,
 654             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type * = 0,
 655             typename boost::enable_if_c<detail::ParsedCommandTraits<Member>::is_simple>::type * = 0);
 656
 657     template <class Owner, class Member>
 658     SimpleOverloadAttributor
 659     Command(Member memfn, Owner const * owner,
 660             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type * = 0,
 661             typename boost::enable_if_c<detail::ParsedCommandTraits<Member>::is_simple>::type * = 0);
 662
 663     template <class CastTo, class Signature>
 664     typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
 665     Command(boost::function<Signature> fn);
 666
 667     template <class CastTo, class Function>
 668     typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
 669     Command(Function fn,
 670             typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_callable>::type * = 0,
 671             typename boost::disable_if<boost::is_member_function_pointer<Function> >::type * = 0);
 672
 673     template <class Signature>
 674     typename senf::console::detail::ParsedCommandTraits<Signature>::Attributor
 675     Command(boost::function<Signature> fn);
 676
 677     template <class Function>
 678     typename senf::console::detail::ParsedCommandTraits<Function>::Attributor
 679     Command(Function fn,
 680             typename boost::enable_if_c<detail::ParsedCommandTraits<Function>::is_callable>::type * = 0,
 681             typename boost::disable_if<boost::is_member_function_pointer<Function> >::type * = 0);
 682
 683     template <class Owner, class Member>
 684     typename senf::console::detail::ParsedCommandTraits<Member>::Attributor
 685     Command(Member memfn, Owner * owner,
 686             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type * = 0);
 687
 688     template <class Owner, class Member>
 689     typename senf::console::detail::ParsedCommandTraits<Member>::Attributor
 690     Command(Member memfn, Owner const * owner,
 691             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type * = 0);
 692
 693     template <class CastTo, class Owner, class Member>
 694     typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
 695     Command(Member memfn, Owner * owner,
 696             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type * = 0);
 697
 698     template <class CastTo, class Owner, class Member>
 699     typename senf::console::detail::ParsedCommandTraits<CastTo>::Attributor
 700     Command(Member memfn, Owner const * owner,
 701             typename boost::enable_if<boost::is_member_function_pointer<Member> >::type * = 0);
 702
 703 #endif
 704
 705 }}}
 706
 707 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 708 #include "ParsedCommand.cci"
 709 #include "ParsedCommand.ct"
 710 #include "ParsedCommand.cti"
 711 #endif
 712
 713 \f
 714 // Local Variables:
 715 // mode: c++
 716 // fill-column: 100
 717 // comment-column: 40
 718 // c-file-style: "senf"
 719 // indent-tabs-mode: nil
 720 // ispell-local-dictionary: "american"
 721 // compile-command: "scons -u test"
 722 // End: