Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: /// \file make.hpp
Chris@16: /// Contains definition of the make<> transform.
Chris@16: //
Chris@16: //  Copyright 2008 Eric Niebler. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #ifndef BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
Chris@16: #define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
Chris@16: 
Chris@16: #include <boost/detail/workaround.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_binary_params.hpp>
Chris@16: #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
Chris@16: #include <boost/preprocessor/repetition/repeat_from_to.hpp>
Chris@16: #include <boost/preprocessor/facilities/intercept.hpp>
Chris@16: #include <boost/preprocessor/cat.hpp>
Chris@16: #include <boost/preprocessor/iteration/iterate.hpp>
Chris@16: #include <boost/preprocessor/selection/max.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/inc.hpp>
Chris@16: #include <boost/mpl/and.hpp>
Chris@16: #include <boost/mpl/aux_/has_type.hpp>
Chris@16: #include <boost/proto/detail/template_arity.hpp>
Chris@16: #include <boost/utility/result_of.hpp>
Chris@16: #include <boost/proto/proto_fwd.hpp>
Chris@16: #include <boost/proto/traits.hpp>
Chris@16: #include <boost/proto/args.hpp>
Chris@16: #include <boost/proto/transform/impl.hpp>
Chris@16: #include <boost/proto/transform/detail/pack.hpp>
Chris@16: #include <boost/proto/detail/as_lvalue.hpp>
Chris@16: #include <boost/proto/detail/ignore_unused.hpp>
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: # pragma warning(push)
Chris@16: # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost { namespace proto
Chris@16: {
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         template<typename T>
Chris@16:         struct is_applyable
Chris@16:           : mpl::and_<is_callable<T>, is_transform<T> >
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename T, bool HasType = mpl::aux::has_type<T>::value>
Chris@16:         struct nested_type
Chris@16:         {
Chris@16:             typedef typename T::type type;
Chris@16:         };
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct nested_type<T, false>
Chris@16:         {
Chris@16:             typedef T type;
Chris@16:         };
Chris@16: 
Chris@16:         template<typename T, bool Applied>
Chris@16:         struct nested_type_if
Chris@16:         {
Chris@16:             typedef T type;
Chris@16:             static bool const applied = false;
Chris@16:         };
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct nested_type_if<T, true>
Chris@16:           : nested_type<T>
Chris@16:         {
Chris@16:             static bool const applied = true;
Chris@16:         };
Chris@16: 
Chris@16:         template<
Chris@16:             typename R
Chris@16:           , typename Expr, typename State, typename Data
Chris@16:             BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<R>::value)
Chris@16:         >
Chris@16:         struct make_
Chris@16:         {
Chris@16:             typedef R type;
Chris@16:             static bool const applied = false;
Chris@16:         };
Chris@16: 
Chris@16:         template<
Chris@16:             typename R
Chris@16:           , typename Expr, typename State, typename Data
Chris@16:           , bool IsApplyable = is_applyable<R>::value
Chris@16:         >
Chris@16:         struct make_if_
Chris@16:           : make_<R, Expr, State, Data>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename R, typename Expr, typename State, typename Data>
Chris@16:         struct make_if_<R, Expr, State, Data, true>
Chris@16:           : uncvref<typename when<_, R>::template impl<Expr, State, Data>::result_type>
Chris@16:         {
Chris@16:             static bool const applied = true;
Chris@16:         };
Chris@16: 
Chris@16:         #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0)
Chris@16:         // work around GCC bug
Chris@16:         template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data>
Chris@16:         struct make_if_<proto::expr<Tag, Args, N>, Expr, State, Data, false>
Chris@16:         {
Chris@16:             typedef proto::expr<Tag, Args, N> type;
Chris@16:             static bool const applied = false;
Chris@16:         };
Chris@16: 
Chris@16:         // work around GCC bug
Chris@16:         template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data>
Chris@16:         struct make_if_<proto::basic_expr<Tag, Args, N>, Expr, State, Data, false>
Chris@16:         {
Chris@16:             typedef proto::basic_expr<Tag, Args, N> type;
Chris@16:             static bool const applied = false;
Chris@16:         };
Chris@16:         #endif
Chris@16: 
Chris@16:         template<typename Type, bool IsAggregate = detail::is_aggregate_<Type>::value>
Chris@16:         struct construct_
Chris@16:         {
Chris@16:             typedef Type result_type;
Chris@16: 
Chris@16:             BOOST_FORCEINLINE
Chris@16:             Type operator ()() const
Chris@16:             {
Chris@16:                 return Type();
Chris@16:             }
Chris@16: 
Chris@16:             // Other overloads generated by the preprocessor
Chris@16:             #include <boost/proto/transform/detail/construct_funop.hpp>
Chris@16:         };
Chris@16: 
Chris@16:         template<typename Type>
Chris@16:         struct construct_<Type, true>
Chris@16:         {
Chris@16:             typedef Type result_type;
Chris@16: 
Chris@16:             BOOST_FORCEINLINE
Chris@16:             Type operator ()() const
Chris@16:             {
Chris@16:                 return Type();
Chris@16:             }
Chris@16: 
Chris@16:             // Other overloads generated by the preprocessor
Chris@16:             #include <boost/proto/transform/detail/construct_pod_funop.hpp>
Chris@16:         };
Chris@16: 
Chris@16:     }
Chris@16: 
Chris@16:     /// \brief A PrimitiveTransform which prevents another PrimitiveTransform
Chris@16:     /// from being applied in an \c ObjectTransform.
Chris@16:     ///
Chris@16:     /// When building higher order transforms with <tt>make\<\></tt> or
Chris@16:     /// <tt>lazy\<\></tt>, you sometimes would like to build types that
Chris@16:     /// are parameterized with Proto transforms. In such lambda-style
Chris@16:     /// transforms, Proto will unhelpfully find all nested transforms
Chris@16:     /// and apply them, even if you don't want them to be applied. Consider
Chris@16:     /// the following transform, which will replace the \c _ in
Chris@16:     /// <tt>Bar<_>()</tt> with <tt>proto::terminal\<int\>::type</tt>:
Chris@16:     ///
Chris@16:     /// \code
Chris@16:     /// template<typename T>
Chris@16:     /// struct Bar
Chris@16:     /// {};
Chris@16:     /// 
Chris@16:     /// struct Foo
Chris@16:     ///   : proto::when<_, Bar<_>() >
Chris@16:     /// {};
Chris@16:     /// 
Chris@16:     /// proto::terminal<int>::type i = {0};
Chris@16:     /// 
Chris@16:     /// int main()
Chris@16:     /// {
Chris@16:     ///     Foo()(i);
Chris@16:     ///     std::cout << typeid(Foo()(i)).name() << std::endl;
Chris@16:     /// }
Chris@16:     /// \endcode
Chris@16:     ///
Chris@16:     /// If you actually wanted to default-construct an object of type
Chris@16:     /// <tt>Bar\<_\></tt>, you would have to protect the \c _ to prevent
Chris@16:     /// it from being applied. You can use <tt>proto::protect\<\></tt>
Chris@16:     /// as follows:
Chris@16:     ///
Chris@16:     /// \code
Chris@16:     /// // OK: replace anything with Bar<_>()
Chris@16:     /// struct Foo
Chris@16:     ///   : proto::when<_, Bar<protect<_> >() >
Chris@16:     /// {};
Chris@16:     /// \endcode
Chris@16:     template<typename PrimitiveTransform>
Chris@16:     struct protect : transform<protect<PrimitiveTransform> >
Chris@16:     {
Chris@16:         template<typename, typename, typename>
Chris@16:         struct impl
Chris@16:         {
Chris@16:             typedef PrimitiveTransform result_type;
Chris@16:         };
Chris@16:     };
Chris@16: 
Chris@16:     /// \brief A PrimitiveTransform which computes a type by evaluating any
Chris@16:     /// nested transforms and then constructs an object of that type.
Chris@16:     ///
Chris@16:     /// The <tt>make\<\></tt> transform checks to see if \c Object is a template.
Chris@16:     /// If it is, the template type is disassembled to find nested transforms.
Chris@16:     /// Proto considers the following types to represent transforms:
Chris@16:     ///
Chris@16:     /// \li Function types
Chris@16:     /// \li Function pointer types
Chris@16:     /// \li Types for which <tt>proto::is_callable\< type \>::value</tt> is \c true
Chris@16:     ///
Chris@16:     /// <tt>boost::result_of\<make\<T\<X0,X1,...\> \>(Expr, State, Data)\>::type</tt>
Chris@16:     /// is evaluated as follows. For each \c X in <tt>X0,X1,...</tt>, do:
Chris@16:     ///
Chris@16:     /// \li If \c X is a template like <tt>U\<Y0,Y1,...\></tt>, then let <tt>X'</tt>
Chris@16:     ///     be <tt>boost::result_of\<make\<U\<Y0,Y1,...\> \>(Expr, State, Data)\>::type</tt>
Chris@16:     ///     (which evaluates this procedure recursively). Note whether any
Chris@16:     ///     substitutions took place during this operation.
Chris@16:     /// \li Otherwise, if \c X is a transform, then let <tt>X'</tt> be
Chris@16:     ///     <tt>boost::result_of\<when\<_, X\>(Expr, State, Data)\>::type</tt>.
Chris@16:     ///     Note that a substitution took place.
Chris@16:     /// \li Otherwise, let <tt>X'</tt> be \c X, and note that no substitution
Chris@16:     ///     took place.
Chris@16:     /// \li If any substitutions took place in any of the above steps and
Chris@16:     ///     <tt>T\<X0',X1',...\></tt> has a nested <tt>::type</tt> typedef,
Chris@16:     ///     the result type is <tt>T\<X0',X1',...\>::type</tt>.
Chris@16:     /// \li Otherwise, the result type is <tt>T\<X0',X1',...\></tt>.
Chris@16:     ///
Chris@16:     /// Note that <tt>when\<\></tt> is implemented in terms of <tt>call\<\></tt>
Chris@16:     /// and <tt>make\<\></tt>, so the above procedure is evaluated recursively.
Chris@16:     template<typename Object>
Chris@16:     struct make : transform<make<Object> >
Chris@16:     {
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl : transform_impl<Expr, State, Data>
Chris@16:         {
Chris@16:             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
Chris@16: 
Chris@16:             /// \return <tt>result_type()</tt>
Chris@16:             BOOST_FORCEINLINE
Chris@16:             result_type operator ()(
Chris@16:                 typename impl::expr_param
Chris@16:               , typename impl::state_param
Chris@16:               , typename impl::data_param
Chris@16:             ) const
Chris@16:             {
Chris@16:                 return result_type();
Chris@16:             }
Chris@16:         };
Chris@16:     };
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     template<typename Fun>
Chris@16:     struct make<detail::msvc_fun_workaround<Fun> >
Chris@16:       : make<Fun>
Chris@16:     {};
Chris@16: 
Chris@16:     // Other specializations generated by the preprocessor.
Chris@16:     #include <boost/proto/transform/detail/make.hpp>
Chris@16:     #include <boost/proto/transform/detail/make_gcc_workaround.hpp>
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Object>
Chris@16:     struct is_callable<make<Object> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename PrimitiveTransform>
Chris@16:     struct is_callable<protect<PrimitiveTransform> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16: }}
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: # pragma warning(pop)
Chris@16: #endif
Chris@16: 
Chris@16: #endif