Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/transform')
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/arg.hpp | 380 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/call.hpp | 416 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/default.hpp | 663 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/fold.hpp | 338 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp | 182 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/impl.hpp | 189 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/lazy.hpp | 83 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/make.hpp | 472 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/pass_through.hpp | 204 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/when.hpp | 278 |
10 files changed, 3205 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/transform/arg.hpp b/3rdParty/Boost/src/boost/proto/transform/arg.hpp new file mode 100644 index 0000000..ac41fa3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/arg.hpp @@ -0,0 +1,380 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file arg.hpp +/// Contains definition of the argN transforms. +// +// Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007 +#define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007 + +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/type_traits/is_array.hpp> + +namespace boost { namespace proto +{ + + /// \brief A PrimitiveTransform that returns the current expression + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// proto::terminal<int>::type & j = proto::_expr()(i); + /// assert( boost::addressof(i) == boost::addressof(j) ); + /// \endcode + struct _expr : transform<_expr> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// Returns the current expression. + /// \param e The current expression. + /// \return \c e + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + result_type + #else + typename impl::expr_param + #endif + operator()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return e; + } + }; + }; + + /// \brief A PrimitiveTransform that returns the current state + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// char ch = proto::_state()(i, 'a'); + /// assert( ch == 'a' ); + /// \endcode + struct _state : transform<_state> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef State result_type; + + /// Returns the current state. + /// \param s The current state. + /// \return \c s + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + result_type + #else + typename impl::state_param + #endif + operator ()( + typename impl::expr_param + , typename impl::state_param s + , typename impl::data_param + ) const + { + return s; + } + }; + }; + + /// \brief A PrimitiveTransform that returns the current data + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// std::string str("hello"); + /// std::string & data = proto::_data()(i, 'a', str); + /// assert( &str == &data ); + /// \endcode + struct _data : transform<_data> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Data result_type; + + /// Returns the current data. + /// \param d The current data. + /// \return \c d + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + result_type + #else + typename impl::data_param + #endif + operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param d + ) const + { + return d; + } + }; + }; + + /// \brief A PrimitiveTransform that returns N-th child of the current + /// expression. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// proto::terminal<int>::type & j = proto::_child_c<0>()(-i); + /// assert( boost::addressof(i) == boost::addressof(j) ); + /// \endcode + template<int N> + struct _child_c : transform<_child_c<N> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef + typename result_of::child_c<Expr, N>::type + result_type; + + /// Returns the N-th child of \c e + /// \pre <tt>arity_of\<Expr\>::value \> N</tt> + /// \param e The current expression. + /// \return <tt>proto::child_c\<N\>(e)</tt> + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + result_type + #else + typename result_of::child_c<typename impl::expr_param, N>::type + #endif + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return proto::child_c<N>(e); + } + }; + }; + + /// \brief A PrimitiveTransform that returns the value of the + /// current terminal expression. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// int j = proto::_value()(i); + /// assert( 42 == j ); + /// \endcode + struct _value : transform<_value> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef + typename result_of::value<Expr>::type + result_type; + + /// Returns the value of the specified terminal expression. + /// \pre <tt>arity_of\<Expr\>::value == 0</tt>. + /// \param e The current expression. + /// \return <tt>proto::value(e)</tt> + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + typename mpl::if_c<is_array<result_type>::value, result_type &, result_type>::type + #else + typename result_of::value<typename impl::expr_param>::type + #endif + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return proto::value(e); + } + }; + }; + + /// \brief A PrimitiveTransform that does nothing + /// and returns void. + struct _void : transform<_void> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef void result_type; + + /// Does nothing and returns void + void operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param + ) const + {} + }; + }; + + /// \brief A unary CallableTransform that wraps its argument + /// in a \c boost::reference_wrapper\<\>. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// boost::reference_wrapper<proto::terminal<int>::type> j + /// = proto::when<_, proto::_byref(_)>()(i); + /// assert( boost::addressof(i) == boost::addressof(j.get()) ); + /// \endcode + struct _byref : callable + { + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef boost::reference_wrapper<T const> const type; + }; + + template<typename This, typename T> + struct result<This(T &)> + { + typedef boost::reference_wrapper<T> const type; + }; + + /// Wrap the parameter \c t in a \c boost::reference_wrapper\<\> + /// \param t The object to wrap + /// \return <tt>boost::ref(t)</tt> + /// \throw nothrow + template<typename T> + boost::reference_wrapper<T> const operator ()(T &t) const + { + return boost::reference_wrapper<T>(t); + } + + /// \overload + /// + template<typename T> + boost::reference_wrapper<T const> const operator ()(T const &t) const + { + return boost::reference_wrapper<T const>(t); + } + }; + + /// \brief A unary CallableTransform that strips references + /// and \c boost::reference_wrapper\<\> from its argument. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// int j = 67; + /// int k = proto::when<_, proto::_byval(proto::_state)>()(i, boost::ref(j)); + /// assert( 67 == k ); + /// \endcode + struct _byval : callable + { + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef T type; + }; + + template<typename This, typename T> + struct result<This(T &)> + : result<This(T)> + {}; + + template<typename This, typename T> + struct result<This(boost::reference_wrapper<T>)> + : result<This(T)> + {}; + + /// \param t The object to unref + /// \return <tt>t</tt> + /// \throw nothrow + template<typename T> + T operator ()(T const &t) const + { + return t; + } + + /// \overload + /// + template<typename T> + T operator ()(boost::reference_wrapper<T> const &t) const + { + return t; + } + }; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_expr> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_state> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_data> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<int N> + struct is_callable<_child_c<N> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_value> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_byref> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_byval> + : mpl::true_ + {}; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/call.hpp b/3rdParty/Boost/src/boost/proto/transform/call.hpp new file mode 100644 index 0000000..12ac454 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/call.hpp @@ -0,0 +1,416 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \file call.hpp + /// Contains definition of the call<> transform. + // + // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007 + #define BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007 + + #include <boost/preprocessor/cat.hpp> + #include <boost/preprocessor/facilities/intercept.hpp> + #include <boost/preprocessor/iteration/iterate.hpp> + #include <boost/preprocessor/repetition/enum.hpp> + #include <boost/preprocessor/repetition/repeat.hpp> + #include <boost/preprocessor/repetition/enum_params.hpp> + #include <boost/preprocessor/repetition/enum_binary_params.hpp> + #include <boost/preprocessor/repetition/enum_trailing_params.hpp> + #include <boost/ref.hpp> + #include <boost/utility/result_of.hpp> + #include <boost/proto/proto_fwd.hpp> + #include <boost/proto/traits.hpp> + #include <boost/proto/transform/impl.hpp> + #include <boost/proto/detail/as_lvalue.hpp> + #include <boost/proto/detail/poly_function.hpp> + + namespace boost { namespace proto + { + /// \brief Wrap \c PrimitiveTransform so that <tt>when\<\></tt> knows + /// it is callable. Requires that the parameter is actually a + /// PrimitiveTransform. + /// + /// This form of <tt>call\<\></tt> is useful for annotating an + /// arbitrary PrimitiveTransform as callable when using it with + /// <tt>when\<\></tt>. Consider the following transform, which + /// is parameterized with another transform. + /// + /// \code + /// template<typename Grammar> + /// struct Foo + /// : when< + /// unary_plus<Grammar> + /// , Grammar(_child) // May or may not work. + /// > + /// {}; + /// \endcode + /// + /// The problem with the above is that <tt>when\<\></tt> may or + /// may not recognize \c Grammar as callable, depending on how + /// \c Grammar is implemented. (See <tt>is_callable\<\></tt> for + /// a discussion of this issue.) You can guard against + /// the issue by wrapping \c Grammar in <tt>call\<\></tt>, such + /// as: + /// + /// \code + /// template<typename Grammar> + /// struct Foo + /// : when< + /// unary_plus<Grammar> + /// , call<Grammar>(_child) // OK, this works + /// > + /// {}; + /// \endcode + /// + /// The above could also have been written as: + /// + /// \code + /// template<typename Grammar> + /// struct Foo + /// : when< + /// unary_plus<Grammar> + /// , call<Grammar(_child)> // OK, this works, too + /// > + /// {}; + /// \endcode + template<typename PrimitiveTransform> + struct call + : PrimitiveTransform + {}; + + /// \brief Either call the PolymorphicFunctionObject with 0 + /// arguments, or invoke the PrimitiveTransform with 3 + /// arguments. + template<typename Fun> + struct call<Fun()> : transform<call<Fun()> > + { + /// INTERNAL ONLY + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename BOOST_PROTO_RESULT_OF<Fun()>::type result_type; + + result_type operator()( + typename impl2::expr_param + , typename impl2::state_param + , typename impl2::data_param + ) const + { + return Fun()(); + } + }; + + /// INTERNAL ONLY + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : Fun::template impl<Expr, State, Data> + {}; + + /// Either call the PolymorphicFunctionObject \c Fun with 0 arguments; or + /// invoke the PrimitiveTransform \c Fun with 3 arguments: the current + /// expression, state, and data. + /// + /// If \c Fun is a nullary PolymorphicFunctionObject, return <tt>Fun()()</tt>. + /// Otherwise, return <tt>Fun()(e, s, d)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + + /// If \c Fun is a nullary PolymorphicFunctionObject, \c type is a typedef + /// for <tt>boost::result_of\<Fun()\>::type</tt>. Otherwise, it is + /// a typedef for <tt>boost::result_of\<Fun(Expr, State, Data)\>::type</tt>. + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, is_transform<Fun>::value> + {}; + }; + + /// \brief Either call the PolymorphicFunctionObject with 1 + /// argument, or invoke the PrimitiveTransform with 3 + /// arguments. + template<typename Fun, typename A0> + struct call<Fun(A0)> : transform<call<Fun(A0)> > + { + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename detail::poly_function_traits<Fun, Fun(a0)>::result_type result_type; + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename detail::poly_function_traits<Fun, Fun(a0)>::function_type()( + detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) + ); + } + }; + + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename Fun::template impl<a0, State, Data>::result_type result_type; + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename Fun::template impl<a0, State, Data>()( + typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) + , s + , d + ); + } + }; + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt> and \c X + /// be the type of \c x. + /// If \c Fun is a unary PolymorphicFunctionObject that accepts \c x, + /// then \c type is a typedef for <tt>boost::result_of\<Fun(X)\>::type</tt>. + /// Otherwise, it is a typedef for <tt>boost::result_of\<Fun(X, State, Data)\>::type</tt>. + + /// Either call the PolymorphicFunctionObject with 1 argument: + /// the result of applying the \c A0 transform; or + /// invoke the PrimitiveTransform with 3 arguments: + /// result of applying the \c A0 transform, the state, and the + /// data. + /// + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. + /// If \c Fun is a unary PolymorphicFunctionObject that accepts \c x, + /// then return <tt>Fun()(x)</tt>. Otherwise, return + /// <tt>Fun()(x, s, d)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, is_transform<Fun>::value> + {}; + }; + + /// \brief Either call the PolymorphicFunctionObject with 2 + /// arguments, or invoke the PrimitiveTransform with 3 + /// arguments. + template<typename Fun, typename A0, typename A1> + struct call<Fun(A0, A1)> : transform<call<Fun(A0, A1)> > + { + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename detail::poly_function_traits<Fun, Fun(a0, a1)>::result_type result_type; + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename detail::poly_function_traits<Fun, Fun(a0, a1)>::function_type()( + detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) + , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)) + ); + } + }; + + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename Fun::template impl<a0, a1, Data>::result_type result_type; + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename Fun::template impl<a0, a1, Data>()( + typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) + , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) + , d + ); + } + }; + + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt> and \c X + /// be the type of \c x. + /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt> and \c Y + /// be the type of \c y. + /// If \c Fun is a binary PolymorphicFunction object that accepts \c x + /// and \c y, then \c type is a typedef for + /// <tt>boost::result_of\<Fun(X, Y)\>::type</tt>. Otherwise, it is + /// a typedef for <tt>boost::result_of\<Fun(X, Y, Data)\>::type</tt>. + + /// Either call the PolymorphicFunctionObject with 2 arguments: + /// the result of applying the \c A0 transform, and the + /// result of applying the \c A1 transform; or invoke the + /// PrimitiveTransform with 3 arguments: the result of applying + /// the \c A0 transform, the result of applying the \c A1 + /// transform, and the data. + /// + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. + /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt>. + /// If \c Fun is a binary PolymorphicFunction object that accepts \c x + /// and \c y, return <tt>Fun()(x, y)</tt>. Otherwise, return + /// <tt>Fun()(x, y, d)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, is_transform<Fun>::value> + {}; + }; + + /// \brief Call the PolymorphicFunctionObject or the + /// PrimitiveTransform with the current expression, state + /// and data, transformed according to \c A0, \c A1, and + /// \c A2, respectively. + template<typename Fun, typename A0, typename A1, typename A2> + struct call<Fun(A0, A1, A2)> : transform<call<Fun(A0, A1, A2)> > + { + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2; + typedef typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::result_type result_type; + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::function_type()( + detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) + , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)) + , detail::as_lvalue(typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d)) + ); + } + }; + + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2; + typedef typename Fun::template impl<a0, a1, a2>::result_type result_type; + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename Fun::template impl<a0, a1, a2>()( + typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) + , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) + , typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) + ); + } + }; + + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. + /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt>. + /// Let \c z be <tt>when\<_, A2\>()(e, s, d)</tt>. + /// Return <tt>Fun()(x, y, z)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, is_transform<Fun>::value> + {}; + }; + + #if BOOST_PROTO_MAX_ARITY > 3 + #define BOOST_PP_ITERATION_PARAMS_1 (3, (4, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/call.hpp>)) + #include BOOST_PP_ITERATE() + #endif + + /// INTERNAL ONLY + /// + template<typename Fun> + struct is_callable<call<Fun> > + : mpl::true_ + {}; + + }} // namespace boost::proto + + #endif + +#else + + #define N BOOST_PP_ITERATION() + + /// \brief Call the PolymorphicFunctionObject \c Fun with the + /// current expression, state and data, transformed according + /// to \c A0 through \c AN. + template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> : transform<call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + #define M0(Z, M, DATA) \ + typedef \ + typename when<_, BOOST_PP_CAT(A, M)> \ + ::template impl<Expr, State, Data> \ + ::result_type \ + BOOST_PP_CAT(a, M); \ + /**/ + BOOST_PP_REPEAT(N, M0, ~) + #undef M0 + + typedef + typename detail::poly_function_traits<Fun, Fun(BOOST_PP_ENUM_PARAMS(N, a))>::result_type + result_type; + + /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt> + /// for each \c x in <tt>[0,N]</tt>. + /// Return <tt>Fun()(a0, a1,... aN)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + #define M0(Z, M, DATA) \ + detail::as_lvalue( \ + typename when<_, BOOST_PP_CAT(A, M)> \ + ::template impl<Expr, State, Data>()(e, s, d)) \ + /**/ + return typename detail::poly_function_traits<Fun, Fun(BOOST_PP_ENUM_PARAMS(N, a))>::function_type()( + BOOST_PP_ENUM(N, M0, ~) + ); + #undef M0 + } + }; + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/default.hpp b/3rdParty/Boost/src/boost/proto/transform/default.hpp new file mode 100644 index 0000000..ec4a61f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/default.hpp @@ -0,0 +1,663 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \file default.hpp + /// Contains definition of the _default transform, which gives operators their + /// usual C++ meanings and uses Boost.Typeof to deduce return types. + // + // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008 + #define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008 + + #include <boost/preprocessor/iteration/iterate.hpp> + #include <boost/preprocessor/repetition/repeat.hpp> + #include <boost/preprocessor/arithmetic/add.hpp> + #include <boost/preprocessor/arithmetic/sub.hpp> + #include <boost/preprocessor/repetition/enum.hpp> + #include <boost/preprocessor/repetition/enum_shifted.hpp> + #include <boost/preprocessor/repetition/enum_shifted_params.hpp> + #include <boost/ref.hpp> + #include <boost/get_pointer.hpp> + #include <boost/utility/enable_if.hpp> + #include <boost/type_traits/is_member_pointer.hpp> + #include <boost/type_traits/is_member_object_pointer.hpp> + #include <boost/type_traits/is_member_function_pointer.hpp> + #include <boost/proto/proto_fwd.hpp> + #include <boost/proto/traits.hpp> + #include <boost/proto/transform/impl.hpp> + #include <boost/proto/transform/arg.hpp> + #include <boost/proto/detail/decltype.hpp> + + namespace boost { namespace proto + { + namespace detail + { + template<typename Grammar, typename Tag> + struct default_case + : not_<_> + {}; + + template<typename Grammar> + struct default_case<Grammar, tag::terminal> + : when<terminal<_>, _value> + {}; + + template<typename Grammar> + struct default_cases + { + template<typename Tag> + struct case_ + : default_case<Grammar, Tag> + {}; + }; + + #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \ + template<typename Grammar> \ + struct BOOST_PP_CAT(default_, TAG) \ + : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \ + { \ + template<typename Expr, typename State, typename Data> \ + struct impl \ + : transform_impl<Expr, State, Data> \ + { \ + private: \ + typedef typename result_of::child_c<Expr, 0>::type e0; \ + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \ + public: \ + BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \ + result_type operator ()( \ + typename impl::expr_param e \ + , typename impl::state_param s \ + , typename impl::data_param d \ + ) const \ + { \ + typename Grammar::template impl<e0, State, Data> t0; \ + return OP t0(proto::child_c<0>(e), s, d); \ + } \ + }; \ + }; \ + \ + template<typename Grammar> \ + struct default_case<Grammar, tag::TAG> \ + : when<unary_expr<tag::TAG, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \ + {}; \ + /**/ + + #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \ + template<typename Grammar> \ + struct BOOST_PP_CAT(default_, TAG) \ + : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \ + { \ + template<typename Expr, typename State, typename Data> \ + struct impl \ + : transform_impl<Expr, State, Data> \ + { \ + private: \ + typedef typename result_of::child_c<Expr, 0>::type e0; \ + typedef typename result_of::child_c<Expr, 1>::type e1; \ + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \ + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; \ + public: \ + BOOST_PROTO_DECLTYPE_( \ + proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \ + , result_type \ + ) \ + result_type operator ()( \ + typename impl::expr_param e \ + , typename impl::state_param s \ + , typename impl::data_param d \ + ) const \ + { \ + typename Grammar::template impl<e0, State, Data> t0; \ + typename Grammar::template impl<e1, State, Data> t1; \ + return t0(proto::child_c<0>(e), s, d) \ + OP t1(proto::child_c<1>(e), s, d); \ + } \ + }; \ + }; \ + \ + template<typename Grammar> \ + struct default_case<Grammar, tag::TAG> \ + : when<binary_expr<tag::TAG, Grammar, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \ + {}; \ + /**/ + + BOOST_PROTO_UNARY_DEFAULT_EVAL(+, unary_plus, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(-, negate, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(*, dereference, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(~, complement, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(&, address_of, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(!, logical_not, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(++, pre_inc, make_mutable) + BOOST_PROTO_UNARY_DEFAULT_EVAL(--, pre_dec, make_mutable) + + BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, shift_left, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, shift_right, make_mutable, make_mutable) + BOOST_PROTO_BINARY_DEFAULT_EVAL(*, multiplies, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(/, divides, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(%, modulus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(+, plus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(-, minus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<, less, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>, greater, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, less_equal, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, greater_equal, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(==, equal_to, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, not_equal_to, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(||, logical_or, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, logical_and, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&, bitwise_and, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(|, bitwise_or, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(^, bitwise_xor, make, make) + + BOOST_PROTO_BINARY_DEFAULT_EVAL(=, assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, shift_left_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, shift_right_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, multiplies_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, divides_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, modulus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, plus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, minus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, bitwise_and_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, bitwise_or_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, bitwise_xor_assign, make_mutable, make) + + #undef BOOST_PROTO_UNARY_DEFAULT_EVAL + #undef BOOST_PROTO_BINARY_DEFAULT_EVAL + + /// INTERNAL ONLY + template<typename Grammar, typename Expr, typename State, typename Data> + struct is_member_function_invocation + : is_member_function_pointer< + typename uncvref< + typename Grammar::template impl< + typename result_of::child_c<Expr, 1>::type + , State + , Data + >::result_type + >::type + > + {}; + + /// INTERNAL ONLY + template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall> + struct default_mem_ptr_impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type; + result_type operator ()( + typename default_mem_ptr_impl::expr_param e + , typename default_mem_ptr_impl::state_param s + , typename default_mem_ptr_impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return detail::mem_ptr_fun<r0, r1>()( + t0(proto::child_c<0>(e), s, d) + , t1(proto::child_c<1>(e), s, d) + ); + } + }; + + /// INTERNAL ONLY + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_mem_ptr_impl<Grammar, Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + typedef detail::memfun<r0, r1> result_type; + result_type const operator ()( + typename default_mem_ptr_impl::expr_param e + , typename default_mem_ptr_impl::state_param s + , typename default_mem_ptr_impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return detail::memfun<r0, r1>( + t0(proto::child_c<0>(e), s, d) + , t1(proto::child_c<1>(e), s, d) + ); + } + }; + + template<typename Grammar> + struct default_mem_ptr + : transform<default_mem_ptr<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : default_mem_ptr_impl< + Grammar + , Expr + , State + , Data + , is_member_function_invocation<Grammar, Expr, State, Data>::value + > + {}; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::mem_ptr> + : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> > + {}; + + template<typename Grammar> + struct default_post_inc + : transform<default_post_inc<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + public: + BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + return t0(proto::child_c<0>(e), s, d) ++; + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::post_inc> + : when<post_inc<Grammar>, default_post_inc<Grammar> > + {}; + + template<typename Grammar> + struct default_post_dec + : transform<default_post_dec<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + public: + BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + return t0(proto::child_c<0>(e), s, d) --; + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::post_dec> + : when<post_dec<Grammar>, default_post_dec<Grammar> > + {}; + + template<typename Grammar> + struct default_subscript + : transform<default_subscript<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + BOOST_PROTO_DECLTYPE_( + proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ] + , result_type + ) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return t0(proto::child_c<0>(e), s, d) [ + t1(proto::child_c<1>(e), s, d) ]; + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::subscript> + : when<subscript<Grammar, Grammar>, default_subscript<Grammar> > + {}; + + template<typename Grammar> + struct default_if_else_ + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename result_of::child_c<Expr, 2>::type e2; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + typedef typename Grammar::template impl<e2, State, Data>::result_type r2; + public: + BOOST_PROTO_DECLTYPE_( + proto::detail::make<r0>() + ? proto::detail::make<r1>() + : proto::detail::make<r2>() + , result_type + ) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + typename Grammar::template impl<e2, State, Data> t2; + return t0(proto::child_c<0>(e), s, d) + ? t1(proto::child_c<1>(e), s, d) + : t2(proto::child_c<2>(e), s, d); + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::if_else_> + : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> > + {}; + + template<typename Grammar> + struct default_comma + : transform<default_comma<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + typedef typename proto::detail::comma_result<r0, r1>::type result_type; + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return t0(proto::child_c<0>(e), s, d) + , t1(proto::child_c<1>(e), s, d); + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::comma> + : when<comma<Grammar, Grammar>, default_comma<Grammar> > + {}; + + template<typename Grammar, typename Expr, typename State, typename Data, long Arity> + struct default_function_impl; + + template<typename Grammar> + struct default_function + : transform<default_function<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : default_function_impl< + Grammar + , Expr + , State + , Data + , transform_impl<Expr, State, Data>::expr::proto_arity_c + > + {}; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::function> + : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> > + {}; + + #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \ + typedef \ + typename result_of::child_c<DATA, N>::type \ + BOOST_PP_CAT(e, N); \ + \ + typedef \ + typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type \ + BOOST_PP_CAT(r, N); \ + /**/ + + #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \ + typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()( \ + proto::child_c<N>(DATA), s, d \ + ) \ + /**/ + + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) + + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + + typedef + typename BOOST_PROTO_RESULT_OF<function_type()>::type + result_type; + + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(); + } + }; + + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr) + + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + + typedef + typename detail::result_of_<function_type(r1)>::type + result_type; + + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke( + e + , s + , d + , is_member_function_pointer<function_type>() + , is_member_object_pointer<function_type>() + ); + } + + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + , mpl::false_ + ) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(BOOST_PROTO_DEFAULT_EVAL(~, 1, e)); + } + + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + , mpl::false_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::classtypeof<function_type>::type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, e) + )(); + } + + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::classtypeof<function_type>::type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, e) + ); + } + }; + + #define BOOST_PP_ITERATION_PARAMS_1 (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/default.hpp>)) + #include BOOST_PP_ITERATE() + + #undef BOOST_PROTO_DEFAULT_EVAL_TYPE + #undef BOOST_PROTO_DEFAULT_EVAL + } + + template<typename Grammar /*= detail::_default*/> + struct _default + : switch_<detail::default_cases<Grammar> > + {}; + + template<typename Grammar> + struct is_callable<_default<Grammar> > + : mpl::true_ + {}; + + namespace detail + { + // Loopy indirection that allows proto::_default<> to be + // used without specifying a Grammar argument. + struct _default + : proto::_default<> + {}; + } + + }} + + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + BOOST_PP_REPEAT(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr) + + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r)) + >::type + result_type; + + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)( + BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, e) + ); + } + + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + #define M0(Z, M, DATA) BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA) + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::classtypeof<function_type>::type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, e) + )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), M0, e)); + #undef M0 + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/fold.hpp b/3rdParty/Boost/src/boost/proto/transform/fold.hpp new file mode 100644 index 0000000..b459bc6 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/fold.hpp @@ -0,0 +1,338 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \file fold.hpp + /// Contains definition of the fold<> and reverse_fold<> transforms. + // + // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007 + #define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007 + + #include <boost/version.hpp> + #include <boost/preprocessor/cat.hpp> + #include <boost/preprocessor/iteration/iterate.hpp> + #include <boost/preprocessor/arithmetic/inc.hpp> + #include <boost/preprocessor/arithmetic/sub.hpp> + #include <boost/preprocessor/repetition/repeat.hpp> + #include <boost/fusion/include/fold.hpp> + #include <boost/proto/proto_fwd.hpp> + #include <boost/proto/fusion.hpp> + #include <boost/proto/functional/fusion/reverse.hpp> + #include <boost/proto/traits.hpp> + #include <boost/proto/transform/call.hpp> + #include <boost/proto/transform/impl.hpp> + + namespace boost { namespace proto + { + namespace detail + { + template<typename Transform, typename Data> + struct as_callable + { + as_callable(Data d) + : d_(d) + {} + + template<typename Sig> + struct result; + + #if BOOST_VERSION >= 104200 + + template<typename This, typename State, typename Expr> + struct result<This(State, Expr)> + { + typedef + typename when<_, Transform>::template impl<Expr, State, Data>::result_type + type; + }; + + template<typename State, typename Expr> + typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type + operator ()(State const &s, Expr &e) const + { + return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_); + } + + #else + + template<typename This, typename Expr, typename State> + struct result<This(Expr, State)> + { + typedef + typename when<_, Transform>::template impl<Expr, State, Data>::result_type + type; + }; + + template<typename Expr, typename State> + typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type + operator ()(Expr &e, State const &s) const + { + return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_); + } + + #endif + + private: + Data d_; + }; + + template< + typename State0 + , typename Fun + , typename Expr + , typename State + , typename Data + , long Arity = arity_of<Expr>::value + > + struct fold_impl + {}; + + template< + typename State0 + , typename Fun + , typename Expr + , typename State + , typename Data + , long Arity = arity_of<Expr>::value + > + struct reverse_fold_impl + {}; + + #define BOOST_PROTO_CHILD_N_TYPE(N)\ + BOOST_PP_CAT(proto_child, N)\ + /**/ + + #define BOOST_PROTO_FOLD_STATE_TYPE(Z, N, DATA) \ + typedef \ + typename when<_, Fun>::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , BOOST_PP_CAT(state, N) \ + , Data \ + >::result_type \ + BOOST_PP_CAT(state, BOOST_PP_INC(N)); \ + /**/ + + #define BOOST_PROTO_FOLD_STATE(Z, N, DATA) \ + BOOST_PP_CAT(state, BOOST_PP_INC(N)) \ + BOOST_PP_CAT(s, BOOST_PP_INC(N)) \ + = typename when<_, Fun>::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , BOOST_PP_CAT(state, N) \ + , Data \ + >()( \ + proto::child_c<N>(e) \ + , BOOST_PP_CAT(s, N) \ + , d \ + ); \ + /**/ + + #define BOOST_PROTO_REVERSE_FOLD_STATE_TYPE(Z, N, DATA) \ + typedef \ + typename when<_, Fun>::template impl< \ + typename result_of::child_c< \ + Expr \ + , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \ + >::type \ + , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \ + , Data \ + >::result_type \ + BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))); \ + /**/ + + #define BOOST_PROTO_REVERSE_FOLD_STATE(Z, N, DATA) \ + BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \ + BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \ + = typename when<_, Fun>::template impl< \ + typename result_of::child_c< \ + Expr \ + , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \ + >::type \ + , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \ + , Data \ + >()( \ + proto::child_c<BOOST_PP_SUB(DATA, BOOST_PP_INC(N))>(e) \ + , BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, N)) \ + , d \ + ); \ + /**/ + + #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/fold.hpp>)) + #include BOOST_PP_ITERATE() + + #undef BOOST_PROTO_REVERSE_FOLD_STATE + #undef BOOST_PROTO_REVERSE_FOLD_STATE_TYPE + #undef BOOST_PROTO_FOLD_STATE + #undef BOOST_PROTO_FOLD_STATE_TYPE + #undef BOOST_PROTO_CHILD_N_TYPE + + } // namespace detail + + /// \brief A PrimitiveTransform that invokes the <tt>fusion::fold\<\></tt> + /// algorithm to accumulate + template<typename Sequence, typename State0, typename Fun> + struct fold : transform<fold<Sequence, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + /// \brief A Fusion sequence. + typedef + typename remove_reference< + typename when<_, Sequence>::template impl<Expr, State, Data>::result_type + >::type + sequence; + + /// \brief An initial state for the fold. + typedef + typename remove_reference< + typename when<_, State0>::template impl<Expr, State, Data>::result_type + >::type + state0; + + /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt> + typedef + detail::as_callable<Fun, Data> + fun; + + typedef + typename fusion::result_of::fold< + sequence + , state0 + , fun + >::type + result_type; + + /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let + /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and + /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt> + /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this + /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename when<_, Sequence>::template impl<Expr, State, Data> seq; + detail::as_callable<Fun, Data> f(d); + return fusion::fold( + seq(e, s, d) + , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d) + , f + ); + } + }; + }; + + /// \brief A PrimitiveTransform that is the same as the + /// <tt>fold\<\></tt> transform, except that it folds + /// back-to-front instead of front-to-back. It uses + /// the \c _reverse callable PolymorphicFunctionObject + /// to create a <tt>fusion::reverse_view\<\></tt> of the + /// sequence before invoking <tt>fusion::fold\<\></tt>. + template<typename Sequence, typename State0, typename Fun> + struct reverse_fold + : fold<call<_reverse(Sequence)>, State0, Fun> + {}; + + // This specialization is only for improved compile-time performance + // in the commom case when the Sequence transform is \c proto::_. + // + /// INTERNAL ONLY + /// + template<typename State0, typename Fun> + struct fold<_, State0, Fun> : transform<fold<_, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : detail::fold_impl<State0, Fun, Expr, State, Data> + {}; + }; + + // This specialization is only for improved compile-time performance + // in the commom case when the Sequence transform is \c proto::_. + // + /// INTERNAL ONLY + /// + template<typename State0, typename Fun> + struct reverse_fold<_, State0, Fun> : transform<reverse_fold<_, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : detail::reverse_fold_impl<State0, Fun, Expr, State, Data> + {}; + }; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State, typename Fun> + struct is_callable<fold<Sequence, State, Fun> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State, typename Fun> + struct is_callable<reverse_fold<Sequence, State, Fun> > + : mpl::true_ + {}; + + }} + + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE_TYPE, N) + typedef BOOST_PP_CAT(state, N) result_type; + + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE, N) + return BOOST_PP_CAT(s, N); + } + }; + + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type BOOST_PP_CAT(state, N); + BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE_TYPE, N) + typedef state0 result_type; + + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + BOOST_PP_CAT(state, N) BOOST_PP_CAT(s, N) = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE, N) + return s0; + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp b/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp new file mode 100644 index 0000000..ace2c21 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp @@ -0,0 +1,182 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file fold_tree.hpp +/// Contains definition of the fold_tree<> and reverse_fold_tree<> transforms. +// +// Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007 +#define BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007 + +#include <boost/type_traits/is_same.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/matches.hpp> +#include <boost/proto/transform/fold.hpp> +#include <boost/proto/transform/impl.hpp> + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Tag> + struct has_tag + { + template<typename Expr, typename State, typename Data, typename EnableIf = Tag> + struct impl + { + typedef mpl::false_ result_type; + }; + + template<typename Expr, typename State, typename Data> + struct impl<Expr, State, Data, typename Expr::proto_tag> + { + typedef mpl::true_ result_type; + }; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data, typename Expr::proto_tag> + { + typedef mpl::true_ result_type; + }; + }; + + template<typename Tag, typename Fun> + struct fold_tree_ + : if_<has_tag<Tag>, fold<_, _state, fold_tree_<Tag, Fun> >, Fun> + {}; + + template<typename Tag, typename Fun> + struct reverse_fold_tree_ + : if_<has_tag<Tag>, reverse_fold<_, _state, reverse_fold_tree_<Tag, Fun> >, Fun> + {}; + } + + /// \brief A PrimitiveTransform that recursively applies the + /// <tt>fold\<\></tt> transform to sub-trees that all share a common + /// tag type. + /// + /// <tt>fold_tree\<\></tt> is useful for flattening trees into lists; + /// for example, you might use <tt>fold_tree\<\></tt> to flatten an + /// expression tree like <tt>a | b | c</tt> into a Fusion list like + /// <tt>cons(c, cons(b, cons(a)))</tt>. + /// + /// <tt>fold_tree\<\></tt> is easily understood in terms of a + /// <tt>recurse_if_\<\></tt> helper, defined as follows: + /// + /// \code + /// template<typename Tag, typename Fun> + /// struct recurse_if_ + /// : if_< + /// // If the current node has type type "Tag" ... + /// is_same<tag_of<_>, Tag>() + /// // ... recurse, otherwise ... + /// , fold<_, _state, recurse_if_<Tag, Fun> > + /// // ... apply the Fun transform. + /// , Fun + /// > + /// {}; + /// \endcode + /// + /// With <tt>recurse_if_\<\></tt> as defined above, + /// <tt>fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is + /// equivalent to + /// <tt>fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> + /// It has the effect of folding a tree front-to-back, recursing into + /// child nodes that share a tag type with the parent node. + template<typename Sequence, typename State0, typename Fun> + struct fold_tree + : transform<fold_tree<Sequence, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : fold< + Sequence + , State0 + , detail::fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr, State, Data> + {}; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data> + : fold< + Sequence + , State0 + , detail::fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr &, State, Data> + {}; + }; + + /// \brief A PrimitiveTransform that recursively applies the + /// <tt>reverse_fold\<\></tt> transform to sub-trees that all share + /// a common tag type. + /// + /// <tt>reverse_fold_tree\<\></tt> is useful for flattening trees into + /// lists; for example, you might use <tt>reverse_fold_tree\<\></tt> to + /// flatten an expression tree like <tt>a | b | c</tt> into a Fusion list + /// like <tt>cons(a, cons(b, cons(c)))</tt>. + /// + /// <tt>reverse_fold_tree\<\></tt> is easily understood in terms of a + /// <tt>recurse_if_\<\></tt> helper, defined as follows: + /// + /// \code + /// template<typename Tag, typename Fun> + /// struct recurse_if_ + /// : if_< + /// // If the current node has type type "Tag" ... + /// is_same<tag_of<_>, Tag>() + /// // ... recurse, otherwise ... + /// , reverse_fold<_, _state, recurse_if_<Tag, Fun> > + /// // ... apply the Fun transform. + /// , Fun + /// > + /// {}; + /// \endcode + /// + /// With <tt>recurse_if_\<\></tt> as defined above, + /// <tt>reverse_fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is + /// equivalent to + /// <tt>reverse_fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> + /// It has the effect of folding a tree back-to-front, recursing into + /// child nodes that share a tag type with the parent node. + template<typename Sequence, typename State0, typename Fun> + struct reverse_fold_tree + : transform<reverse_fold_tree<Sequence, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : reverse_fold< + Sequence + , State0 + , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr, State, Data> + {}; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data> + : reverse_fold< + Sequence + , State0 + , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr &, State, Data> + {}; + }; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State0, typename Fun> + struct is_callable<fold_tree<Sequence, State0, Fun> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State0, typename Fun> + struct is_callable<reverse_fold_tree<Sequence, State0, Fun> > + : mpl::true_ + {}; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/impl.hpp b/3rdParty/Boost/src/boost/proto/transform/impl.hpp new file mode 100644 index 0000000..22e9337 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/impl.hpp @@ -0,0 +1,189 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file impl.hpp +/// Contains definition of transform<> and transform_impl<> helpers. +// +// Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008 +#define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008 + +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto +{ + /// INTERNAL ONLY + /// + #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \ + BOOST_PROTO_CALLABLE() \ + typedef X proto_is_transform_; \ + typedef PrimitiveTransform transform_type; \ + \ + template<typename Sig> \ + struct result \ + { \ + typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \ + }; \ + \ + template<typename Expr> \ + typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type \ + operator ()(Expr &e) const \ + { \ + int i = 0; \ + return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, i, i); \ + } \ + \ + template<typename Expr, typename State> \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State &)>::result_type \ + operator ()(Expr &e, State &s) const \ + { \ + int i = 0; \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State &)>()(e, s, i); \ + } \ + \ + template<typename Expr, typename State> \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>::result_type \ + operator ()(Expr &e, State const &s) const \ + { \ + int i = 0; \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>()(e, s, i); \ + } \ + \ + template<typename Expr, typename State, typename Data> \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>::result_type \ + operator ()(Expr &e, State &s, Data &d) const \ + { \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State, typename Data> \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>::result_type \ + operator ()(Expr &e, State const &s, Data &d) const \ + { \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>()(e, s, d); \ + } \ + /**/ + + #define BOOST_PROTO_TRANSFORM(PrimitiveTransform) \ + BOOST_PROTO_TRANSFORM_(PrimitiveTransform, void) \ + /**/ + + namespace detail + { + template<typename Sig> + struct apply_transform; + + template<typename PrimitiveTransform, typename Expr> + struct apply_transform<PrimitiveTransform(Expr)> + : PrimitiveTransform::template impl<Expr, int, int> + {}; + + template<typename PrimitiveTransform, typename Expr, typename State> + struct apply_transform<PrimitiveTransform(Expr, State)> + : PrimitiveTransform::template impl<Expr, State, int> + {}; + + template<typename PrimitiveTransform, typename Expr, typename State, typename Data> + struct apply_transform<PrimitiveTransform(Expr, State, Data)> + : PrimitiveTransform::template impl<Expr, State, Data> + {}; + } + + template<typename PrimitiveTransform, typename X> + struct transform + { + BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State, Data> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr, State &, Data> + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State state; + typedef State &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr, State, Data &> + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data data; + typedef Data &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State &, Data> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State state; + typedef State &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State, Data &> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data data; + typedef Data &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr, State &, Data &> + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State state; + typedef State &state_param; + typedef Data data; + typedef Data &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State &, Data &> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State state; + typedef State &state_param; + typedef Data data; + typedef Data &data_param; + }; + +}} // namespace boost::proto + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/lazy.hpp b/3rdParty/Boost/src/boost/proto/transform/lazy.hpp new file mode 100644 index 0000000..09581a9 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/lazy.hpp @@ -0,0 +1,83 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \file lazy.hpp + /// Contains definition of the lazy<> transform. + // + // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007 + #define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007 + + #include <boost/preprocessor/iteration/iterate.hpp> + #include <boost/preprocessor/repetition/enum_params.hpp> + #include <boost/preprocessor/repetition/enum_trailing_params.hpp> + #include <boost/proto/proto_fwd.hpp> + #include <boost/proto/transform/make.hpp> + #include <boost/proto/transform/call.hpp> + #include <boost/proto/transform/impl.hpp> + + namespace boost { namespace proto + { + /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build + /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it. + /// + /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the + /// transform to be applied depends on the current state of the + /// transformation. The invocation of the <tt>make\<\></tt> transform + /// evaluates any nested transforms, and the resulting type is treated + /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>. + template<typename Object> + struct lazy : transform<lazy<Object> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + >::template impl<Expr, State, Data> + {}; + }; + + #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/lazy.hpp>)) + #include BOOST_PP_ITERATE() + + /// INTERNAL ONLY + /// + template<typename Object> + struct is_callable<lazy<Object> > + : mpl::true_ + {}; + + }} + + #endif + +#else + + #define N BOOST_PP_ITERATION() + + /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build + /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it. + /// + /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the + /// transform to be applied depends on the current state of the + /// transformation. The invocation of the <tt>make\<\></tt> transform + /// evaluates any nested transforms, and the resulting type is treated + /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>. + template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (BOOST_PP_ENUM_PARAMS(N, A)) + >::template impl<Expr, State, Data> + {}; + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/make.hpp b/3rdParty/Boost/src/boost/proto/transform/make.hpp new file mode 100644 index 0000000..964886c --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/make.hpp @@ -0,0 +1,472 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \file make.hpp + /// Contains definition of the make<> transform. + // + // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007 + #define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007 + + #include <boost/detail/workaround.hpp> + #include <boost/preprocessor/repetition/enum.hpp> + #include <boost/preprocessor/repetition/enum_params.hpp> + #include <boost/preprocessor/repetition/enum_trailing_params.hpp> + #include <boost/preprocessor/repetition/enum_binary_params.hpp> + #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> + #include <boost/preprocessor/repetition/repeat_from_to.hpp> + #include <boost/preprocessor/facilities/intercept.hpp> + #include <boost/preprocessor/cat.hpp> + #include <boost/preprocessor/iteration/iterate.hpp> + #include <boost/preprocessor/selection/max.hpp> + #include <boost/preprocessor/arithmetic/inc.hpp> + #include <boost/mpl/and.hpp> + #include <boost/mpl/aux_/has_type.hpp> + #include <boost/mpl/aux_/template_arity.hpp> + #include <boost/mpl/aux_/lambda_arity_param.hpp> + #include <boost/utility/result_of.hpp> + #include <boost/proto/proto_fwd.hpp> + #include <boost/proto/traits.hpp> + #include <boost/proto/args.hpp> + #include <boost/proto/transform/impl.hpp> + #include <boost/proto/detail/as_lvalue.hpp> + #include <boost/proto/detail/ignore_unused.hpp> + + namespace boost { namespace proto + { + namespace detail + { + template<typename T> + struct is_applyable + : mpl::and_<is_callable<T>, is_transform<T> > + {}; + + template<typename T, bool HasType = mpl::aux::has_type<T>::value> + struct nested_type + { + typedef typename T::type type; + }; + + template<typename T> + struct nested_type<T, false> + { + typedef T type; + }; + + template<typename T, bool Applied> + struct nested_type_if + { + typedef T type; + static bool const applied = false; + }; + + template<typename T> + struct nested_type_if<T, true> + : nested_type<T> + { + static bool const applied = true; + }; + + template< + typename R + , typename Expr, typename State, typename Data + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(long Arity = mpl::aux::template_arity<R>::value) + > + struct make_ + { + typedef R type; + static bool const applied = false; + }; + + template< + typename R + , typename Expr, typename State, typename Data + , bool IsApplyable = is_applyable<R>::value + > + struct make_if_ + : make_<R, Expr, State, Data> + {}; + + template<typename R, typename Expr, typename State, typename Data> + struct make_if_<R, Expr, State, Data, true> + : uncvref<typename when<_, R>::template impl<Expr, State, Data>::result_type> + { + static bool const applied = true; + }; + + #if BOOST_WORKAROUND(__GNUC__, == 3) || (__GNUC__ == 4 && __GNUC_MINOR__ == 0) + // work around GCC bug + template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data> + struct make_if_<proto::expr<Tag, Args, N>, Expr, State, Data, false> + { + typedef proto::expr<Tag, Args, N> type; + static bool const applied = false; + }; + + // work around GCC bug + template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data> + struct make_if_<proto::basic_expr<Tag, Args, N>, Expr, State, Data, false> + { + typedef proto::basic_expr<Tag, Args, N> type; + static bool const applied = false; + }; + #endif + + template<typename Type, bool IsAggregate = is_aggregate<Type>::value> + struct construct_ + { + typedef Type result_type; + + Type operator ()() const + { + return Type(); + } + + #define TMP(Z, N, DATA) \ + template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \ + Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, &a)) const \ + { \ + return Type(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \ + } + BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), TMP, ~) + #undef TMP + }; + + template<typename Type> + struct construct_<Type, true> + { + typedef Type result_type; + + Type operator ()() const + { + return Type(); + } + + #define TMP(Z, N, DATA) \ + template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \ + Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, &a)) const \ + { \ + Type that = {BOOST_PP_ENUM_PARAMS_Z(Z, N, a)}; \ + return that; \ + } + BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), TMP, ~) + #undef TMP + }; + + #define TMP(Z, N, DATA) \ + template<typename Type BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, typename A)> \ + Type construct(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, &a)) \ + { \ + return construct_<Type>()(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \ + } + BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, TMP, ~) + #undef TMP + } + + /// \brief A PrimitiveTransform which prevents another PrimitiveTransform + /// from being applied in an \c ObjectTransform. + /// + /// When building higher order transforms with <tt>make\<\></tt> or + /// <tt>lazy\<\></tt>, you sometimes would like to build types that + /// are parameterized with Proto transforms. In such lambda-style + /// transforms, Proto will unhelpfully find all nested transforms + /// and apply them, even if you don't want them to be applied. Consider + /// the following transform, which will replace the \c _ in + /// <tt>Bar<_>()</tt> with <tt>proto::terminal\<int\>::type</tt>: + /// + /// \code + /// template<typename T> + /// struct Bar + /// {}; + /// + /// struct Foo + /// : proto::when<_, Bar<_>() > + /// {}; + /// + /// proto::terminal<int>::type i = {0}; + /// + /// int main() + /// { + /// Foo()(i); + /// std::cout << typeid(Foo()(i)).name() << std::endl; + /// } + /// \endcode + /// + /// If you actually wanted to default-construct an object of type + /// <tt>Bar\<_\></tt>, you would have to protect the \c _ to prevent + /// it from being applied. You can use <tt>proto::protect\<\></tt> + /// as follows: + /// + /// \code + /// // OK: replace anything with Bar<_>() + /// struct Foo + /// : proto::when<_, Bar<protect<_> >() > + /// {}; + /// \endcode + template<typename PrimitiveTransform> + struct protect : transform<protect<PrimitiveTransform> > + { + template<typename, typename, typename> + struct impl + { + typedef PrimitiveTransform result_type; + }; + }; + + /// \brief A PrimitiveTransform which computes a type by evaluating any + /// nested transforms and then constructs an object of that type. + /// + /// The <tt>make\<\></tt> transform checks to see if \c Object is a template. + /// If it is, the template type is disassembled to find nested transforms. + /// Proto considers the following types to represent transforms: + /// + /// \li Function types + /// \li Function pointer types + /// \li Types for which <tt>proto::is_callable\< type \>::value</tt> is \c true + /// + /// <tt>boost::result_of\<make\<T\<X0,X1,...\> \>(Expr, State, Data)\>::type</tt> + /// is evaluated as follows. For each \c X in <tt>X0,X1,...</tt>, do: + /// + /// \li If \c X is a template like <tt>U\<Y0,Y1,...\></tt>, then let <tt>X'</tt> + /// be <tt>boost::result_of\<make\<U\<Y0,Y1,...\> \>(Expr, State, Data)\>::type</tt> + /// (which evaluates this procedure recursively). Note whether any + /// substitutions took place during this operation. + /// \li Otherwise, if \c X is a transform, then let <tt>X'</tt> be + /// <tt>boost::result_of\<when\<_, X\>(Expr, State, Data)\>::type</tt>. + /// Note that a substitution took place. + /// \li Otherwise, let <tt>X'</tt> be \c X, and note that no substitution + /// took place. + /// \li If any substitutions took place in any of the above steps and + /// <tt>T\<X0',X1',...\></tt> has a nested <tt>::type</tt> typedef, + /// the result type is <tt>T\<X0',X1',...\>::type</tt>. + /// \li Otherwise, the result type is <tt>T\<X0',X1',...\></tt>. + /// + /// Note that <tt>when\<\></tt> is implemented in terms of <tt>call\<\></tt> + /// and <tt>make\<\></tt>, so the above procedure is evaluated recursively. + template<typename Object> + struct make : transform<make<Object> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + /// \return <tt>result_type()</tt> + result_type operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param + ) const + { + return result_type(); + } + }; + }; + + #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/make.hpp>)) + #include BOOST_PP_ITERATE() + + /// INTERNAL ONLY + /// + template<typename Object> + struct is_callable<make<Object> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename PrimitiveTransform> + struct is_callable<protect<PrimitiveTransform> > + : mpl::true_ + {}; + + }} + + #endif + +#else + + #define N BOOST_PP_ITERATION() + + namespace detail + { + #if N > 0 + #define TMP0(Z, M, DATA) make_if_<BOOST_PP_CAT(A, M), Expr, State, Data> + #define TMP1(Z, M, DATA) typename TMP0(Z, M, DATA) ::type + #define TMP2(Z, M, DATA) TMP0(Z, M, DATA) ::applied || + + template< + template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R + BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A) + , typename Expr, typename State, typename Data + > + struct make_< + R<BOOST_PP_ENUM_PARAMS(N, A)> + , Expr, State, Data + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(N) + > + : nested_type_if<R<BOOST_PP_ENUM(N, TMP1, ~)>, (BOOST_PP_REPEAT(N, TMP2, ~) false)> + {}; + + template< + template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R + BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A) + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<BOOST_PP_ENUM_PARAMS(N, A)> > + , Expr, State, Data + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(1) + > + { + typedef R<BOOST_PP_ENUM(N, TMP1, ~)> type; + static bool const applied = true; + }; + + #undef TMP0 + #undef TMP1 + #undef TMP2 + #endif + + template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct is_applyable<R(BOOST_PP_ENUM_PARAMS(N, A))> + : mpl::true_ + {}; + + template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct is_applyable<R(*)(BOOST_PP_ENUM_PARAMS(N, A))> + : mpl::true_ + {}; + + template<typename T, typename A> + struct construct_<proto::expr<T, A, N>, true> + { + typedef proto::expr<T, A, N> result_type; + + template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)> + result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const + { + return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a)); + } + }; + + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, N>, true> + { + typedef proto::basic_expr<T, A, N> result_type; + + template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)> + result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const + { + return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a)); + } + }; + } + + /// \brief A PrimitiveTransform which computes a type by evaluating any + /// nested transforms and then constructs an object of that type with the + /// current expression, state and data, transformed according + /// to \c A0 through \c AN. + template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make<Object(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + /// \brief <tt>boost::result_of\<make\<Object\>(Expr, State, Data)\>::type</tt> + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt> + /// for each \c x in <tt>[0,N]</tt>. + /// Return <tt>result_type(a0, a1,... aN)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>( + #define TMP(Z, M, DATA) \ + detail::as_lvalue( \ + typename when<_, BOOST_PP_CAT(A, M)> \ + ::template impl<Expr, State, Data>()(e, s, d) \ + ) + BOOST_PP_ENUM(N, TMP, DATA) + #undef TMP + ); + } + }; + }; + + #if BOOST_WORKAROUND(__GNUC__, == 3) || (__GNUC__ == 4 && __GNUC_MINOR__ == 0) + // work around GCC bug + template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + #define TMP(Z, M, DATA) \ + detail::as_lvalue( \ + typename when<_, BOOST_PP_CAT(A, M)> \ + ::template impl<Expr, State, Data>()(e, s, d) \ + ) + BOOST_PP_ENUM(N, TMP, DATA) + #undef TMP + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + #define TMP(Z, M, DATA) \ + detail::as_lvalue( \ + typename when<_, BOOST_PP_CAT(A, M)> \ + ::template impl<Expr, State, Data>()(e, s, d) \ + ) + BOOST_PP_ENUM(N, TMP, DATA) + #undef TMP + ); + } + }; + }; + #endif + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp b/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp new file mode 100644 index 0000000..216097b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp @@ -0,0 +1,204 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \file pass_through.hpp + /// + /// Definition of the pass_through transform, which is the default transform + /// of all of the expression generator metafunctions such as unary_plus<>, plus<> + /// and nary_expr<>. + // + // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006 + #define BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006 + + #include <boost/preprocessor/cat.hpp> + #include <boost/preprocessor/repetition/enum.hpp> + #include <boost/preprocessor/iteration/iterate.hpp> + #include <boost/mpl/bool.hpp> + #include <boost/type_traits/remove_reference.hpp> + #include <boost/proto/proto_fwd.hpp> + #include <boost/proto/args.hpp> + #include <boost/proto/transform/impl.hpp> + + namespace boost { namespace proto + { + namespace detail + { + template< + typename Grammar + , typename Expr + , typename State + , typename Data + , long Arity = arity_of<Expr>::value + > + struct pass_through_impl + {}; + + #define BOOST_PROTO_DEFINE_TRANSFORM_TYPE(Z, N, DATA) \ + typename Grammar::BOOST_PP_CAT(proto_child, N)::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , State \ + , Data \ + >::result_type \ + /**/ + + #define BOOST_PROTO_DEFINE_TRANSFORM(Z, N, DATA) \ + typename Grammar::BOOST_PP_CAT(proto_child, N)::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , State \ + , Data \ + >()( \ + e.proto_base().BOOST_PP_CAT(child, N), s, d \ + ) \ + /**/ + + #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/pass_through.hpp>)) + #include BOOST_PP_ITERATE() + + #undef BOOST_PROTO_DEFINE_TRANSFORM + #undef BOOST_PROTO_DEFINE_TRANSFORM_TYPE + + template<typename Grammar, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Expr, State, Data, 0> + : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// \param e An expression + /// \return \c e + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + result_type + #else + typename pass_through_impl::expr_param + #endif + operator()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param + , typename pass_through_impl::data_param + ) const + { + return e; + } + }; + + } // namespace detail + + /// \brief A PrimitiveTransform that transforms the child expressions + /// of an expression node according to the corresponding children of + /// a Grammar. + /// + /// Given a Grammar such as <tt>plus\<T0, T1\></tt>, an expression type + /// that matches the grammar such as <tt>plus\<E0, E1\>::type</tt>, a + /// state \c S and a data \c V, the result of applying the + /// <tt>pass_through\<plus\<T0, T1\> \></tt> transform is: + /// + /// \code + /// plus< + /// T0::result<T0(E0, S, V)>::type + /// , T1::result<T1(E1, S, V)>::type + /// >::type + /// \endcode + /// + /// The above demonstrates how child transforms and child expressions + /// are applied pairwise, and how the results are reassembled into a new + /// expression node with the same tag type as the original. + /// + /// The explicit use of <tt>pass_through\<\></tt> is not usually needed, + /// since the expression generator metafunctions such as + /// <tt>plus\<\></tt> have <tt>pass_through\<\></tt> as their default + /// transform. So, for instance, these are equivalent: + /// + /// \code + /// // Within a grammar definition, these are equivalent: + /// when< plus<X, Y>, pass_through< plus<X, Y> > > + /// when< plus<X, Y>, plus<X, Y> > + /// when< plus<X, Y> > // because of when<class X, class Y=X> + /// plus<X, Y> // because plus<> is both a + /// // grammar and a transform + /// \endcode + /// + /// For example, consider the following transform that promotes all + /// \c float terminals in an expression to \c double. + /// + /// \code + /// // This transform finds all float terminals in an expression and promotes + /// // them to doubles. + /// struct Promote + /// : or_< + /// when<terminal<float>, terminal<double>::type(_value) > + /// // terminal<>'s default transform is a no-op: + /// , terminal<_> + /// // nary_expr<> has a pass_through<> transform: + /// , nary_expr<_, vararg<Promote> > + /// > + /// {}; + /// \endcode + template<typename Grammar> + struct pass_through + : transform<pass_through<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<Grammar, Expr, State, Data> + {}; + }; + + /// INTERNAL ONLY + /// + template<typename Grammar> + struct is_callable<pass_through<Grammar> > + : mpl::true_ + {}; + + }} // namespace boost::proto + + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template<typename Grammar, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + + typedef + typename base_expr< + typename unref_expr::proto_domain + , typename unref_expr::proto_tag + , BOOST_PP_CAT(list, N)< + BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM_TYPE, ~) + > + >::type + expr_type; + + typedef typename unref_expr::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type const result_type; + + result_type const operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM, ~) + }; + #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) + // Without this, MSVC complains that "that" is uninitialized, + // and it actually triggers a runtime check in debug mode when + // built with VC8. + &that; + #endif + return proto_generator()(that); + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/when.hpp b/3rdParty/Boost/src/boost/proto/transform/when.hpp new file mode 100644 index 0000000..fc776ca --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/when.hpp @@ -0,0 +1,278 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \file when.hpp + /// Definition of when transform. + // + // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 + #define BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 + + #include <boost/preprocessor/cat.hpp> + #include <boost/preprocessor/repetition/enum_params.hpp> + #include <boost/preprocessor/repetition/enum_trailing_params.hpp> + #include <boost/preprocessor/iteration/iterate.hpp> + #include <boost/mpl/at.hpp> + #include <boost/mpl/if.hpp> + #include <boost/mpl/map.hpp> + #include <boost/proto/proto_fwd.hpp> + #include <boost/proto/traits.hpp> + #include <boost/proto/transform/call.hpp> + #include <boost/proto/transform/make.hpp> + #include <boost/proto/transform/impl.hpp> + + namespace boost { namespace proto + { + /// \brief A grammar element and a PrimitiveTransform that associates + /// a transform with the grammar. + /// + /// Use <tt>when\<\></tt> to override a grammar's default transform + /// with a custom transform. It is for used when composing larger + /// transforms by associating smaller transforms with individual + /// rules in your grammar, as in the following transform which + /// counts the number of terminals in an expression. + /// + /// \code + /// // Count the terminals in an expression tree. + /// // Must be invoked with initial state == mpl::int_<0>(). + /// struct CountLeaves + /// : or_< + /// when<terminal<_>, mpl::next<_state>()> + /// , otherwise<fold<_, _state, CountLeaves> > + /// > + /// {}; + /// \endcode + /// + /// In <tt>when\<G, T\></tt>, when \c T is a class type it is a + /// PrimitiveTransform and the following equivalencies hold: + /// + /// <tt>boost::result_of\<when\<G,T\>(E,S,V)\>::type</tt> is the same as + /// <tt>boost::result_of\<T(E,S,V)\>::type</tt>. + /// + /// <tt>when\<G,T\>()(e,s,d)</tt> is the same as + /// <tt>T()(e,s,d)</tt>. + template<typename Grammar, typename PrimitiveTransform /*= Grammar*/> + struct when + : PrimitiveTransform + { + typedef Grammar first; + typedef PrimitiveTransform second; + typedef typename Grammar::proto_grammar proto_grammar; + }; + + /// \brief A specialization that treats function pointer Transforms as + /// if they were function type Transforms. + /// + /// This specialization requires that \c Fun is actually a function type. + /// + /// This specialization is required for nested transforms such as + /// <tt>when\<G, T0(T1(_))\></tt>. In C++, functions that are used as + /// parameters to other functions automatically decay to funtion + /// pointer types. In other words, the type <tt>T0(T1(_))</tt> is + /// indistinguishable from <tt>T0(T1(*)(_))</tt>. This specialization + /// is required to handle these nested function pointer type transforms + /// properly. + template<typename Grammar, typename Fun> + struct when<Grammar, Fun *> + : when<Grammar, Fun> + {}; + + /// \brief Syntactic sugar for <tt>when\<_, Fun\></tt>, for use + /// in grammars to handle all the cases not yet handled. + /// + /// Use <tt>otherwise\<T\></tt> in your grammars as a synonym for + /// <tt>when\<_, T\></tt> as in the following transform which + /// counts the number of terminals in an expression. + /// + /// \code + /// // Count the terminals in an expression tree. + /// // Must be invoked with initial state == mpl::int_<0>(). + /// struct CountLeaves + /// : or_< + /// when<terminal<_>, mpl::next<_state>()> + /// , otherwise<fold<_, _state, CountLeaves> > + /// > + /// {}; + /// \endcode + template<typename Fun> + struct otherwise + : when<_, Fun> + {}; + + /// \brief This specialization uses the Data parameter as a collection + /// of transforms that can be indexed by the specified rule. + /// + /// Use <tt>when\<T, external_transform\></tt> in your code when you would like + /// to define a grammar once and use it to evaluate expressions with + /// many different sets of transforms. The transforms are found by + /// using the Data parameter as a map from rules to transforms. + /// + /// See \c action_map for an example. + template<typename Grammar> + struct when<Grammar, external_transform> + : proto::transform<when<Grammar, external_transform> > + { + typedef Grammar first; + typedef external_transform second; + typedef typename Grammar::proto_grammar proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : Data::template when<Grammar>::template impl<Expr, State, Data> + {}; + + template<typename Expr, typename State, typename Data> + struct impl<Expr, State, Data &> + : Data::template when<Grammar>::template impl<Expr, State, Data &> + {}; + }; + + /// \brief For defining a map of Rule/Transform pairs for use with + /// <tt>when\<T, external_transform\></tt> to make transforms external to the grammar + /// + /// The following code defines a grammar with a couple of external transforms. + /// It also defines an action_map that maps from rules to transforms. It then + /// passes that transforms map at the Data parameter to the grammar. In this way, + /// the behavior of the grammar can be modified post-hoc by passing a different + /// action_map. + /// + /// \code + /// struct int_terminal + /// : proto::terminal<int> + /// {}; + /// + /// struct char_terminal + /// : proto::terminal<char> + /// {}; + /// + /// struct my_grammar + /// : proto::or_< + /// proto::when< int_terminal, proto::external_transform > + /// , proto::when< char_terminal, proto::external_transform > + /// , proto::when< + /// proto::plus< my_grammar, my_grammar > + /// , proto::fold< _, int(), my_grammar > + /// > + /// > + /// {}; + /// + /// struct my_transforms + /// : proto::external_transforms< + /// proto::when<int_terminal, print(proto::_value)> + /// , proto::when<char_terminal, print(proto::_value)> + /// > + /// {}; + /// + /// proto::literal<int> i(1); + /// proto::literal<char> c('a'); + /// my_transforms trx; + /// + /// // Evaluate "i+c" using my_grammar with the specified transforms: + /// my_grammar()(i + c, 0, trx); + /// \endcode + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_LIMIT_MAP_SIZE, typename T, mpl::na)> + struct external_transforms + { + typedef mpl::map<BOOST_PP_ENUM_PARAMS(BOOST_MPL_LIMIT_MAP_SIZE, T)> map_type; + + template<typename Rule> + struct when + : proto::when<_, typename mpl::at<map_type, Rule>::type> + {}; + }; + + #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/when.hpp>)) + #include BOOST_PP_ITERATE() + + /// INTERNAL ONLY + /// + template<typename Grammar, typename Transform> + struct is_callable<when<Grammar, Transform> > + : mpl::true_ + {}; + + }} // namespace boost::proto + + #endif + +#else + + #define N BOOST_PP_ITERATION() + + /// \brief A grammar element and a PrimitiveTransform that associates + /// a transform with the grammar. + /// + /// Use <tt>when\<\></tt> to override a grammar's default transform + /// with a custom transform. It is for used when composing larger + /// transforms by associating smaller transforms with individual + /// rules in your grammar, as in the following transform which + /// counts the number of terminals in an expression. + /// + /// \code + /// // Count the terminals in an expression tree. + /// // Must be invoked with initial state == mpl::int_<0>(). + /// struct CountLeaves + /// : or_< + /// when<terminal<_>, mpl::next<_state>()> + /// , otherwise<fold<_, _state, CountLeaves> > + /// > + /// {}; + /// \endcode + /// + /// The <tt>when\<G, R(A0,A1,...)\></tt> form accepts either a + /// CallableTransform or an ObjectTransform as its second parameter. + /// <tt>when\<\></tt> uses <tt>is_callable\<R\>::value</tt> to + /// distinguish between the two, and uses <tt>call\<\></tt> to + /// evaluate CallableTransforms and <tt>make\<\></tt> to evaluate + /// ObjectTransforms. + template<typename Grammar, typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A))> > + { + typedef Grammar first; + typedef R second(BOOST_PP_ENUM_PARAMS(N, A)); + typedef typename Grammar::proto_grammar proto_grammar; + + // Note: do not evaluate is_callable<R> in this scope. + // R may be an incomplete type at this point. + + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + // OK to evaluate is_callable<R> here. R should be compete by now. + typedef + typename mpl::if_c< + is_callable<R>::value + , call<R(BOOST_PP_ENUM_PARAMS(N, A))> // "R" is a function to call + , make<R(BOOST_PP_ENUM_PARAMS(N, A))> // "R" is an object to construct + >::type + which; + + typedef typename which::template impl<Expr, State, Data>::result_type result_type; + + /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with + /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on + /// whether <tt>is_callable\<R\>::value</tt> is \c true or + /// \c false. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + /// \pre <tt>matches\<Expr, Grammar\>::value</tt> is \c true + /// \return <tt>which()(e, s, d)</tt> + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return typename which::template impl<Expr, State, Data>()(e, s, d); + } + }; + }; + + #undef N + +#endif |