Console/ParsedCommand.mpp

   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 Boost.Preprocesser external iteration include */
  25
  26 #if !BOOST_PP_IS_ITERATING && !defined(MPP_ParsedCommand_)
  27 #define MPP_ParsedCommand_ 1
  28
  29 // Custom includes
  30 #include <boost/preprocessor/iteration/iterate.hpp>
  31 #include <boost/preprocessor/repetition/enum_trailing.hpp>
  32 #include <boost/preprocessor/repetition/enum_params.hpp>
  33 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
  34 #include <boost/preprocessor/cat.hpp>
  35 #include <boost/preprocessor/arithmetic/inc.hpp>
  36 #include <boost/preprocessor/arithmetic/sub.hpp>
  37 #include <boost/preprocessor/repetition/repeat.hpp>
  38 #include <boost/type_traits/remove_reference.hpp>
  39 #include <boost/type_traits/remove_const.hpp>
  40 #include <boost/bind.hpp>
  41
  42 // ///////////////////////////mpp.p////////////////////////////////////////
  43 #elif BOOST_PP_IS_ITERATING // ////////////////////////////////////////////
  44 // ////////////////////////////////////////////////////////////////////////
  45 // Local Macros
  46
  47 #define mpp_ArgTypeN(n) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(n)), _type)
  48 #define mpp_ArgN(n) BOOST_PP_CAT(arg, BOOST_PP_INC(n))
  49
  50 #define mpp_ArgTypes_(z,n,d) typename traits::mpp_ArgTypeN(n)
  51 #define mpp_TrailingArgTypes() BOOST_PP_ENUM_TRAILING( BOOST_PP_ITERATION(), mpp_ArgTypes_, _ )
  52
  53 #define mpp_Args_(z,n,d) mpp_ArgN(n)
  54 #define mpp_TrailingArgs() BOOST_PP_ENUM_TRAILING( BOOST_PP_ITERATION(), mpp_Args_, _ )
  55
  56 #define mpp_BindArgs_(z,n,d) BOOST_PP_CAT( _, BOOST_PP_INC(BOOST_PP_INC(n)))
  57 #define mpp_TrailingBindArgs() BOOST_PP_ENUM_TRAILING( BOOST_PP_ITERATION(), mpp_BindArgs_, _ )
  58
  59 // ////////////////////////////////////////////////////////////////////////
  60 #if BOOST_PP_ITERATION_FLAGS()==1 // //////////////////////////////////////
  61 // ////////////////////////////////////////////////////////////////////////
  62
  63 // Header file (.hh)
  64
  65 template <class FunctionTraits, class ReturnValue>
  66 class ParsedCommandOverload<FunctionTraits, ReturnValue, BOOST_PP_ITERATION() >
  67     : public ParsedCommandOverloadBase
  68 {
  69 public:
  70     typedef boost::intrusive_ptr<ParsedCommandOverload> ptr;
  71     typedef FunctionTraits traits;
  72     typedef boost::function<typename traits::result_type(std::ostream &
  73                                                          mpp_TrailingArgTypes())> Function;
  74     typedef typename senf::remove_cvref<typename traits::result_type>::type result_type;
  75     typedef boost::function<void (result_type const &, std::ostream &)> Formatter;
  76
  77 #   define mpp_l(z,n,d)                                                                           \
  78         typedef typename senf::remove_cvref< typename traits::mpp_ArgTypeN(n) >::type             \
  79             mpp_ArgTypeN(n);
  80     BOOST_PP_REPEAT( BOOST_PP_ITERATION(), mpp_l, _ )
  81 #   undef mpp_l
  82
  83     static ptr create(Function fn);
  84
  85     void formatter(Formatter f);
  86
  87 protected:
  88
  89 private:
  90     ParsedCommandOverload(Function fn);
  91
  92     virtual void v_execute(std::ostream & os, ParseCommandInfo const & command) const;
  93
  94     Function function_;
  95     Formatter formatter_;
  96 };
  97
  98 template <class FunctionTraits>
  99 class ParsedCommandOverload<FunctionTraits, void, BOOST_PP_ITERATION() >
 100     : public ParsedCommandOverloadBase
 101 {
 102 public:
 103     typedef boost::intrusive_ptr<ParsedCommandOverload> ptr;
 104     typedef FunctionTraits traits;
 105     typedef boost::function<typename traits::result_type(std::ostream &
 106                                                          mpp_TrailingArgTypes())> Function;
 107     typedef void result_type;
 108
 109 #   define mpp_l(z,n,d)                                                                           \
 110         typedef typename senf::remove_cvref< typename traits::mpp_ArgTypeN(n) >::type             \
 111             mpp_ArgTypeN(n);
 112     BOOST_PP_REPEAT( BOOST_PP_ITERATION(), mpp_l, _ )
 113 #   undef mpp_l
 114
 115     static ptr create(Function fn);
 116
 117 protected:
 118
 119 private:
 120     ParsedCommandOverload(Function fn);
 121
 122     virtual void v_execute(std::ostream & os, ParseCommandInfo const & command) const;
 123
 124     Function function_;
 125 };
 126
 127 // ////////////////////////////////////////////////////////////////////////
 128 #elif BOOST_PP_ITERATION_FLAGS()==2 // ////////////////////////////////////
 129 // ////////////////////////////////////////////////////////////////////////
 130
 131 // inline template implementation (.cti)
 132
 133 template <class FunctionTraits, class ReturnValue>
 134 prefix_ typename senf::console::ParsedCommandOverload<FunctionTraits, ReturnValue, BOOST_PP_ITERATION() >::ptr
 135 senf::console::ParsedCommandOverload<FunctionTraits, ReturnValue, BOOST_PP_ITERATION() >::
 136 create(Function fn)
 137 {
 138     return ptr(new ParsedCommandOverload(fn));
 139 }
 140
 141 template <class FunctionTraits, class ReturnValue>
 142 void
 143 senf::console::ParsedCommandOverload<FunctionTraits, ReturnValue, BOOST_PP_ITERATION() >::
 144 formatter(Formatter f)
 145 {
 146     formatter_ = f;
 147 }
 148
 149 template <class FunctionTraits, class ReturnValue>
 150 prefix_
 151 senf::console::ParsedCommandOverload<FunctionTraits, ReturnValue, BOOST_PP_ITERATION()>::
 152 ParsedCommandOverload(Function fn)
 153     : function_ (fn)
 154 {
 155 #   define mpp_l(z,n,d) addParameter< mpp_ArgTypeN(n) >();
 156     BOOST_PP_REPEAT( BOOST_PP_ITERATION(), mpp_l, _ )
 157 #   undef mpp_l
 158 }
 159
 160 template <class FunctionTraits>
 161 prefix_ typename senf::console::ParsedCommandOverload<FunctionTraits, void, BOOST_PP_ITERATION() >::ptr
 162 senf::console::ParsedCommandOverload<FunctionTraits, void, BOOST_PP_ITERATION() >::
 163 create(Function fn)
 164 {
 165     return ptr(new ParsedCommandOverload(fn));
 166 }
 167
 168 template <class FunctionTraits>
 169 prefix_
 170 senf::console::ParsedCommandOverload<FunctionTraits, void, BOOST_PP_ITERATION() >::
 171 ParsedCommandOverload(Function fn)
 172     : function_ (fn)
 173 {
 174 #   define mpp_l(z,n,d) addParameter< mpp_ArgTypeN(n) >();
 175     BOOST_PP_REPEAT( BOOST_PP_ITERATION(), mpp_l, _ )
 176 #   undef mpp_l
 177 }
 178
 179 // ////////////////////////////////////////////////////////////////////////
 180 #elif BOOST_PP_ITERATION_FLAGS()==3 // ////////////////////////////////////
 181 // ////////////////////////////////////////////////////////////////////////
 182
 183 // non-inline template implementation (.ct)
 184
 185 template <class FunctionTraits, class ReturnValue>
 186 prefix_ void senf::console::ParsedCommandOverload<FunctionTraits, ReturnValue, BOOST_PP_ITERATION() >::
 187 v_execute(std::ostream & os, ParseCommandInfo const & command)
 188     const
 189 {
 190     if ( command.arguments().size() > BOOST_PP_ITERATION() )
 191         throw SyntaxErrorException("invalid number of arguments");
 192     int nDefaults ( BOOST_PP_ITERATION() - command.arguments().size() );
 193
 194     typedef typename boost::range_const_reverse_iterator<ParseCommandInfo::ArgumentsRange>::type
 195         riterator;
 196     riterator i (boost::rbegin(command.arguments()));
 197     riterator const i_end (boost::rend(command.arguments()));
 198
 199 #   define mpp_l(z,n,d)                                                                           \
 200         mpp_ArgTypeN(n) mpp_ArgN(n) (arg< mpp_ArgTypeN(n) >( n ).defaultValue);                   \
 201         if (! arg(n).hasDefault || nDefaults-- <= 0) {                                            \
 202             if (i == i_end)                                                                       \
 203                 throw SyntaxErrorException("invalid number of arguments");                        \
 204             if (arg< mpp_ArgTypeN(n) >(n).parser)                                                 \
 205                 arg< mpp_ArgTypeN(n) >(n).parser( *(i++), mpp_ArgN(n) );                          \
 206             else                                                                                  \
 207                 ArgumentTraits< mpp_ArgTypeN(n) >::parse( *(i++), mpp_ArgN(n) );                  \
 208         }
 209 #   define mpp_l_(z,n,d) mpp_l(z, BOOST_PP_SUB(BOOST_PP_DEC(BOOST_PP_ITERATION()), n), d)
 210     BOOST_PP_REPEAT( BOOST_PP_ITERATION(), mpp_l_, _ )
 211 #   undef mpp_l
 212 #   undef mpp_l_
 213
 214     if (formatter_)
 215         formatter_( function_(os mpp_TrailingArgs()), os );
 216     else
 217         ReturnValueTraits<result_type>::format( function_(os mpp_TrailingArgs()), os );
 218     os << "\n";
 219 }
 220
 221 template <class FunctionTraits>
 222 prefix_ void senf::console::ParsedCommandOverload<FunctionTraits, void, BOOST_PP_ITERATION() >::
 223 v_execute(std::ostream & os, ParseCommandInfo const & command)
 224     const
 225 {
 226     if ( command.arguments().size() > BOOST_PP_ITERATION() )
 227         throw SyntaxErrorException("invalid number of arguments");
 228     int nDefaults ( BOOST_PP_ITERATION() - command.arguments().size() );
 229
 230     typedef typename boost::range_const_reverse_iterator<ParseCommandInfo::ArgumentsRange>::type
 231         riterator;
 232     riterator i (boost::rbegin(command.arguments()));
 233     riterator const i_end (boost::rend(command.arguments()));
 234
 235 #   define mpp_l(z,n,d)                                                                           \
 236         mpp_ArgTypeN(n) mpp_ArgN(n) (arg< mpp_ArgTypeN(n) >( n ).defaultValue);                   \
 237         if (! arg(n).hasDefault || nDefaults-- <= 0) {                                            \
 238             if (i == i_end)                                                                       \
 239                 throw SyntaxErrorException("invalid number of arguments");                        \
 240             if (arg< mpp_ArgTypeN(n) >(n).parser)                                                 \
 241                 arg< mpp_ArgTypeN(n) >(n).parser( *(i++), mpp_ArgN(n) );                          \
 242             else                                                                                  \
 243                 ArgumentTraits< mpp_ArgTypeN(n) >::parse( *(i++), mpp_ArgN(n) );                  \
 244         }
 245 #   define mpp_l_(z,n,d) mpp_l(z, BOOST_PP_SUB(BOOST_PP_DEC(BOOST_PP_ITERATION()), n), d)
 246     BOOST_PP_REPEAT( BOOST_PP_ITERATION(), mpp_l_, _ )
 247 #   undef mpp_l
 248 #   undef mpp_l_
 249
 250     function_(os mpp_TrailingArgs());
 251 }
 252
 253 // ////////////////////////////////////////////////////////////////////////
 254 #elif BOOST_PP_ITERATION_FLAGS()==4 // ////////////////////////////////////
 255 // ////////////////////////////////////////////////////////////////////////
 256
 257 // CreateParsedCommandOverload
 258
 259 template <class Traits>
 260 struct CreateParsedCommandOverload<Traits, true, BOOST_PP_ITERATION()>
 261 {
 262     typedef typename Traits::traits traits;
 263
 264     template <class Function>
 265     static typename senf::console::ParsedCommandOverload<traits>::ptr create(Function fn)
 266         {
 267             return senf::console::ParsedCommandOverload<traits>::create(
 268                 boost::bind(fn  mpp_TrailingBindArgs()) );
 269         }
 270
 271 };
 272
 273 // ////////////////////////////////////////////////////////////////////////
 274 #elif BOOST_PP_ITERATION_FLAGS()==5 // ////////////////////////////////////
 275 // ////////////////////////////////////////////////////////////////////////
 276
 277 // Create keyword arg forwarding functions
 278
 279 template <BOOST_PP_ENUM_PARAMS( BOOST_PP_ITERATION(), class A ) >
 280 next_type arg ( BOOST_PP_ENUM_BINARY_PARAMS( BOOST_PP_ITERATION(), A, const & a ),
 281                 typename arg_params::match< BOOST_PP_ENUM_PARAMS( BOOST_PP_ITERATION(), A ) >::type
 282                     kw = arg_params()) const {
 283     return argInfo( kw(BOOST_PP_ENUM_PARAMS( BOOST_PP_ITERATION(), a )) );
 284 }
 285
 286 // ////////////////////////////////////////////////////////////////////////
 287 #endif // /////////////////////////////////////////////////////////////////
 288 // ////////////////////////////////////////////////////////////////////////
 289 // Undefine local Macros
 290
 291 #undef mpp_TrailingArgs
 292 #undef mpp_Args_
 293
 294 #undef mpp_TrailingArgTypes
 295 #undef mpp_ArgTypes_
 296
 297 #undef mpp_ArgN
 298 #undef mpp_ArgTypeN
 299
 300 // ////////////////////////////////////////////////////////////////////////
 301 #endif // /////////////////////////////////////////////////////////////////
 302 // ///////////////////////////mpp.e////////////////////////////////////////
 303
 304 \f
 305 // Local Variables:
 306 // mode: c++
 307 // fill-column: 100
 308 // comment-column: 40
 309 // c-file-style: "senf"
 310 // indent-tabs-mode: nil
 311 // ispell-local-dictionary: "american"
 312 // compile-command: "scons -u test"
 313 // End: