Added boost header

test/external/boost/proto/functional/fusion/at.hpp

@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file at.hpp
+/// Proto callables Fusion at
+//
+//  Copyright 2010 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_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::at() accessor on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::at() accessor on its argument.
+    struct at
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq, typename N>
+        struct result<This(Seq, N)>
+          : fusion::result_of::at<
+                typename boost::remove_reference<Seq>::type
+              , typename boost::remove_const<typename boost::remove_reference<N>::type>::type
+            >
+        {};
+
+        template<typename Seq, typename N>
+        typename fusion::result_of::at<Seq, N>::type
+        operator ()(Seq &seq, N const & BOOST_PROTO_DISABLE_IF_IS_CONST(Seq)) const
+        {
+            return fusion::at<N>(seq);
+        }
+
+        template<typename Seq, typename N>
+        typename fusion::result_of::at<Seq const, N>::type
+        operator ()(Seq const &seq, N const &) const
+        {
+            return fusion::at<N>(seq);
+        }
+    };
+}}}
+
+#endif

test/external/boost/proto/functional/fusion/pop_back.hpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file pop_back.hpp
+/// Proto callables Fusion pop_back
+//
+//  Copyright 2010 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_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010
+
+#include <boost/fusion/include/begin.hpp>
+#include <boost/fusion/include/end.hpp>
+#include <boost/fusion/include/prior.hpp>
+#include <boost/fusion/include/pop_back.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_back() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_back() algorithm on its argument.
+    struct pop_back
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::pop_back<Seq>
+        {};
+
+        template<typename Seq>
+        typename fusion::result_of::pop_back<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            // Work around a const-correctness issue in Fusion
+            typedef typename fusion::result_of::pop_back<Seq>::type result_type;
+            return result_type(fusion::begin(seq), fusion::prior(fusion::end(seq)));
+        }
+
+        template<typename Seq>
+        typename fusion::result_of::pop_back<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::pop_back(seq);
+        }
+    };
+}}}
+
+#endif

test/external/boost/proto/functional/fusion/pop_front.hpp

@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file pop_front.hpp
+/// Proto callables Fusion pop_front
+//
+//  Copyright 2010 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_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010
+
+#include <boost/fusion/include/begin.hpp>
+#include <boost/fusion/include/end.hpp>
+#include <boost/fusion/include/next.hpp>
+#include <boost/fusion/include/pop_front.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_front() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_front() algorithm on its argument. This is
+    /// useful for defining a CallableTransform like \c pop_front(_)
+    /// which removes the first child from a Proto expression node.
+    /// Such a transform might be used as the first argument to the
+    /// \c proto::fold\<\> transform; that is, fold all but
+    /// the first child.
+    struct pop_front
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::pop_front<Seq>
+        {};
+
+        template<typename Seq>
+        typename fusion::result_of::pop_front<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            // Work around a const-correctness issue in Fusion
+            typedef typename fusion::result_of::pop_front<Seq>::type result_type;
+            return result_type(fusion::next(fusion::begin(seq)), fusion::end(seq));
+        }
+
+        template<typename Seq>
+        typename fusion::result_of::pop_front<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::pop_front(seq);
+        }
+    };
+}}}
+
+#endif

test/external/boost/proto/functional/fusion/push_back.hpp

@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file push_back.hpp
+/// Proto callables Fusion push_back
+//
+//  Copyright 2010 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_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/push_back.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_back() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_back() algorithm on its argument.
+    struct push_back
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq, typename T>
+        struct result<This(Seq, T)>
+          : fusion::result_of::push_back<
+                typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
+              , typename boost::remove_const<typename boost::remove_reference<T>::type>::type
+            >
+        {};
+
+        template<typename Seq, typename T>
+        typename fusion::result_of::push_back<Seq const, T>::type
+        operator ()(Seq const &seq, T const &t) const
+        {
+            return fusion::push_back(seq, t);
+        }
+    };
+}}}
+
+#endif

test/external/boost/proto/functional/fusion/push_front.hpp

@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file push_front.hpp
+/// Proto callables Fusion push_front
+//
+//  Copyright 2010 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_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/push_front.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_front() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_front() algorithm on its argument.
+    struct push_front
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq, typename T>
+        struct result<This(Seq, T)>
+          : fusion::result_of::push_front<
+                typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
+              , typename boost::remove_const<typename boost::remove_reference<T>::type>::type
+            >
+        {};
+
+        template<typename Seq, typename T>
+        typename fusion::result_of::push_front<Seq const, T>::type
+        operator ()(Seq const &seq, T const &t) const
+        {
+            return fusion::push_front(seq, t);
+        }
+    };
+}}}
+
+#endif

test/external/boost/proto/functional/fusion/reverse.hpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file reverse.hpp
+/// Proto callables Fusion reverse
+//
+//  Copyright 2010 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_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010
+
+#include <boost/fusion/include/reverse.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::reverse() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::reverse() algorithm on its argument. This is
+    /// useful for defining a CallableTransform like \c reverse(_)
+    /// which reverses the order of the children of a Proto
+    /// expression node.
+    struct reverse
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::reverse<Seq>
+        {};
+
+        template<typename Seq>
+        typename fusion::result_of::reverse<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            // Work around a const-correctness issue in Fusion
+            typedef typename fusion::result_of::reverse<Seq>::type result_type;
+            return result_type(seq);
+        }
+
+        template<typename Seq>
+        typename fusion::result_of::reverse<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::reverse(seq);
+        }
+    };
+}}}
+
+#endif