diff DEPENDENCIES/generic/include/boost/proto/fusion.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/proto/fusion.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,720 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file fusion.hpp
+/// Make any Proto expression a valid Fusion sequence
+//
+//  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_FUSION_HPP_EAN_11_04_2006
+#define BOOST_PROTO_FUSION_HPP_EAN_11_04_2006
+
+#include <boost/config.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/sequence_tag_fwd.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/include/is_view.hpp>
+#include <boost/fusion/include/tag_of_fwd.hpp>
+#include <boost/fusion/include/category_of.hpp>
+#include <boost/fusion/include/iterator_base.hpp>
+#include <boost/fusion/include/intrinsic.hpp>
+#include <boost/fusion/include/single_view.hpp>
+#include <boost/fusion/include/transform.hpp>
+#include <boost/fusion/include/as_list.hpp>
+#include <boost/fusion/include/is_segmented.hpp>
+#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/eval.hpp>
+#include <boost/proto/make_expr.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4510) // default constructor could not be generated
+#pragma warning(disable : 4512) // assignment operator could not be generated
+#pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
+#endif
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Expr, long Pos>
+        struct expr_iterator
+          : fusion::iterator_base<expr_iterator<Expr, Pos> >
+        {
+            typedef Expr expr_type;
+            static const long index = Pos;
+            typedef fusion::random_access_traversal_tag category;
+            typedef
+                tag::proto_expr_iterator<
+                    typename Expr::proto_tag
+                  , typename Expr::proto_domain
+                >
+            fusion_tag;
+
+            explicit expr_iterator(Expr &e)
+              : expr(e)
+            {}
+
+            Expr &expr;
+        };
+
+        template<typename Tag>
+        struct as_element
+        {
+            template<typename Sig>
+            struct result;
+
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+              : result<This(Expr const &)>
+            {};
+
+            template<typename This, typename Expr>
+            struct result<This(Expr &)>
+              : mpl::if_c<
+                    is_same<Tag, typename Expr::proto_tag>::value
+                  , flat_view<Expr>
+                  , fusion::single_view<Expr &>
+                >
+            {};
+
+            template<typename Expr>
+            typename result<as_element(Expr &)>::type const
+            operator ()(Expr &e) const
+            {
+                return typename result<as_element(Expr &)>::type(e);
+            }
+
+            template<typename Expr>
+            typename result<as_element(Expr const &)>::type const
+            operator ()(Expr const &e) const
+            {
+                return typename result<as_element(Expr const &)>::type(e);
+            }
+        };
+
+        template<typename Expr>
+        struct flat_view
+          : fusion::sequence_base<flat_view<Expr> >
+        {
+            typedef fusion::forward_traversal_tag category;
+            typedef
+                tag::proto_flat_view<
+                    typename Expr::proto_tag
+                  , typename Expr::proto_domain
+                >
+            fusion_tag;
+            typedef
+                typename fusion::result_of::as_list<
+                    typename fusion::result_of::transform<
+                        Expr
+                      , as_element<typename Expr::proto_tag>
+                    >::type
+                >::type
+            segments_type;
+
+            explicit flat_view(Expr &e)
+              : segs_(fusion::as_list(fusion::transform(e, as_element<typename Expr::proto_tag>())))
+            {}
+
+            segments_type segs_;
+        };
+    }
+
+    namespace result_of
+    {
+        template<typename Expr>
+        struct flatten
+          : flatten<Expr const &>
+        {};
+
+        template<typename Expr>
+        struct flatten<Expr &>
+        {
+            typedef detail::flat_view<Expr> type;
+        };
+    }
+
+    namespace functional
+    {
+        /// \brief A PolymorphicFunctionObject type that returns a "flattened"
+        /// view of a Proto expression tree.
+        ///
+        /// A PolymorphicFunctionObject type that returns a "flattened"
+        /// view of a Proto expression tree. For a tree with a top-most node
+        /// tag of type \c T, the elements of the flattened sequence are
+        /// determined by recursing into each child node with the same
+        /// tag type and returning those nodes of different type. So for
+        /// instance, the Proto expression tree corresponding to the
+        /// expression <tt>a | b | c</tt> has a flattened view with elements
+        /// [a, b, c], even though the tree is grouped as
+        /// <tt>((a | b) | c)</tt>.
+        struct flatten
+        {
+            BOOST_PROTO_CALLABLE()
+
+            template<typename Sig>
+            struct result;
+
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+              : result<This(Expr const &)>
+            {};
+
+            template<typename This, typename Expr>
+            struct result<This(Expr &)>
+            {
+                typedef proto::detail::flat_view<Expr> type;
+            };
+
+            template<typename Expr>
+            proto::detail::flat_view<Expr> const
+            operator ()(Expr &e) const
+            {
+                return proto::detail::flat_view<Expr>(e);
+            }
+
+            template<typename Expr>
+            proto::detail::flat_view<Expr const> const
+            operator ()(Expr const &e) const
+            {
+                return proto::detail::flat_view<Expr const>(e);
+            }
+        };
+    }
+
+    /// \brief A function that returns a "flattened"
+    /// view of a Proto expression tree.
+    ///
+    /// For a tree with a top-most node
+    /// tag of type \c T, the elements of the flattened sequence are
+    /// determined by recursing into each child node with the same
+    /// tag type and returning those nodes of different type. So for
+    /// instance, the Proto expression tree corresponding to the
+    /// expression <tt>a | b | c</tt> has a flattened view with elements
+    /// [a, b, c], even though the tree is grouped as
+    /// <tt>((a | b) | c)</tt>.
+    template<typename Expr>
+    proto::detail::flat_view<Expr> const
+    flatten(Expr &e)
+    {
+        return proto::detail::flat_view<Expr>(e);
+    }
+
+    /// \overload
+    ///
+    template<typename Expr>
+    proto::detail::flat_view<Expr const> const
+    flatten(Expr const &e)
+    {
+        return proto::detail::flat_view<Expr const>(e);
+    }
+
+    /// INTERNAL ONLY
+    ///
+    template<typename Context>
+    struct eval_fun
+      : proto::callable
+    {
+        explicit eval_fun(Context &ctx)
+          : ctx_(ctx)
+        {}
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+          : result<This(Expr const &)>
+        {};
+
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+          : proto::result_of::eval<Expr, Context>
+        {};
+
+        template<typename Expr>
+        typename proto::result_of::eval<Expr, Context>::type
+        operator ()(Expr &e) const
+        {
+            return proto::eval(e, this->ctx_);
+        }
+
+        template<typename Expr>
+        typename proto::result_of::eval<Expr const, Context>::type
+        operator ()(Expr const &e) const
+        {
+            return proto::eval(e, this->ctx_);
+        }
+
+    private:
+        Context &ctx_;
+    };
+
+    /// INTERNAL ONLY
+    ///
+    template<typename Context>
+    struct is_callable<eval_fun<Context> >
+      : mpl::true_
+    {};
+}}
+
+namespace boost { namespace fusion
+{
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_sequence_impl;
+
+        template<typename Tag, typename Domain>
+        struct is_sequence_impl<proto::tag::proto_flat_view<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::true_
+            {};
+        };
+
+        template<typename Tag, typename Domain>
+        struct is_sequence_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::true_
+            {};
+        };
+
+        template<typename Tag>
+        struct is_view_impl;
+
+        template<typename Tag, typename Domain>
+        struct is_view_impl<proto::tag::proto_flat_view<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::true_
+            {};
+        };
+
+        template<typename Tag, typename Domain>
+        struct is_view_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::false_
+            {};
+        };
+
+        template<typename Tag>
+        struct value_of_impl;
+
+        template<typename Tag, typename Domain>
+        struct value_of_impl<proto::tag::proto_expr_iterator<Tag, Domain> >
+        {
+            template<
+                typename Iterator
+              , long Arity = proto::arity_of<typename Iterator::expr_type>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        typename Iterator::expr_type
+                      , Iterator::index
+                    >::value_type
+                type;
+            };
+
+            template<typename Iterator>
+            struct apply<Iterator, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        typename Iterator::expr_type
+                    >::value_type
+                type;
+            };
+        };
+
+        template<typename Tag>
+        struct deref_impl;
+
+        template<typename Tag, typename Domain>
+        struct deref_impl<proto::tag::proto_expr_iterator<Tag, Domain> >
+        {
+            template<
+                typename Iterator
+              , long Arity = proto::arity_of<typename Iterator::expr_type>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        typename Iterator::expr_type &
+                      , Iterator::index
+                    >::type
+                type;
+
+                static type call(Iterator const &iter)
+                {
+                    return proto::child_c<Iterator::index>(iter.expr);
+                }
+            };
+
+            template<typename Iterator>
+            struct apply<Iterator, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        typename Iterator::expr_type &
+                    >::type
+                type;
+
+                static type call(Iterator const &iter)
+                {
+                    return proto::value(iter.expr);
+                }
+            };
+        };
+
+        template<typename Tag>
+        struct advance_impl;
+
+        template<typename Tag, typename Domain>
+        struct advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >
+        {
+            template<typename Iterator, typename N>
+            struct apply
+            {
+                typedef
+                    proto::detail::expr_iterator<
+                        typename Iterator::expr_type
+                      , Iterator::index + N::value
+                    >
+                type;
+
+                static type call(Iterator const &iter)
+                {
+                    return type(iter.expr);
+                }
+            };
+        };
+
+        template<typename Tag>
+        struct distance_impl;
+
+        template<typename Tag, typename Domain>
+        struct distance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >
+        {
+            template<typename IteratorFrom, typename IteratorTo>
+            struct apply
+              : mpl::long_<IteratorTo::index - IteratorFrom::index>
+            {};
+        };
+
+        template<typename Tag>
+        struct next_impl;
+
+        template<typename Tag, typename Domain>
+        struct next_impl<proto::tag::proto_expr_iterator<Tag, Domain> >
+        {
+            template<typename Iterator>
+            struct apply
+              : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<1> >
+            {};
+        };
+
+        template<typename Tag>
+        struct prior_impl;
+
+        template<typename Tag, typename Domain>
+        struct prior_impl<proto::tag::proto_expr_iterator<Tag, Domain> >
+        {
+            template<typename Iterator>
+            struct apply
+              : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<-1> >
+            {};
+        };
+
+        template<typename Tag>
+        struct category_of_impl;
+
+        template<typename Tag, typename Domain>
+        struct category_of_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef random_access_traversal_tag type;
+            };
+        };
+
+        template<typename Tag>
+        struct size_impl;
+
+        template<typename Tag, typename Domain>
+        struct size_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::long_<0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c>
+            {};
+        };
+
+        template<typename Tag>
+        struct begin_impl;
+
+        template<typename Tag, typename Domain>
+        struct begin_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef proto::detail::expr_iterator<Sequence, 0> type;
+
+                static type call(Sequence &seq)
+                {
+                    return type(seq);
+                }
+            };
+        };
+
+        template<typename Tag>
+        struct end_impl;
+
+        template<typename Tag, typename Domain>
+        struct end_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef
+                    proto::detail::expr_iterator<
+                        Sequence
+                      , 0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c
+                    >
+                type;
+
+                static type call(Sequence &seq)
+                {
+                    return type(seq);
+                }
+            };
+        };
+
+        template<typename Tag>
+        struct value_at_impl;
+
+        template<typename Tag, typename Domain>
+        struct value_at_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<
+                typename Sequence
+              , typename Index
+              , long Arity = proto::arity_of<Sequence>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        Sequence
+                      , Index::value
+                    >::value_type
+                type;
+            };
+
+            template<typename Sequence, typename Index>
+            struct apply<Sequence, Index, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        Sequence
+                    >::value_type
+                type;
+            };
+        };
+
+        template<typename Tag>
+        struct at_impl;
+
+        template<typename Tag, typename Domain>
+        struct at_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<
+                typename Sequence
+              , typename Index
+              , long Arity = proto::arity_of<Sequence>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        Sequence &
+                      , Index::value
+                    >::type
+                type;
+
+                static type call(Sequence &seq)
+                {
+                    return proto::child_c<Index::value>(seq);
+                }
+            };
+
+            template<typename Sequence, typename Index>
+            struct apply<Sequence, Index, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        Sequence &
+                    >::type
+                type;
+
+                static type call(Sequence &seq)
+                {
+                    return proto::value(seq);
+                }
+            };
+        };
+
+        template<typename Tag>
+        struct convert_impl;
+
+        template<typename Tag, typename Domain>
+        struct convert_impl<proto::tag::proto_expr<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::unpack_expr<
+                        Tag
+                      , Domain
+                      , Sequence
+                    >::type
+                type;
+
+                static type call(Sequence& seq)
+                {
+                    return proto::unpack_expr<Tag, Domain>(seq);
+                }
+            };
+        };
+
+        template<typename Tag, typename Domain>
+        struct convert_impl<proto::tag::proto_flat_view<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::unpack_expr<
+                        Tag
+                      , Domain
+                      , Sequence
+                    >::type
+                type;
+
+                static type call(Sequence& seq)
+                {
+                    return proto::unpack_expr<Tag, Domain>(seq);
+                }
+            };
+        };
+
+        template<typename Tag>
+        struct is_segmented_impl;
+
+        template<typename Tag, typename Domain>
+        struct is_segmented_impl<proto::tag::proto_flat_view<Tag, Domain> >
+        {
+            template<typename Iterator>
+            struct apply
+              : mpl::true_
+            {};
+        };
+
+        template<typename Tag>
+        struct segments_impl;
+
+        template<typename Tag, typename Domain>
+        struct segments_impl<proto::tag::proto_flat_view<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::segments_type const &type;
+                            
+                static type call(Sequence &sequence)
+                {
+                    return sequence.segs_;
+                }
+            };
+        };
+
+        template<typename Tag, typename Domain>
+        struct category_of_impl<proto::tag::proto_flat_view<Tag, Domain> >
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef forward_traversal_tag type;
+            };
+        };
+    }
+
+    namespace traits
+    {
+        template<typename Seq1, typename Seq2>
+        struct enable_equality<
+            Seq1
+          , Seq2
+          , typename enable_if_c<
+                mpl::or_<
+                    proto::is_expr<Seq1>
+                  , proto::is_expr<Seq2>
+                >::value
+            >::type
+        >
+            : mpl::false_
+        {};
+
+        template<typename Seq1, typename Seq2>
+        struct enable_comparison<
+            Seq1
+          , Seq2
+          , typename enable_if_c<
+                mpl::or_<
+                    proto::is_expr<Seq1>
+                  , proto::is_expr<Seq2>
+                >::value
+            >::type
+        >
+          : mpl::false_
+        {};
+    }
+}}
+
+namespace boost { namespace mpl
+{
+    template<typename Tag, typename Args, long Arity>
+    struct sequence_tag< proto::expr<Tag, Args, Arity> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template<typename Tag, typename Args, long Arity>
+    struct sequence_tag< proto::basic_expr<Tag, Args, Arity> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+}}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif