ceph/src/boost/libs/spirit/include/boost/spirit/home/classic/phoenix/primitives.hpp

   1 /*=============================================================================
   2     Phoenix V1.2.1
   3     Copyright (c) 2001-2002 Joel de Guzman
   4
   5   Distributed under the Boost Software License, Version 1.0. (See accompanying
   6   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 ==============================================================================*/
   8 #ifndef PHOENIX_PRIMITIVES_HPP
   9 #define PHOENIX_PRIMITIVES_HPP
  10
  11 ///////////////////////////////////////////////////////////////////////////////
  12 #include <boost/spirit/home/classic/phoenix/actor.hpp>
  13
  14 ///////////////////////////////////////////////////////////////////////////////
  15 namespace phoenix {
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 //
  19 //  argument class
  20 //
  21 //      Lazy arguments
  22 //
  23 //      An actor base class that extracts and returns the Nth argument
  24 //      from the argument list passed in the 'args' tuple in the eval
  25 //      member function (see actor.hpp). There are some predefined
  26 //      argument constants that can be used as actors (arg1..argN).
  27 //
  28 //      The argument actor is a place-holder for the actual arguments
  29 //      passed by the client. For example, wherever arg1 is seen placed
  30 //      in a lazy function (see functions.hpp) or lazy operator (see
  31 //      operators.hpp), this will be replaced by the actual first
  32 //      argument in the actual function evaluation. Argument actors are
  33 //      essentially lazy arguments. A lazy argument is a full actor in
  34 //      its own right and can be evaluated through the actor's operator().
  35 //
  36 //      Example:
  37 //
  38 //          char        c = 'A';
  39 //          int         i = 123;
  40 //          const char* s = "Hello World";
  41 //
  42 //          cout << arg1(c) << ' ';
  43 //          cout << arg1(i, s) << ' ';
  44 //          cout << arg2(i, s) << ' ';
  45 //
  46 //       will print out "A 123 Hello World"
  47 //
  48 ///////////////////////////////////////////////////////////////////////////////
  49 template <int N>
  50 struct argument {
  51
  52     template <typename TupleT>
  53     struct result { typedef typename tuple_element<N, TupleT>::type type; };
  54
  55     template <typename TupleT>
  56     typename tuple_element<N, TupleT>::type
  57     eval(TupleT const& args) const
  58     {
  59         return args[tuple_index<N>()];
  60     }
  61 };
  62
  63 //////////////////////////////////
  64 actor<argument<0> > const arg1 = argument<0>();
  65 actor<argument<1> > const arg2 = argument<1>();
  66 actor<argument<2> > const arg3 = argument<2>();
  67
  68 #if PHOENIX_LIMIT > 3
  69 actor<argument<3> > const arg4 = argument<3>();
  70 actor<argument<4> > const arg5 = argument<4>();
  71 actor<argument<5> > const arg6 = argument<5>();
  72
  73 #if PHOENIX_LIMIT > 6
  74 actor<argument<6> > const arg7 = argument<6>();
  75 actor<argument<7> > const arg8 = argument<7>();
  76 actor<argument<8> > const arg9 = argument<8>();
  77
  78 #if PHOENIX_LIMIT > 9
  79 actor<argument<9> > const arg10 = argument<9>();
  80 actor<argument<10> > const arg11 = argument<10>();
  81 actor<argument<11> > const arg12 = argument<11>();
  82
  83 #if PHOENIX_LIMIT > 12
  84 actor<argument<12> > const arg13 = argument<12>();
  85 actor<argument<13> > const arg14 = argument<13>();
  86 actor<argument<14> > const arg15 = argument<14>();
  87
  88 #endif
  89 #endif
  90 #endif
  91 #endif
  92 ///////////////////////////////////////////////////////////////////////////////
  93 //
  94 //  value class
  95 //
  96 //      Lazy values
  97 //
  98 //      A bound actual parameter is kept in a value class for deferred
  99 //      access later when needed. A value object is immutable. Value
 100 //      objects are typically created through the val(x) free function
 101 //      which returns a value<T> with T deduced from the type of x. x is
 102 //      held in the value<T> object by value.
 103 //
 104 //      Lazy values are actors. As such, lazy values can be evaluated
 105 //      through the actor's operator(). Such invocation gives the value's
 106 //      identity. Example:
 107 //
 108 //          cout << val(3)() << val("Hello World")();
 109 //
 110 //      prints out "3 Hello World"
 111 //
 112 ///////////////////////////////////////////////////////////////////////////////
 113 template <typename T>
 114 struct value {
 115
 116     typedef typename boost::remove_reference<T>::type plain_t;
 117
 118     template <typename TupleT>
 119     struct result { typedef plain_t const type; };
 120
 121     value(plain_t val_)
 122     :   val(val_) {}
 123
 124     template <typename TupleT>
 125     plain_t const
 126     eval(TupleT const& /*args*/) const
 127     {
 128         return val;
 129     }
 130
 131     plain_t val;
 132 };
 133
 134 //////////////////////////////////
 135 template <typename T>
 136 inline actor<value<T> > const
 137 val(T v)
 138 {
 139     return value<T>(v);
 140 }
 141
 142 //////////////////////////////////
 143 template <typename BaseT>
 144 void
 145 val(actor<BaseT> const& v);     //  This is undefined and not allowed.
 146
 147 ///////////////////////////////////////////////////////////////////////////
 148 //
 149 //  Arbitrary types T are typically converted to a actor<value<T> >
 150 //  (see as_actor<T> in actor.hpp). A specialization is also provided
 151 //  for arrays. T[N] arrays are converted to actor<value<T const*> >.
 152 //
 153 ///////////////////////////////////////////////////////////////////////////
 154 template <typename T>
 155 struct as_actor {
 156
 157     typedef actor<value<T> > type;
 158     static type convert(T const& x)
 159     { return value<T>(x); }
 160 };
 161
 162 //////////////////////////////////
 163 template <typename T, int N>
 164 struct as_actor<T[N]> {
 165
 166     typedef actor<value<T const*> > type;
 167     static type convert(T const x[N])
 168     { return value<T const*>(x); }
 169 };
 170
 171 ///////////////////////////////////////////////////////////////////////////////
 172 //
 173 //  variable class
 174 //
 175 //      Lazy variables
 176 //
 177 //      A bound actual parameter may also be held by non-const reference
 178 //      in a variable class for deferred access later when needed. A
 179 //      variable object is mutable, i.e. its referenced variable can be
 180 //      modified. Variable objects are typically created through the
 181 //      var(x) free function which returns a variable<T> with T deduced
 182 //      from the type of x. x is held in the value<T> object by
 183 //      reference.
 184 //
 185 //      Lazy variables are actors. As such, lazy variables can be
 186 //      evaluated through the actor's operator(). Such invocation gives
 187 //      the variables's identity. Example:
 188 //
 189 //          int i = 3;
 190 //          char const* s = "Hello World";
 191 //          cout << var(i)() << var(s)();
 192 //
 193 //      prints out "3 Hello World"
 194 //
 195 //      Another free function const_(x) may also be used. const_(x) creates
 196 //      a variable<T const&> object using a constant reference.
 197 //
 198 ///////////////////////////////////////////////////////////////////////////////
 199 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 200 #pragma warning(push)
 201 #pragma warning(disable:4512) //assignment operator could not be generated
 202 #endif
 203
 204 template <typename T>
 205 struct variable {
 206
 207     template <typename TupleT>
 208     struct result { typedef T& type; };
 209
 210     variable(T& var_)
 211     :   var(var_) {}
 212
 213     template <typename TupleT>
 214     T&
 215     eval(TupleT const& /*args*/) const
 216     {
 217         return var;
 218     }
 219
 220     T& var;
 221 };
 222
 223 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 224 #pragma warning(pop)
 225 #endif
 226
 227 //////////////////////////////////
 228 template <typename T>
 229 inline actor<variable<T> > const
 230 var(T& v)
 231 {
 232     return variable<T>(v);
 233 }
 234
 235 //////////////////////////////////
 236 template <typename T>
 237 inline actor<variable<T const> > const
 238 const_(T const& v)
 239 {
 240     return variable<T const>(v);
 241 }
 242
 243 //////////////////////////////////
 244 template <typename BaseT>
 245 void
 246 var(actor<BaseT> const& v);     //  This is undefined and not allowed.
 247
 248 //////////////////////////////////
 249 template <typename BaseT>
 250 void
 251 const_(actor<BaseT> const& v);  //  This is undefined and not allowed.
 252
 253 ///////////////////////////////////////////////////////////////////////////////
 254 }   //  namespace phoenix
 255
 256 #endif