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

   1 /*=============================================================================
   2     Phoenix V1.2.1
   3     Copyright (c) 2001-2002 Joel de Guzman
   4     MT code Copyright (c) 2002-2003 Martin Wille
   5
   6   Distributed under the Boost Software License, Version 1.0. (See accompanying
   7   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8 ==============================================================================*/
   9 #ifndef CLASSIC_PHOENIX_CLOSURES_HPP
  10 #define CLASSIC_PHOENIX_CLOSURES_HPP
  11
  12 ///////////////////////////////////////////////////////////////////////////////
  13 #include <boost/spirit/home/classic/phoenix/actor.hpp>
  14 #include <boost/assert.hpp>
  15
  16 #ifdef PHOENIX_THREADSAFE
  17 #include <boost/thread/tss.hpp>
  18 #include <boost/thread/once.hpp>
  19 #endif
  20
  21 ///////////////////////////////////////////////////////////////////////////////
  22 namespace phoenix {
  23
  24 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
  25 #pragma warning(push)
  26 #pragma warning(disable:4512) //assignment operator could not be generated
  27 #endif
  28
  29 ///////////////////////////////////////////////////////////////////////////////
  30 //
  31 //  Adaptable closures
  32 //
  33 //      The framework will not be complete without some form of closures
  34 //      support. Closures encapsulate a stack frame where local
  35 //      variables are created upon entering a function and destructed
  36 //      upon exiting. Closures provide an environment for local
  37 //      variables to reside. Closures can hold heterogeneous types.
  38 //
  39 //      Phoenix closures are true hardware stack based closures. At the
  40 //      very least, closures enable true reentrancy in lambda functions.
  41 //      A closure provides access to a function stack frame where local
  42 //      variables reside. Modeled after Pascal nested stack frames,
  43 //      closures can be nested just like nested functions where code in
  44 //      inner closures may access local variables from in-scope outer
  45 //      closures (accessing inner scopes from outer scopes is an error
  46 //      and will cause a run-time assertion failure).
  47 //
  48 //      There are three (3) interacting classes:
  49 //
  50 //      1) closure:
  51 //
  52 //      At the point of declaration, a closure does not yet create a
  53 //      stack frame nor instantiate any variables. A closure declaration
  54 //      declares the types and names[note] of the local variables. The
  55 //      closure class is meant to be subclassed. It is the
  56 //      responsibility of a closure subclass to supply the names for
  57 //      each of the local variable in the closure. Example:
  58 //
  59 //          struct my_closure : closure<int, string, double> {
  60 //
  61 //              member1 num;        // names the 1st (int) local variable
  62 //              member2 message;    // names the 2nd (string) local variable
  63 //              member3 real;       // names the 3rd (double) local variable
  64 //          };
  65 //
  66 //          my_closure clos;
  67 //
  68 //      Now that we have a closure 'clos', its local variables can be
  69 //      accessed lazily using the dot notation. Each qualified local
  70 //      variable can be used just like any primitive actor (see
  71 //      primitives.hpp). Examples:
  72 //
  73 //          clos.num = 30
  74 //          clos.message = arg1
  75 //          clos.real = clos.num * 1e6
  76 //
  77 //      The examples above are lazily evaluated. As usual, these
  78 //      expressions return composite actors that will be evaluated
  79 //      through a second function call invocation (see operators.hpp).
  80 //      Each of the members (clos.xxx) is an actor. As such, applying
  81 //      the operator() will reveal its identity:
  82 //
  83 //          clos.num() // will return the current value of clos.num
  84 //
  85 //      *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB)
  86 //      introduced and initilally implemented the closure member names
  87 //      that uses the dot notation.
  88 //
  89 //      2) closure_member
  90 //
  91 //      The named local variables of closure 'clos' above are actually
  92 //      closure members. The closure_member class is an actor and
  93 //      conforms to its conceptual interface. member1..memberN are
  94 //      predefined typedefs that correspond to each of the listed types
  95 //      in the closure template parameters.
  96 //
  97 //      3) closure_frame
  98 //
  99 //      When a closure member is finally evaluated, it should refer to
 100 //      an actual instance of the variable in the hardware stack.
 101 //      Without doing so, the process is not complete and the evaluated
 102 //      member will result to an assertion failure. Remember that the
 103 //      closure is just a declaration. The local variables that a
 104 //      closure refers to must still be instantiated.
 105 //
 106 //      The closure_frame class does the actual instantiation of the
 107 //      local variables and links these variables with the closure and
 108 //      all its members. There can be multiple instances of
 109 //      closure_frames typically situated in the stack inside a
 110 //      function. Each closure_frame instance initiates a stack frame
 111 //      with a new set of closure local variables. Example:
 112 //
 113 //          void foo()
 114 //          {
 115 //              closure_frame<my_closure> frame(clos);
 116 //              /* do something */
 117 //          }
 118 //
 119 //      where 'clos' is an instance of our closure 'my_closure' above.
 120 //      Take note that the usage above precludes locally declared
 121 //      classes. If my_closure is a locally declared type, we can still
 122 //      use its self_type as a paramater to closure_frame:
 123 //
 124 //          closure_frame<my_closure::self_type> frame(clos);
 125 //
 126 //      Upon instantiation, the closure_frame links the local variables
 127 //      to the closure. The previous link to another closure_frame
 128 //      instance created before is saved. Upon destruction, the
 129 //      closure_frame unlinks itself from the closure and relinks the
 130 //      preceding closure_frame prior to this instance.
 131 //
 132 //      The local variables in the closure 'clos' above is default
 133 //      constructed in the stack inside function 'foo'. Once 'foo' is
 134 //      exited, all of these local variables are destructed. In some
 135 //      cases, default construction is not desirable and we need to
 136 //      initialize the local closure variables with some values. This
 137 //      can be done by passing in the initializers in a compatible
 138 //      tuple. A compatible tuple is one with the same number of
 139 //      elements as the destination and where each element from the
 140 //      destination can be constructed from each corresponding element
 141 //      in the source. Example:
 142 //
 143 //          tuple<int, char const*, int> init(123, "Hello", 1000);
 144 //          closure_frame<my_closure> frame(clos, init);
 145 //
 146 //      Here now, our closure_frame's variables are initialized with
 147 //      int: 123, char const*: "Hello" and int: 1000.
 148 //
 149 ///////////////////////////////////////////////////////////////////////////////
 150
 151 namespace impl
 152 {
 153     ///////////////////////////////////////////////////////////////////////
 154     // closure_frame_holder is a simple class that encapsulates the
 155     // storage for a frame pointer. It uses thread specific data in
 156     // case when multithreading is enabled, an ordinary pointer otherwise
 157     //
 158     // it has get() and set() member functions. set() has to be used
 159     // _after_ get(). get() contains intialisation code in the multi
 160     // threading case
 161     //
 162     // closure_frame_holder is used by the closure<> class to store
 163     // the pointer to the current frame.
 164     //
 165 #ifndef PHOENIX_THREADSAFE
 166     template <typename FrameT>
 167     struct closure_frame_holder
 168     {
 169         typedef FrameT frame_t;
 170         typedef frame_t *frame_ptr;
 171
 172         closure_frame_holder() : frame(0) {}
 173
 174         frame_ptr &get() { return frame; }
 175         void set(frame_t *f) { frame = f; }
 176
 177     private:
 178         frame_ptr frame;
 179
 180         // no copies, no assignments
 181         closure_frame_holder(closure_frame_holder const &);
 182         closure_frame_holder &operator=(closure_frame_holder const &);
 183     };
 184 #else
 185     template <typename FrameT>
 186     struct closure_frame_holder
 187     {
 188         typedef FrameT   frame_t;
 189         typedef frame_t *frame_ptr;
 190
 191         closure_frame_holder() : tsp_frame() {}
 192
 193         frame_ptr &get()
 194         {
 195             if (!tsp_frame.get())
 196                 tsp_frame.reset(new frame_ptr(0));
 197             return *tsp_frame;
 198         }
 199         void set(frame_ptr f)
 200         {
 201             *tsp_frame = f;
 202         }
 203
 204     private:
 205         boost::thread_specific_ptr<frame_ptr> tsp_frame;
 206
 207         // no copies, no assignments
 208         closure_frame_holder(closure_frame_holder const &);
 209         closure_frame_holder &operator=(closure_frame_holder const &);
 210     };
 211 #endif
 212 } // namespace phoenix::impl
 213
 214 ///////////////////////////////////////////////////////////////////////////////
 215 //
 216 //  closure_frame class
 217 //
 218 ///////////////////////////////////////////////////////////////////////////////
 219 template <typename ClosureT>
 220 class closure_frame : public ClosureT::tuple_t {
 221
 222 public:
 223
 224     closure_frame(ClosureT const& clos)
 225     : ClosureT::tuple_t(), save(clos.frame.get()), frame(clos.frame)
 226     { clos.frame.set(this); }
 227
 228     template <typename TupleT>
 229     closure_frame(ClosureT const& clos, TupleT const& init)
 230     : ClosureT::tuple_t(init), save(clos.frame.get()), frame(clos.frame)
 231     { clos.frame.set(this); }
 232
 233     ~closure_frame()
 234     { frame.set(save); }
 235
 236 private:
 237
 238     closure_frame(closure_frame const&);            // no copy
 239     closure_frame& operator=(closure_frame const&); // no assign
 240
 241     closure_frame* save;
 242     impl::closure_frame_holder<closure_frame>& frame;
 243 };
 244
 245 ///////////////////////////////////////////////////////////////////////////////
 246 //
 247 //  closure_member class
 248 //
 249 ///////////////////////////////////////////////////////////////////////////////
 250 template <int N, typename ClosureT>
 251 class closure_member {
 252
 253 public:
 254
 255     typedef typename ClosureT::tuple_t tuple_t;
 256
 257     closure_member()
 258     : frame(ClosureT::closure_frame_holder_ref()) {}
 259
 260     template <typename TupleT>
 261     struct result {
 262
 263         typedef typename tuple_element<
 264             N, typename ClosureT::tuple_t
 265         >::rtype type;
 266     };
 267
 268     template <typename TupleT>
 269     typename tuple_element<N, typename ClosureT::tuple_t>::rtype
 270     eval(TupleT const& /*args*/) const
 271     {
 272         using namespace std;
 273         BOOST_ASSERT(frame.get() != 0);
 274         return (*frame.get())[tuple_index<N>()];
 275     }
 276
 277 private:
 278     impl::closure_frame_holder<typename ClosureT::closure_frame_t> &frame;
 279 };
 280
 281 ///////////////////////////////////////////////////////////////////////////////
 282 //
 283 //  closure class
 284 //
 285 ///////////////////////////////////////////////////////////////////////////////
 286 template <
 287         typename T0 = nil_t
 288     ,   typename T1 = nil_t
 289     ,   typename T2 = nil_t
 290
 291 #if PHOENIX_LIMIT > 3
 292     ,   typename T3 = nil_t
 293     ,   typename T4 = nil_t
 294     ,   typename T5 = nil_t
 295
 296 #if PHOENIX_LIMIT > 6
 297     ,   typename T6 = nil_t
 298     ,   typename T7 = nil_t
 299     ,   typename T8 = nil_t
 300
 301 #if PHOENIX_LIMIT > 9
 302     ,   typename T9 = nil_t
 303     ,   typename T10 = nil_t
 304     ,   typename T11 = nil_t
 305
 306 #if PHOENIX_LIMIT > 12
 307     ,   typename T12 = nil_t
 308     ,   typename T13 = nil_t
 309     ,   typename T14 = nil_t
 310
 311 #endif
 312 #endif
 313 #endif
 314 #endif
 315 >
 316 class closure {
 317
 318 public:
 319
 320     typedef tuple<
 321             T0, T1, T2
 322 #if PHOENIX_LIMIT > 3
 323         ,   T3, T4, T5
 324 #if PHOENIX_LIMIT > 6
 325         ,   T6, T7, T8
 326 #if PHOENIX_LIMIT > 9
 327         ,   T9, T10, T11
 328 #if PHOENIX_LIMIT > 12
 329         ,   T12, T13, T14
 330 #endif
 331 #endif
 332 #endif
 333 #endif
 334         > tuple_t;
 335
 336     typedef closure<
 337             T0, T1, T2
 338 #if PHOENIX_LIMIT > 3
 339         ,   T3, T4, T5
 340 #if PHOENIX_LIMIT > 6
 341         ,   T6, T7, T8
 342 #if PHOENIX_LIMIT > 9
 343         ,   T9, T10, T11
 344 #if PHOENIX_LIMIT > 12
 345         ,   T12, T13, T14
 346 #endif
 347 #endif
 348 #endif
 349 #endif
 350         > self_t;
 351
 352     typedef closure_frame<self_t> closure_frame_t;
 353
 354                             closure()
 355                             : frame()       { closure_frame_holder_ref(&frame); }
 356
 357     typedef actor<closure_member<0, self_t> > member1;
 358     typedef actor<closure_member<1, self_t> > member2;
 359     typedef actor<closure_member<2, self_t> > member3;
 360
 361 #if PHOENIX_LIMIT > 3
 362     typedef actor<closure_member<3, self_t> > member4;
 363     typedef actor<closure_member<4, self_t> > member5;
 364     typedef actor<closure_member<5, self_t> > member6;
 365
 366 #if PHOENIX_LIMIT > 6
 367     typedef actor<closure_member<6, self_t> > member7;
 368     typedef actor<closure_member<7, self_t> > member8;
 369     typedef actor<closure_member<8, self_t> > member9;
 370
 371 #if PHOENIX_LIMIT > 9
 372     typedef actor<closure_member<9, self_t> > member10;
 373     typedef actor<closure_member<10, self_t> > member11;
 374     typedef actor<closure_member<11, self_t> > member12;
 375
 376 #if PHOENIX_LIMIT > 12
 377     typedef actor<closure_member<12, self_t> > member13;
 378     typedef actor<closure_member<13, self_t> > member14;
 379     typedef actor<closure_member<14, self_t> > member15;
 380
 381 #endif
 382 #endif
 383 #endif
 384 #endif
 385
 386 #if !defined(__MWERKS__) || (__MWERKS__ > 0x3002)
 387 private:
 388 #endif
 389
 390     closure(closure const&);            // no copy
 391     closure& operator=(closure const&); // no assign
 392
 393 #if !defined(__MWERKS__) || (__MWERKS__ > 0x3002)
 394     template <int N, typename ClosureT>
 395     friend class closure_member;
 396
 397     template <typename ClosureT>
 398     friend class closure_frame;
 399 #endif
 400
 401     typedef impl::closure_frame_holder<closure_frame_t> holder_t;
 402
 403 #ifdef PHOENIX_THREADSAFE
 404     static boost::thread_specific_ptr<holder_t*> &
 405     tsp_frame_instance()
 406     {
 407         static boost::thread_specific_ptr<holder_t*> the_instance;
 408         return the_instance;
 409     }
 410
 411     static void
 412     tsp_frame_instance_init()
 413     {
 414         tsp_frame_instance();
 415     }
 416 #endif
 417
 418     static holder_t &
 419     closure_frame_holder_ref(holder_t* holder_ = 0)
 420     {
 421 #ifdef PHOENIX_THREADSAFE
 422 #ifndef BOOST_THREAD_PROVIDES_ONCE_CXX11
 423         static boost::once_flag been_here = BOOST_ONCE_INIT;
 424 #else
 425         static boost::once_flag been_here;
 426 #endif
 427         boost::call_once(been_here, tsp_frame_instance_init);
 428         boost::thread_specific_ptr<holder_t*> &tsp_frame = tsp_frame_instance();
 429         if (!tsp_frame.get())
 430             tsp_frame.reset(new holder_t *(0));
 431         holder_t *& holder = *tsp_frame;
 432 #else
 433         static holder_t* holder = 0;
 434 #endif
 435         if (holder_ != 0)
 436             holder = holder_;
 437         return *holder;
 438     }
 439
 440     mutable holder_t frame;
 441 };
 442
 443 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 444 #pragma warning(pop)
 445 #endif
 446
 447 }
 448    //  namespace phoenix
 449
 450 #endif