comparison DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/primitives.hpp @ 16:2665513ce2d3

Add boost headers

+/*=============================================================================
+    Phoenix V1.2.1
+    Copyright (c) 2001-2002 Joel de Guzman
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef PHOENIX_PRIMITIVES_HPP
+#define PHOENIX_PRIMITIVES_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/spirit/home/classic/phoenix/actor.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace phoenix {
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  argument class
+//
+//      Lazy arguments
+//
+//      An actor base class that extracts and returns the Nth argument
+//      from the argument list passed in the 'args' tuple in the eval
+//      member function (see actor.hpp). There are some predefined
+//      argument constants that can be used as actors (arg1..argN).
+//
+//      The argument actor is a place-holder for the actual arguments
+//      passed by the client. For example, wherever arg1 is seen placed
+//      in a lazy function (see functions.hpp) or lazy operator (see
+//      operators.hpp), this will be replaced by the actual first
+//      argument in the actual function evaluation. Argument actors are
+//      essentially lazy arguments. A lazy argument is a full actor in
+//      its own right and can be evaluated through the actor's operator().
+//
+//      Example:
+//
+//          char        c = 'A';
+//          int         i = 123;
+//          const char* s = "Hello World";
+//
+//          cout << arg1(c) << ' ';
+//          cout << arg1(i, s) << ' ';
+//          cout << arg2(i, s) << ' ';
+//
+//       will print out "A 123 Hello World"
+//
+///////////////////////////////////////////////////////////////////////////////
+template <int N>
+struct argument {
+
+    template <typename TupleT>
+    struct result { typedef typename tuple_element<N, TupleT>::type type; };
+
+    template <typename TupleT>
+    typename tuple_element<N, TupleT>::type
+    eval(TupleT const& args) const
+    {
+        return args[tuple_index<N>()];
+    }
+};
+
+//////////////////////////////////
+actor<argument<0> > const arg1 = argument<0>();
+actor<argument<1> > const arg2 = argument<1>();
+actor<argument<2> > const arg3 = argument<2>();
+
+#if PHOENIX_LIMIT > 3
+actor<argument<3> > const arg4 = argument<3>();
+actor<argument<4> > const arg5 = argument<4>();
+actor<argument<5> > const arg6 = argument<5>();
+
+#if PHOENIX_LIMIT > 6
+actor<argument<6> > const arg7 = argument<6>();
+actor<argument<7> > const arg8 = argument<7>();
+actor<argument<8> > const arg9 = argument<8>();
+
+#if PHOENIX_LIMIT > 9
+actor<argument<9> > const arg10 = argument<9>();
+actor<argument<10> > const arg11 = argument<10>();
+actor<argument<11> > const arg12 = argument<11>();
+
+#if PHOENIX_LIMIT > 12
+actor<argument<12> > const arg13 = argument<12>();
+actor<argument<13> > const arg14 = argument<13>();
+actor<argument<14> > const arg15 = argument<14>();
+
+#endif
+#endif
+#endif
+#endif
+///////////////////////////////////////////////////////////////////////////////
+//
+//  value class
+//
+//      Lazy values
+//
+//      A bound actual parameter is kept in a value class for deferred
+//      access later when needed. A value object is immutable. Value
+//      objects are typically created through the val(x) free function
+//      which returns a value<T> with T deduced from the type of x. x is
+//      held in the value<T> object by value.
+//
+//      Lazy values are actors. As such, lazy values can be evaluated
+//      through the actor's operator(). Such invocation gives the value's
+//      identity. Example:
+//
+//          cout << val(3)() << val("Hello World")();
+//
+//      prints out "3 Hello World"
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename T>
+struct value {
+
+    typedef typename boost::remove_reference<T>::type plain_t;
+
+    template <typename TupleT>
+    struct result { typedef plain_t const type; };
+
+    value(plain_t val_)
+    :   val(val_) {}
+
+    template <typename TupleT>
+    plain_t const
+    eval(TupleT const& /*args*/) const
+    {
+        return val;
+    }
+
+    plain_t val;
+};
+
+//////////////////////////////////
+template <typename T>
+inline actor<value<T> > const
+val(T v)
+{
+    return value<T>(v);
+}
+
+//////////////////////////////////
+template <typename BaseT>
+void
+val(actor<BaseT> const& v);     //  This is undefined and not allowed.
+
+///////////////////////////////////////////////////////////////////////////
+//
+//  Arbitrary types T are typically converted to a actor<value<T> >
+//  (see as_actor<T> in actor.hpp). A specialization is also provided
+//  for arrays. T[N] arrays are converted to actor<value<T const*> >.
+//
+///////////////////////////////////////////////////////////////////////////
+template <typename T>
+struct as_actor {
+
+    typedef actor<value<T> > type;
+    static type convert(T const& x)
+    { return value<T>(x); }
+};
+
+//////////////////////////////////
+template <typename T, int N>
+struct as_actor<T[N]> {
+
+    typedef actor<value<T const*> > type;
+    static type convert(T const x[N])
+    { return value<T const*>(x); }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  variable class
+//
+//      Lazy variables
+//
+//      A bound actual parameter may also be held by non-const reference
+//      in a variable class for deferred access later when needed. A
+//      variable object is mutable, i.e. its referenced variable can be
+//      modified. Variable objects are typically created through the
+//      var(x) free function which returns a variable<T> with T deduced
+//      from the type of x. x is held in the value<T> object by
+//      reference.
+//
+//      Lazy variables are actors. As such, lazy variables can be
+//      evaluated through the actor's operator(). Such invocation gives
+//      the variables's identity. Example:
+//
+//          int i = 3;
+//          char const* s = "Hello World";
+//          cout << var(i)() << var(s)();
+//
+//      prints out "3 Hello World"
+//
+//      Another free function const_(x) may also be used. const_(x) creates
+//      a variable<T const&> object using a constant reference.
+//
+///////////////////////////////////////////////////////////////////////////////
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
+template <typename T>
+struct variable {
+
+    template <typename TupleT>
+    struct result { typedef T& type; };
+
+    variable(T& var_)
+    :   var(var_) {}
+
+    template <typename TupleT>
+    T&
+    eval(TupleT const& /*args*/) const
+    {
+        return var;
+    }
+
+    T& var;
+};
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
+//////////////////////////////////
+template <typename T>
+inline actor<variable<T> > const
+var(T& v)
+{
+    return variable<T>(v);
+}
+
+//////////////////////////////////
+template <typename T>
+inline actor<variable<T const> > const
+const_(T const& v)
+{
+    return variable<T const>(v);
+}
+
+//////////////////////////////////
+template <typename BaseT>
+void
+var(actor<BaseT> const& v);     //  This is undefined and not allowed.
+
+//////////////////////////////////
+template <typename BaseT>
+void
+const_(actor<BaseT> const& v);  //  This is undefined and not allowed.
+
+///////////////////////////////////////////////////////////////////////////////
+}   //  namespace phoenix
+
+#endif