Added boost header

test/external/boost/proto/detail/reverse.hpp

@@ -0,0 +1,189 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 Joel de Guzman
+    Copyright (c) 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_DETAIL_FUSION_REVERSE_EAH_01_22_2008
+#define BOOST_PROTO_DETAIL_FUSION_REVERSE_EAH_01_22_2008
+
+#include <boost/spirit/fusion/detail/access.hpp>
+#include <boost/spirit/fusion/iterator/as_fusion_iterator.hpp>
+#include <boost/spirit/fusion/iterator/detail/iterator_base.hpp>
+#include <boost/spirit/fusion/sequence/detail/sequence_base.hpp>
+#include <boost/spirit/fusion/iterator/next.hpp>
+#include <boost/spirit/fusion/iterator/prior.hpp>
+#include <boost/spirit/fusion/iterator/deref.hpp>
+#include <boost/spirit/fusion/iterator/value_of.hpp>
+#include <boost/spirit/fusion/sequence/begin.hpp>
+#include <boost/spirit/fusion/sequence/end.hpp>
+
+namespace boost { namespace fusion
+{
+    struct reverse_view_tag;
+    struct reverse_view_iterator_tag;
+
+    template <typename First>
+    struct reverse_view_iterator
+        : iterator_base<reverse_view_iterator<First> >
+    {
+        typedef as_fusion_iterator<First> converter;
+        typedef typename converter::type first_type;
+        typedef reverse_view_iterator_tag tag;
+
+        reverse_view_iterator(First const& first)
+            : first(converter::convert(first)) {}
+
+        first_type first;
+    };
+
+    template <typename Sequence>
+    struct reverse_view : sequence_base<reverse_view<Sequence> >
+    {
+        typedef as_fusion_sequence<Sequence> seq_converter;
+        typedef typename seq_converter::type seq;
+
+        typedef reverse_view_tag tag;
+        typedef typename meta::begin<seq>::type first_type;
+        typedef typename meta::end<seq>::type last_type;
+
+        reverse_view(Sequence& seq)
+          : first(fusion::begin(seq))
+          , last(fusion::end(seq))
+        {}
+
+        first_type first;
+        last_type last;
+    };
+
+    namespace meta
+    {
+        template <>
+        struct deref_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    meta::deref<
+                        typename meta::prior<
+                            typename Iterator::first_type
+                        >::type
+                    >::type
+                type;
+
+                static type
+                call(Iterator const& i)
+                {
+                    return *fusion::prior(i.first);
+                }
+            };
+        };
+
+        template <>
+        struct prior_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename next_impl<typename first_type::tag>::
+                    template apply<first_type>
+                wrapped;
+
+                typedef reverse_view_iterator<typename wrapped::type> type;
+
+                static type
+                call(Iterator const& i)
+                {
+                    return type(wrapped::call(i.first));
+                }
+            };
+        };
+
+        template <>
+        struct next_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename prior_impl<typename first_type::tag>::
+                    template apply<first_type>
+                wrapped;
+
+                typedef reverse_view_iterator<typename wrapped::type> type;
+
+                static type
+                call(Iterator const& i)
+                {
+                    return type(wrapped::call(i.first));
+                }
+            };
+        };
+
+        template <>
+        struct value_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    meta::value_of<
+                        typename meta::prior<
+                            typename Iterator::first_type
+                        >::type
+                    >::type
+                type;
+            };
+        };
+
+        template <>
+        struct begin_impl<reverse_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef reverse_view_iterator<typename Sequence::last_type> type;
+
+                static type
+                call(Sequence const& s)
+                {
+                    return type(s.last);
+                }
+            };
+        };
+
+        template <>
+        struct end_impl<reverse_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef reverse_view_iterator<typename Sequence::first_type> type;
+
+                static type
+                call(Sequence const& s)
+                {
+                    return type(s.first);
+                }
+            };
+        };
+
+        template <typename Sequence>
+        struct reverse
+        {
+            typedef reverse_view<Sequence> type;
+        };
+    }
+
+    template <typename Sequence>
+    inline reverse_view<Sequence const>
+    reverse(Sequence const& view)
+    {
+        return reverse_view<Sequence const>(view);
+    }
+}}
+
+#endif