Added boost header

test/external/boost/proto/generate.hpp

@@ -0,0 +1,436 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file generate.hpp
+/// Contains definition of generate\<\> class template, which end users can
+/// specialize for generating domain-specific expression wrappers.
+//
+//  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_GENERATE_HPP_EAN_02_13_2007
+#define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
+
+#include <boost/config.hpp>
+#include <boost/version.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/facilities/intercept.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/mpl/bool.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/args.hpp>
+
+namespace boost { namespace proto
+{
+
+    namespace detail
+    {
+        template<typename Expr>
+        struct by_value_generator_;
+
+        template<typename Tag, typename Arg>
+        struct by_value_generator_<proto::expr<Tag, term<Arg>, 0> >
+        {
+            typedef
+                proto::expr<
+                    Tag
+                  , term<typename detail::term_traits<Arg>::value_type>
+                  , 0
+                >
+            type;
+
+            static type const call(proto::expr<Tag, term<Arg>, 0> const &e)
+            {
+                type that = {e.child0};
+                return that;
+            }
+        };
+
+        template<typename Tag, typename Arg>
+        struct by_value_generator_<proto::basic_expr<Tag, term<Arg>, 0> >
+        {
+            typedef
+                proto::basic_expr<
+                    Tag
+                  , term<typename detail::term_traits<Arg>::value_type>
+                  , 0
+                >
+            type;
+
+            static type const call(proto::basic_expr<Tag, term<Arg>, 0> const &e)
+            {
+                type that = {e.child0};
+                return that;
+            }
+        };
+
+        // Include the other specializations of by_value_generator_
+        #include <boost/proto/detail/generate_by_value.hpp>
+    }
+
+    /// \brief Annotate a generator to indicate that it would
+    /// prefer to be passed instances of \c proto::basic_expr\<\> rather
+    /// than \c proto::expr\<\>. <tt>use_basic_expr\<Generator\></tt> is
+    /// itself a generator.
+    ///
+    template<typename Generator>
+    struct use_basic_expr
+      : Generator
+    {
+        BOOST_PROTO_USE_BASIC_EXPR()
+    };
+
+    /// \brief A simple generator that passes an expression
+    /// through unchanged.
+    ///
+    /// Generators are intended for use as the first template parameter
+    /// to the \c domain\<\> class template and control if and how
+    /// expressions within that domain are to be customized.
+    /// The \c default_generator makes no modifications to the expressions
+    /// passed to it.
+    struct default_generator
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef Expr type;
+        };
+
+        /// \param expr A Proto expression
+        /// \return expr
+        template<typename Expr>
+        #ifdef BOOST_PROTO_STRICT_RESULT_OF
+        Expr
+        #else
+        Expr const &
+        #endif
+        operator ()(Expr const &e) const
+        {
+            return e;
+        }
+    };
+
+    /// \brief A simple generator that passes an expression
+    /// through unchanged and specifies a preference for
+    /// \c proto::basic_expr\<\> over \c proto::expr\<\>.
+    ///
+    /// Generators are intended for use as the first template parameter
+    /// to the \c domain\<\> class template and control if and how
+    /// expressions within that domain are to be customized.
+    /// The \c default_generator makes no modifications to the expressions
+    /// passed to it.
+    struct basic_default_generator
+      : proto::use_basic_expr<default_generator>
+    {};
+    
+    /// \brief A generator that wraps expressions passed
+    /// to it in the specified extension wrapper.
+    ///
+    /// Generators are intended for use as the first template parameter
+    /// to the \c domain\<\> class template and control if and how
+    /// expressions within that domain are to be customized.
+    /// \c generator\<\> wraps each expression passed to it in
+    /// the \c Extends\<\> wrapper.
+    template<template<typename> class Extends>
+    struct generator
+    {
+        BOOST_PROTO_CALLABLE()
+        BOOST_PROTO_USE_BASIC_EXPR()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef Extends<Expr> type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef Extends<Expr> type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef Extends<Expr> type;
+        };
+
+        /// \param expr A Proto expression
+        /// \return Extends<Expr>(expr)
+        template<typename Expr>
+        Extends<Expr> operator ()(Expr const &e) const
+        {
+            return Extends<Expr>(e);
+        }
+    };
+
+    /// \brief A generator that wraps expressions passed
+    /// to it in the specified extension wrapper and uses
+    /// aggregate initialization for the wrapper.
+    ///
+    /// Generators are intended for use as the first template parameter
+    /// to the \c domain\<\> class template and control if and how
+    /// expressions within that domain are to be customized.
+    /// \c pod_generator\<\> wraps each expression passed to it in
+    /// the \c Extends\<\> wrapper, and uses aggregate initialzation
+    /// for the wrapped object.
+    template<template<typename> class Extends>
+    struct pod_generator
+    {
+        BOOST_PROTO_CALLABLE()
+        BOOST_PROTO_USE_BASIC_EXPR()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef Extends<Expr> type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef Extends<Expr> type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef Extends<Expr> type;
+        };
+
+        /// \param expr The expression to wrap
+        /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
+        template<typename Expr>
+        Extends<Expr> operator ()(Expr const &e) const
+        {
+            Extends<Expr> that = {e};
+            return that;
+        }
+    };
+
+    /// \brief A generator that replaces child nodes held by
+    /// reference with ones held by value. Use with
+    /// \c compose_generators to forward that result to another
+    /// generator.
+    ///
+    /// Generators are intended for use as the first template parameter
+    /// to the \c domain\<\> class template and control if and how
+    /// expressions within that domain are to be customized.
+    /// \c by_value_generator ensures all child nodes are
+    /// held by value. This generator is typically composed with a
+    /// second generator for further processing, as
+    /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>.
+    struct by_value_generator
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef
+                typename detail::by_value_generator_<Expr>::type
+            type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef
+                typename detail::by_value_generator_<Expr>::type
+            type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef
+                typename detail::by_value_generator_<Expr>::type
+            type;
+        };
+
+        /// \param expr The expression to modify.
+        /// \return <tt>deep_copy(expr)</tt>
+        template<typename Expr>
+        typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
+        {
+            return detail::by_value_generator_<Expr>::call(e);
+        }
+    };
+
+    /// \brief A composite generator that first applies one
+    /// transform to an expression and then forwards the result
+    /// on to another generator for further transformation.
+    ///
+    /// Generators are intended for use as the first template parameter
+    /// to the \c domain\<\> class template and control if and how
+    /// expressions within that domain are to be customized.
+    /// \c compose_generators\<\> is a composite generator that first
+    /// applies one transform to an expression and then forwards the
+    /// result on to another generator for further transformation.
+    template<typename First, typename Second>
+    struct compose_generators
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef
+                typename Second::template result<
+                    Second(typename First::template result<First(Expr)>::type)
+                >::type
+            type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef
+                typename Second::template result<
+                    Second(typename First::template result<First(Expr)>::type)
+                >::type
+            type;
+        };
+
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef
+                typename Second::template result<
+                    Second(typename First::template result<First(Expr)>::type)
+                >::type
+            type;
+        };
+
+        /// \param expr The expression to modify.
+        /// \return Second()(First()(expr))
+        template<typename Expr>
+        typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
+        {
+            return Second()(First()(e));
+        }
+    };
+
+    /// \brief Tests a generator to see whether it would prefer
+    /// to be passed instances of \c proto::basic_expr\<\> rather than
+    /// \c proto::expr\<\>.
+    ///
+    template<typename Generator, typename Void>
+    struct wants_basic_expr
+      : mpl::false_
+    {};
+
+    template<typename Generator>
+    struct wants_basic_expr<Generator, typename Generator::proto_use_basic_expr_>
+      : mpl::true_
+    {};
+
+    /// INTERNAL ONLY
+    template<>
+    struct is_callable<default_generator>
+      : mpl::true_
+    {};
+
+    /// INTERNAL ONLY
+    template<template<typename> class Extends>
+    struct is_callable<generator<Extends> >
+      : mpl::true_
+    {};
+
+    /// INTERNAL ONLY
+    template<template<typename> class Extends>
+    struct is_callable<pod_generator<Extends> >
+      : mpl::true_
+    {};
+
+    /// INTERNAL ONLY
+    template<>
+    struct is_callable<by_value_generator>
+      : mpl::true_
+    {};
+
+    /// INTERNAL ONLY
+    template<typename First, typename Second>
+    struct is_callable<compose_generators<First, Second> >
+      : mpl::true_
+    {};
+
+}}
+
+// Specializations of boost::result_of and boost::tr1_result_of to eliminate
+// some unnecessary template instantiations
+namespace boost
+{
+    template<typename Expr>
+    struct result_of<proto::default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+
+    template<typename Expr>
+    struct result_of<proto::basic_default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+
+    template<typename Expr>
+    struct result_of<proto::default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+
+    template<typename Expr>
+    struct result_of<proto::basic_default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+
+    #if BOOST_VERSION >= 104400
+    template<typename Expr>
+    struct tr1_result_of<proto::default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+
+    template<typename Expr>
+    struct tr1_result_of<proto::basic_default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+
+    template<typename Expr>
+    struct tr1_result_of<proto::default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+
+    template<typename Expr>
+    struct tr1_result_of<proto::basic_default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+    #endif
+}
+
+#endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007