Added boost header

test/external/boost/fusion/sequence/comparison.hpp

@@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_SEQUENCE_COMPARISON_10022005_0615)
+#define FUSION_SEQUENCE_COMPARISON_10022005_0615
+
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+
+#endif

test/external/boost/fusion/sequence/comparison/detail/equal_to.hpp

@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_EQUAL_TO_05052005_1142)
+#define FUSION_EQUAL_TO_05052005_1142
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Seq1, typename Seq2, bool same_size>
+    struct sequence_equal_to
+    {
+        typedef typename result_of::end<Seq1>::type end1_type;
+        typedef typename result_of::end<Seq2>::type end2_type;
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const&, I2 const&, mpl::true_)
+        {
+            return true;
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b, mpl::false_)
+        {
+            return *a == *b
+                && call(fusion::next(a), fusion::next(b));
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            typename result_of::equal_to<I1, end1_type>::type eq;
+            return call(a, b, eq);
+        }
+    };
+
+    template <typename Seq1, typename Seq2>
+    struct sequence_equal_to<Seq1, Seq2, false>
+    {
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& /*a*/, I2 const& /*b*/)
+        {
+            return false;
+        }
+    };
+}}}
+
+#endif

test/external/boost/fusion/sequence/comparison/detail/greater.hpp

@@ -0,0 +1,49 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_GREATER_05052005_1142)
+#define FUSION_GREATER_05052005_1142
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Seq1, typename Seq2>
+    struct sequence_greater
+    {
+        typedef typename result_of::end<Seq1>::type end1_type;
+        typedef typename result_of::end<Seq2>::type end2_type;
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const&, I2 const&, mpl::true_)
+        {
+            return false;
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b, mpl::false_)
+        {
+            return *a > *b ||
+                (!(*b > *a) && call(fusion::next(a), fusion::next(b)));
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            typename result_of::equal_to<I1, end1_type>::type eq;
+            return call(a, b, eq);
+        }
+    };
+}}}
+
+#endif

test/external/boost/fusion/sequence/comparison/detail/greater_equal.hpp

@@ -0,0 +1,49 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_GREATER_EQUAL_05052005_1142)
+#define FUSION_GREATER_EQUAL_05052005_1142
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Seq1, typename Seq2>
+    struct sequence_greater_equal
+    {
+        typedef typename result_of::end<Seq1>::type end1_type;
+        typedef typename result_of::end<Seq2>::type end2_type;
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const&, I2 const&, mpl::true_)
+        {
+            return true;
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b, mpl::false_)
+        {
+            return *a >= *b
+                && (!(*b >= *a) || call(fusion::next(a), fusion::next(b)));
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            typename result_of::equal_to<I1, end1_type>::type eq;
+            return call(a, b, eq);
+        }
+    };
+}}}
+
+#endif

test/external/boost/fusion/sequence/comparison/detail/less.hpp

@@ -0,0 +1,49 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_LESS_05052005_1141)
+#define FUSION_LESS_05052005_1141
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Seq1, typename Seq2>
+    struct sequence_less
+    {
+        typedef typename result_of::end<Seq1>::type end1_type;
+        typedef typename result_of::end<Seq2>::type end2_type;
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const&, I2 const&, mpl::true_)
+        {
+            return false;
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b, mpl::false_)
+        {
+            return *a < *b ||
+                (!(*b < *a) && call(fusion::next(a), fusion::next(b)));
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            typename result_of::equal_to<I1, end1_type>::type eq;
+            return call(a, b, eq);
+        }
+    };
+}}}
+
+#endif

test/external/boost/fusion/sequence/comparison/detail/less_equal.hpp

@@ -0,0 +1,49 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_LESS_EQUAL_05052005_1141)
+#define FUSION_LESS_EQUAL_05052005_1141
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Seq1, typename Seq2>
+    struct sequence_less_equal
+    {
+        typedef typename result_of::end<Seq1>::type end1_type;
+        typedef typename result_of::end<Seq2>::type end2_type;
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const&, I2 const&, mpl::true_)
+        {
+            return true;
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b, mpl::false_)
+        {
+            return *a <= *b
+                && (!(*b <= *a) || call(fusion::next(a), fusion::next(b)));
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            typename result_of::equal_to<I1, end1_type>::type eq;
+            return call(a, b, eq);
+        }
+    };
+}}}
+
+#endif

test/external/boost/fusion/sequence/comparison/detail/not_equal_to.hpp

@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_NOT_EQUAL_TO_05052005_1141)
+#define FUSION_NOT_EQUAL_TO_05052005_1141
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Seq1, typename Seq2, bool same_size>
+    struct sequence_not_equal_to
+    {
+        typedef typename result_of::end<Seq1>::type end1_type;
+        typedef typename result_of::end<Seq2>::type end2_type;
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const&, I2 const&, mpl::true_)
+        {
+            return false;
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b, mpl::false_)
+        {
+            return *a != *b
+                || call(fusion::next(a), fusion::next(b));
+        }
+
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            typename result_of::equal_to<I1, end1_type>::type eq;
+            return call(a, b, eq);
+        }
+    };
+
+    template <typename Seq1, typename Seq2>
+    struct sequence_not_equal_to<Seq1, Seq2, false>
+    {
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            return true;
+        }
+    };
+}}}
+
+#endif

test/external/boost/fusion/sequence/comparison/enable_comparison.hpp

@@ -0,0 +1,34 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_ENABLE_COMPARISON_09232005_1958)
+#define FUSION_ENABLE_COMPARISON_09232005_1958
+
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+
+namespace boost { namespace fusion { namespace traits
+{
+    template <typename Seq1, typename Seq2, typename Enable = void>
+    struct enable_equality
+        : mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >
+    {};
+
+    template <typename Seq1, typename Seq2, typename Enable = void>
+    struct enable_comparison
+        : mpl::and_<
+            mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >
+          , mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> >
+        >
+    {};
+}}}
+
+#endif

test/external/boost/fusion/sequence/comparison/equal_to.hpp

@@ -0,0 +1,56 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_EQUAL_TO_05052005_0431)
+#define FUSION_EQUAL_TO_05052005_0431
+
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
+#include <boost/config.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4100) // unreferenced formal parameter
+#endif
+
+namespace boost { namespace fusion
+{
+    template <typename Seq1, typename Seq2>
+    inline bool
+    equal_to(Seq1 const& a, Seq2 const& b)
+    {
+        return result_of::size<Seq1>::value == result_of::size<Seq2>::value
+            && detail::sequence_equal_to<
+            Seq1 const, Seq2 const
+            , result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
+            call(fusion::begin(a), fusion::begin(b));
+    }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                traits::enable_equality<Seq1, Seq2>
+              , bool
+            >::type
+        operator==(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::equal_to(a, b);
+        }
+    }
+    using operators::operator==;
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif

test/external/boost/fusion/sequence/comparison/greater.hpp

@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_GREATER_05052005_0432)
+#define FUSION_GREATER_05052005_0432
+
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
+
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+#include <boost/fusion/sequence/comparison/detail/greater.hpp>
+#else
+#include <boost/fusion/sequence/comparison/less.hpp>
+#endif
+
+namespace boost { namespace fusion
+{
+    template <typename Seq1, typename Seq2>
+    inline bool
+    greater(Seq1 const& a, Seq2 const& b)
+    {
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+        return detail::sequence_greater<Seq1 const, Seq2 const>::
+            call(fusion::begin(a), fusion::begin(b));
+#else
+        return (b < a);
+#endif
+    }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                traits::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator>(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::greater(a, b);
+        }
+    }
+    using operators::operator>;
+}}
+
+#endif

test/external/boost/fusion/sequence/comparison/greater_equal.hpp

@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_GREATER_EQUAL_05052005_0432)
+#define FUSION_GREATER_EQUAL_05052005_0432
+
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
+
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+#include <boost/fusion/sequence/comparison/detail/greater_equal.hpp>
+#else
+#include <boost/fusion/sequence/comparison/less.hpp>
+#endif
+
+namespace boost { namespace fusion
+{
+    template <typename Seq1, typename Seq2>
+    inline bool
+    greater_equal(Seq1 const& a, Seq2 const& b)
+    {
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+        return detail::sequence_greater_equal<Seq1 const, Seq2 const>::
+            call(fusion::begin(a), fusion::begin(b));
+#else
+        return !(a < b);
+#endif
+    }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                traits::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator>=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::greater_equal(a, b);
+        }
+    }
+    using operators::operator>=;
+}}
+
+#endif

test/external/boost/fusion/sequence/comparison/less.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_LESS_05052005_0432)
+#define FUSION_LESS_05052005_0432
+
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/less.hpp>
+#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
+
+namespace boost { namespace fusion
+{
+    template <typename Seq1, typename Seq2>
+    inline bool
+    less(Seq1 const& a, Seq2 const& b)
+    {
+        return detail::sequence_less<Seq1 const, Seq2 const>::
+            call(fusion::begin(a), fusion::begin(b));
+    }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                traits::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator<(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::less(a, b);
+        }
+    }
+    using operators::operator<;
+}}
+
+#endif

test/external/boost/fusion/sequence/comparison/less_equal.hpp

@@ -0,0 +1,81 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_LESS_EQUAL_05052005_0432)
+#define FUSION_LESS_EQUAL_05052005_0432
+
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+#include <boost/fusion/sequence/comparison/detail/less_equal.hpp>
+#else
+#include <boost/fusion/sequence/comparison/less.hpp>
+#endif
+
+namespace boost { namespace fusion
+{
+    template <typename Seq1, typename Seq2>
+    inline bool
+    less_equal(Seq1 const& a, Seq2 const& b)
+    {
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+        return detail::sequence_less_equal<Seq1 const, Seq2 const>::
+            call(fusion::begin(a), fusion::begin(b));
+#else
+        return !(b < a);
+#endif
+    }
+
+    namespace operators
+    {
+#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1400)
+// Workaround for  VC8.0 and VC7.1
+        template <typename Seq1, typename Seq2>
+        inline bool
+        operator<=(sequence_base<Seq1> const& a, sequence_base<Seq2> const& b)
+        {
+            return less_equal(a.derived(), b.derived());
+        }
+
+        template <typename Seq1, typename Seq2>
+        inline typename disable_if<traits::is_native_fusion_sequence<Seq2>, bool>::type
+        operator<=(sequence_base<Seq1> const& a, Seq2 const& b)
+        {
+            return less_equal(a.derived(), b);
+        }
+
+        template <typename Seq1, typename Seq2>
+        inline typename disable_if<traits::is_native_fusion_sequence<Seq1>, bool>::type
+        operator<=(Seq1 const& a, sequence_base<Seq2> const& b)
+        {
+            return less_equal(a, b.derived());
+        }
+
+#else
+// Somehow VC8.0 and VC7.1 does not like this code
+// but barfs somewhere else.
+
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                traits::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator<=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::less_equal(a, b);
+        }
+#endif
+    }
+    using operators::operator<=;
+}}
+
+#endif

test/external/boost/fusion/sequence/comparison/not_equal_to.hpp

@@ -0,0 +1,55 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_NOT_EQUAL_TO_05052005_0431)
+#define FUSION_NOT_EQUAL_TO_05052005_0431
+
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
+
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+#include <boost/fusion/sequence/comparison/detail/not_equal_to.hpp>
+#else
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#endif
+
+namespace boost { namespace fusion
+{
+    template <typename Seq1, typename Seq2>
+    inline bool
+    not_equal_to(Seq1 const& a, Seq2 const& b)
+    {
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+        return result_of::size<Seq1>::value != result_of::size<Seq2>::value
+            || detail::sequence_not_equal_to<
+            Seq1 const, Seq2 const
+            , result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
+            call(fusion::begin(a), fusion::begin(b));
+#else
+        return !(a == b);
+#endif
+    }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                traits::enable_equality<Seq1, Seq2>
+              , bool
+            >::type
+        operator!=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::not_equal_to(a, b);
+        }
+    }
+    using operators::operator!=;
+}}
+
+#endif

test/external/boost/fusion/sequence/convert.hpp

@@ -0,0 +1,48 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_CONVERT_10022005_1442)
+#define FUSION_CONVERT_10022005_1442
+
+namespace boost { namespace fusion
+{
+    namespace extension
+    {
+        template <typename Tag>
+        struct convert_impl;
+    }
+
+    namespace result_of
+    {
+        template <typename Tag, typename Sequence>
+        struct convert
+        {
+            typedef typename extension::convert_impl<Tag> gen;
+
+            typedef typename
+                gen::template apply<Sequence>::type
+            type;
+        };
+    }
+
+    template <typename Tag, typename Sequence>
+    inline typename result_of::convert<Tag, Sequence>::type
+    convert(Sequence& seq)
+    {
+        typedef typename result_of::convert<Tag, Sequence>::gen gen;
+        return gen::call(seq);
+    }
+
+    template <typename Tag, typename Sequence>
+    inline typename result_of::convert<Tag, Sequence const>::type
+    convert(Sequence const& seq)
+    {
+        typedef typename result_of::convert<Tag, Sequence const>::gen gen;
+        return gen::call(seq);
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic.hpp

@@ -0,0 +1,23 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_SEQUENCE_INTRINSIC_10022005_0618)
+#define FUSION_SEQUENCE_INTRINSIC_10022005_0618
+
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/segments.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
+
+#endif

test/external/boost/fusion/sequence/intrinsic/at.hpp

@@ -0,0 +1,111 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_AT_05042005_0722)
+#define FUSION_AT_05042005_0722
+
+#include <boost/mpl/int.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+    struct std_tuple_tag; // std::tuple tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl
+        {
+            template <typename Sequence, typename N>
+            struct apply;
+        };
+
+        template <>
+        struct at_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply : Sequence::template at<Sequence, N> {};
+        };
+
+        template <>
+        struct at_impl<boost_tuple_tag>;
+
+        template <>
+        struct at_impl<boost_array_tag>;
+
+        template <>
+        struct at_impl<mpl_sequence_tag>;
+
+        template <>
+        struct at_impl<std_pair_tag>;
+
+        template <>
+        struct at_impl<std_tuple_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct at
+            : extension::at_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, N>
+        {};
+
+        template <typename Sequence, int N>
+        struct at_c
+            : at<Sequence, mpl::int_<N> >
+        {};
+    }
+
+
+    template <typename N, typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at<Sequence, N>
+        >::type
+    at(Sequence& seq)
+    {
+        return result_of::at<Sequence, N>::call(seq);
+    }
+
+    template <typename N, typename Sequence>
+    inline typename result_of::at<Sequence const, N>::type
+    at(Sequence const& seq)
+    {
+        return result_of::at<Sequence const, N>::call(seq);
+    }
+
+    template <int N, typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_c<Sequence, N>
+        >::type
+    at_c(Sequence& seq)
+    {
+        return fusion::at<mpl::int_<N> >(seq);
+    }
+
+    template <int N, typename Sequence>
+    inline typename result_of::at_c<Sequence const, N>::type
+    at_c(Sequence const& seq)
+    {
+        return fusion::at<mpl::int_<N> >(seq);
+    }
+}}
+
+#endif
+

test/external/boost/fusion/sequence/intrinsic/at_c.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_AT_C_08252008_0308)
+#define FUSION_AT_C_08252008_0308
+
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+
+#endif
+

test/external/boost/fusion/sequence/intrinsic/at_key.hpp

@@ -0,0 +1,93 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_AT_KEY_20060304_1755)
+#define BOOST_FUSION_AT_KEY_20060304_1755
+
+#include <boost/type_traits/is_const.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/algorithm/query/find.hpp>
+#include <boost/fusion/iterator/deref_data.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_key_impl
+        {
+            template <typename Seq, typename Key>
+            struct apply
+            {
+                typedef typename
+                    result_of::deref_data<
+                        typename result_of::find<Seq, Key>::type
+                    >::type
+                type;
+
+                static type
+                call(Seq& seq)
+                {
+                    return fusion::deref_data(fusion::find<Key>(seq));
+                }
+            };
+        };
+
+        template <>
+        struct at_key_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : Sequence::template at_key_impl<Sequence, Key> {};
+        };
+
+        template <>
+        struct at_key_impl<boost_array_tag>;
+
+        template <>
+        struct at_key_impl<mpl_sequence_tag>;
+
+        template <>
+        struct at_key_impl<std_pair_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence, typename Key>
+        struct at_key
+            : extension::at_key_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, Key>
+        {};
+    }
+
+    template <typename Key, typename Sequence>
+    inline typename 
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_key<Sequence, Key>
+        >::type
+    at_key(Sequence& seq)
+    {
+        return result_of::at_key<Sequence, Key>::call(seq);
+    }
+
+    template <typename Key, typename Sequence>
+    inline typename result_of::at_key<Sequence const, Key>::type
+    at_key(Sequence const& seq)
+    {
+        return result_of::at_key<Sequence const, Key>::call(seq);
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/back.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_BACK_09162005_0350)
+#define FUSION_BACK_09162005_0350
+
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion
+{
+    struct fusion_sequence_tag;
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct back
+            : result_of::deref<typename result_of::prior<typename result_of::end<Sequence>::type>::type>
+        {};
+    }
+    
+    template <typename Sequence>
+    inline typename result_of::back<Sequence>::type
+    back(Sequence& seq)
+    {
+        return *fusion::prior(fusion::end(seq));
+    }
+
+    template <typename Sequence>
+    inline typename result_of::back<Sequence const>::type
+    back(Sequence const& seq)
+    {
+        return *fusion::prior(fusion::end(seq));
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/begin.hpp

@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_BEGIN_04052005_1132)
+#define FUSION_BEGIN_04052005_1132
+
+#include <boost/blank.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag; // iterator facade tag
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl
+        {
+            template <typename Sequence>
+            struct apply
+              : mpl::if_<
+                    traits::is_segmented<Sequence>
+                  , detail::segmented_begin<Sequence>
+                  , blank
+                >::type
+            {};
+        };
+
+        template <>
+        struct begin_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template begin<Sequence> {};
+        };
+
+        template <>
+        struct begin_impl<boost_tuple_tag>;
+
+        template <>
+        struct begin_impl<boost_array_tag>;
+
+        template <>
+        struct begin_impl<mpl_sequence_tag>;
+
+        template <>
+        struct begin_impl<std_pair_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct begin
+            : extension::begin_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence>
+        {};
+    }
+
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence>
+        >::type const
+    begin(Sequence& seq)
+    {
+        return result_of::begin<Sequence>::call(seq);
+    }
+
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence const>
+        >::type const
+    begin(Sequence const& seq)
+    {
+        return result_of::begin<Sequence const>::call(seq);
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2011 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_BEGIN_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_BEGIN_HPP_INCLUDED
+
+#include <boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp>
+#include <boost/fusion/iterator/segmented_iterator.hpp>
+#include <boost/fusion/view/iterator_range.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/container/list/cons.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    //auto segmented_begin( seq )
+    //{
+    //    return make_segmented_iterator( segmented_begin_impl( seq, nil ) );
+    //}
+
+    template <typename Sequence, typename Nil = fusion::nil>
+    struct segmented_begin
+    {
+        typedef
+            segmented_iterator<
+                typename segmented_begin_impl<Sequence, Nil>::type
+            >
+        type;
+
+        static type call(Sequence& seq)
+        {
+            return type(
+                segmented_begin_impl<Sequence, Nil>::call(seq, Nil()));
+        }
+    };
+
+}}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp

@@ -0,0 +1,92 @@
+/*=============================================================================
+    Copyright (c) 2011 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_BEGIN_IMPL_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_BEGIN_IMPL_HPP_INCLUDED
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/fusion/container/list/cons_fwd.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp>
+#include <boost/fusion/support/detail/segmented_fold_until_impl.hpp>
+
+namespace boost { namespace fusion
+{
+    template <typename First, typename Last>
+    struct iterator_range;
+}}
+
+namespace boost { namespace fusion { namespace detail
+{
+    struct segmented_begin_fun
+    {
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef
+                iterator_range<
+                    typename fusion::result_of::begin<Sequence>::type
+                  , typename fusion::result_of::end<Sequence>::type
+                >
+            range_type;
+
+            typedef cons<range_type, Context> type;
+            typedef mpl::false_ continue_type;
+
+            static type call(Sequence& seq, State const&, Context const& context, segmented_begin_fun)
+            {
+                return type(range_type(fusion::begin(seq), fusion::end(seq)), context);
+            }
+        };
+    };
+
+    template <typename Sequence, typename Stack, bool IsSegmented = traits::is_segmented<Sequence>::type::value>
+    struct segmented_begin_impl_aux
+    {
+        typedef
+            segmented_end_impl<Sequence, Stack>
+        end_impl;
+
+        typedef
+            segmented_fold_until_impl<
+                Sequence
+              , typename end_impl::type
+              , Stack
+              , segmented_begin_fun
+            >
+        fold_impl;
+
+        typedef typename fold_impl::type type;
+
+        static type call(Sequence& seq, Stack const& stack)
+        {
+            return fold_impl::call(seq, end_impl::call(seq, stack), stack, segmented_begin_fun());
+        }
+    };
+
+    template <typename Sequence, typename Stack>
+    struct segmented_begin_impl_aux<Sequence, Stack, false>
+    {
+        typedef typename result_of::begin<Sequence>::type  begin_type;
+        typedef typename result_of::end<Sequence>::type    end_type;
+        typedef iterator_range<begin_type, end_type>    pair_type;
+        typedef cons<pair_type, Stack>                  type;
+
+        static type call(Sequence& seq, Stack stack)
+        {
+            return type(pair_type(fusion::begin(seq), fusion::end(seq)), stack);
+        }
+    };
+
+    template <typename Sequence, typename Stack>
+    struct segmented_begin_impl
+      : segmented_begin_impl_aux<Sequence, Stack>
+    {};
+
+}}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp

@@ -0,0 +1,39 @@
+/*=============================================================================
+    Copyright (c) 2011 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_END_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_END_HPP_INCLUDED
+
+#include <boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp>
+#include <boost/fusion/iterator/segmented_iterator.hpp>
+#include <boost/fusion/container/list/cons.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    //auto segmented_end( seq )
+    //{
+    //    return make_segmented_iterator( segmented_end_impl( seq ) );
+    //}
+
+    template <typename Sequence, typename Nil = fusion::nil>
+    struct segmented_end
+    {
+        typedef
+            segmented_iterator<
+                typename segmented_end_impl<Sequence, Nil>::type
+            >
+        type;
+
+        static type call(Sequence & seq)
+        {
+            return type(
+                segmented_end_impl<Sequence, Nil>::call(seq, Nil()));
+        }
+    };
+
+}}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp

@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2011 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_END_IMPL_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_END_IMPL_HPP_INCLUDED
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/container/list/cons_fwd.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+
+namespace boost { namespace fusion
+{
+    template <typename First, typename Last>
+    struct iterator_range;
+}}
+
+namespace boost { namespace fusion { namespace detail
+{
+    //auto segmented_end_impl( seq, stack )
+    //{
+    //    assert(is_segmented(seq));
+    //    auto it = end(segments(seq));
+    //    return cons(iterator_range(it, it), stack);
+    //}
+
+    template <typename Sequence, typename Stack>
+    struct segmented_end_impl
+    {
+        BOOST_MPL_ASSERT((traits::is_segmented<Sequence>));
+
+        typedef
+            typename result_of::end<
+                typename remove_reference<
+                    typename add_const<
+                        typename result_of::segments<Sequence>::type
+                    >::type
+                >::type
+            >::type
+        end_type;
+
+        typedef iterator_range<end_type, end_type>  pair_type;
+        typedef cons<pair_type, Stack>              type;
+
+        static type call(Sequence & seq, Stack stack)
+        {
+            end_type end = fusion::end(fusion::segments(seq));
+            return type(pair_type(end, end), stack);
+        }
+    };
+
+}}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp

@@ -0,0 +1,54 @@
+/*=============================================================================
+    Copyright (c) 2011 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_SIZE_08112006_1141)
+#define BOOST_FUSION_SEGMENTED_SIZE_08112006_1141
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/mpl/begin.hpp>
+#include <boost/fusion/mpl/end.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // calculates the size of any segmented data structure.
+    template<typename Sequence>
+    struct segmented_size;
+
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value>
+    struct segmented_size_impl
+      : mpl::fold<
+            typename remove_reference<
+                typename add_const<
+                    typename result_of::segments<Sequence>::type
+                >::type
+            >::type
+          , mpl::size_t<0>
+          , mpl::plus<mpl::_1, segmented_size<remove_reference<mpl::_2> > >
+        >::type
+    {};
+
+    template<typename Sequence>
+    struct segmented_size_impl<Sequence, false>
+      : result_of::size<Sequence>::type
+    {};
+
+    template<typename Sequence>
+    struct segmented_size
+      : segmented_size_impl<Sequence>
+    {};
+
+}}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/empty.hpp

@@ -0,0 +1,61 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_EMPTY_09162005_0335)
+#define FUSION_EMPTY_09162005_0335
+
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct mpl_sequence_tag; // mpl sequence tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct empty_impl
+        {
+            template <typename Sequence>
+            struct apply 
+                : mpl::bool_<(result_of::size<Sequence>::value == 0)>
+            {};
+        };
+
+        template <>
+        struct empty_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template empty<Sequence> {};
+        };
+
+        template <>
+        struct empty_impl<mpl_sequence_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct empty 
+            : extension::empty_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence>
+        {};
+    }
+
+    template <typename Sequence>
+    inline typename result_of::empty<Sequence>::type
+    empty(Sequence const&)
+    {
+        typedef typename result_of::empty<Sequence>::type result;
+        return result();
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/end.hpp

@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_END_04052005_1141)
+#define FUSION_END_04052005_1141
+
+#include <boost/blank.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/sequence/intrinsic/detail/segmented_end.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl
+        {
+            template <typename Sequence>
+            struct apply
+              : mpl::if_<
+                    traits::is_segmented<Sequence>
+                  , detail::segmented_end<Sequence>
+                  , blank
+                >::type
+            {};
+        };
+
+        template <>
+        struct end_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template end<Sequence> {};
+        };
+
+        template <>
+        struct end_impl<boost_tuple_tag>;
+
+        template <>
+        struct end_impl<boost_array_tag>;
+
+        template <>
+        struct end_impl<mpl_sequence_tag>;
+
+        template <>
+        struct end_impl<std_pair_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct end
+            : extension::end_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence>
+        {};
+    }
+
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence>
+        >::type const
+    end(Sequence& seq)
+    {
+        return result_of::end<Sequence>::call(seq);
+    }
+
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence const>
+        >::type const
+    end(Sequence const& seq)
+    {
+        return result_of::end<Sequence const>::call(seq);
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/front.hpp

@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_FRONT_09162005_0343)
+#define FUSION_FRONT_09162005_0343
+
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion
+{
+    struct fusion_sequence_tag;
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct front
+            : result_of::deref<typename result_of::begin<Sequence>::type>
+        {};
+    }
+    
+    template <typename Sequence>
+    inline typename result_of::front<Sequence>::type
+    front(Sequence& seq)
+    {
+        return *fusion::begin(seq);
+    }
+
+    template <typename Sequence>
+    inline typename result_of::front<Sequence const>::type
+    front(Sequence const& seq)
+    {
+        return *fusion::begin(seq);
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/has_key.hpp

@@ -0,0 +1,79 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_HAS_KEY_09232005_1454)
+#define FUSION_HAS_KEY_09232005_1454
+
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/algorithm/query/find.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/mpl/not.hpp>
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct has_key_impl
+        {
+            template <typename Seq, typename Key>
+            struct apply
+              : mpl::not_<
+                    typename result_of::equal_to<
+                        typename result_of::find<Seq, Key>::type
+                      , typename result_of::end<Seq>::type
+                    >::type
+                >::type
+            {};
+        };
+
+        template <>
+        struct has_key_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : Sequence::template has_key<Sequence, Key> {};
+        };
+
+        template <>
+        struct has_key_impl<boost_array_tag>;
+
+        template <>
+        struct has_key_impl<mpl_sequence_tag>;
+
+        template <>
+        struct has_key_impl<std_pair_tag>;
+    }
+    
+    namespace result_of
+    {
+        template <typename Sequence, typename Key>
+        struct has_key 
+            : extension::has_key_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, Key>
+        {};
+    }
+
+    template <typename Key, typename Sequence>
+    inline typename result_of::has_key<Sequence, Key>::type
+    has_key(Sequence const& seq)
+    {
+        typedef typename result_of::has_key<Sequence, Key>::type result;
+        return result();
+    }
+}}
+
+#endif
+

test/external/boost/fusion/sequence/intrinsic/segments.hpp

@@ -0,0 +1,76 @@
+/*=============================================================================
+    Copyright (c) 2006 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTS_04052005_1141)
+#define BOOST_FUSION_SEGMENTS_04052005_1141
+
+#include <boost/type_traits/is_const.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct iterator_range_tag;
+
+    // segments: returns a sequence of sequences
+    namespace extension
+    {
+        template <typename Tag>
+        struct segments_impl
+        {
+            template <typename Sequence>
+            struct apply {};
+        };
+
+        template <>
+        struct segments_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template segments<Sequence> {};
+        }; 
+
+        template <>
+        struct segments_impl<iterator_range_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct segments
+        {
+            typedef typename traits::tag_of<Sequence>::type tag_type;
+
+            typedef typename
+                extension::segments_impl<tag_type>::template apply<Sequence>::type
+            type;
+        };
+    }
+
+    template <typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::segments<Sequence>
+        >::type
+    segments(Sequence& seq)
+    {
+        typedef typename traits::tag_of<Sequence>::type tag_type;
+        return extension::segments_impl<tag_type>::template apply<Sequence>::call(seq);
+    }
+
+    template <typename Sequence>
+    inline typename result_of::segments<Sequence const>::type
+    segments(Sequence const& seq)
+    {
+        typedef typename traits::tag_of<Sequence const>::type tag_type;
+        return extension::segments_impl<tag_type>::template apply<Sequence const>::call(seq);
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/size.hpp

@@ -0,0 +1,88 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_SIZE_05052005_0214)
+#define FUSION_SIZE_05052005_0214
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/sequence/intrinsic/detail/segmented_size.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct size_impl
+        {
+            template<typename Sequence>
+            struct unsegmented_size : Sequence::size {};
+
+            template <typename Sequence>
+            struct apply
+              : mpl::if_<
+                    traits::is_segmented<Sequence>
+                  , detail::segmented_size<Sequence>
+                  , unsegmented_size<Sequence>
+                >::type
+            {};
+        };
+
+        template <>
+        struct size_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template size<Sequence> {};
+        };
+ 
+        template <>
+        struct size_impl<boost_tuple_tag>;
+ 
+        template <>
+        struct size_impl<boost_array_tag>;
+
+        template <>
+        struct size_impl<mpl_sequence_tag>;
+
+        template <>
+        struct size_impl<std_pair_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct size
+            : extension::size_impl<typename detail::tag_of<Sequence>::type>::
+        template apply<Sequence>
+
+        {
+            typedef typename extension::size_impl<typename detail::tag_of<Sequence>::type>::
+            template apply<Sequence>::type size_application;
+            BOOST_STATIC_CONSTANT(int, value = size_application::value);
+        };
+    }
+
+    template <typename Sequence>
+    inline typename result_of::size<Sequence>::type
+    size(Sequence const&)
+    {
+        typedef typename result_of::size<Sequence>::type result;
+        return result();
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/swap.hpp

@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SWAP_20070501_1956)
+#define BOOST_FUSION_SWAP_20070501_1956
+
+#include <algorithm>
+
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/view/zip_view.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/mpl/and.hpp>
+
+namespace boost { namespace fusion {
+    namespace result_of
+    {
+        template<typename Seq1, typename Seq2>
+        struct swap
+        {
+            typedef void type;
+        };
+    }
+
+    namespace detail
+    {
+        struct swap
+        {
+            template<typename Elem>
+            struct result
+            {
+                typedef void type;
+            };
+
+            template<typename Elem>
+            void operator()(Elem const& e) const
+            {
+                using std::swap;
+                swap(front(e), back(e));
+            }
+        };
+    }
+
+    template<typename Seq1, typename Seq2>
+    typename enable_if<mpl::and_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >, void>::type 
+    swap(Seq1& lhs, Seq2& rhs)
+    {
+        typedef vector<Seq1&, Seq2&> references;
+        for_each(zip_view<references>(references(lhs, rhs)), detail::swap());
+    }
+}}
+
+#endif

test/external/boost/fusion/sequence/intrinsic/value_at.hpp

@@ -0,0 +1,68 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_VALUE_AT_05052005_0229)
+#define FUSION_VALUE_AT_05052005_0229
+
+#include <boost/mpl/int.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_impl
+        {
+            template <typename Sequence, typename N>
+            struct apply;
+        };
+
+        template <>
+        struct value_at_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply : Sequence::template value_at<Sequence, N> {};
+        };
+
+        template <>
+        struct value_at_impl<boost_tuple_tag>;
+
+        template <>
+        struct value_at_impl<boost_array_tag>;
+
+        template <>
+        struct value_at_impl<mpl_sequence_tag>;
+
+        template <>
+        struct value_at_impl<std_pair_tag>;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct value_at
+            : extension::value_at_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, N>
+        {};
+
+        template <typename Sequence, int N>
+        struct value_at_c
+            : fusion::result_of::value_at<Sequence, mpl::int_<N> >
+        {};
+    }
+}}
+
+#endif
+

test/external/boost/fusion/sequence/intrinsic/value_at_key.hpp

@@ -0,0 +1,66 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_VALUE_AT_KEY_05052005_0229)
+#define FUSION_VALUE_AT_KEY_05052005_0229
+
+#include <boost/mpl/int.hpp>
+#include <boost/fusion/sequence/intrinsic_fwd.hpp>
+#include <boost/fusion/iterator/value_of_data.hpp>
+#include <boost/fusion/algorithm/query/find.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_array_tag; // boost::array tag
+    struct mpl_sequence_tag; // mpl sequence tag
+    struct std_pair_tag; // std::pair tag
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_key_impl
+        {
+            template <typename Seq, typename Key>
+            struct apply
+              : result_of::value_of_data<
+                    typename result_of::find<Seq, Key>::type
+                >
+            {};
+        };
+
+        template <>
+        struct value_at_key_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : Sequence::template value_at_key<Sequence, Key> {};
+        };
+
+        template <>
+        struct value_at_key_impl<boost_array_tag>;
+
+        template <>
+        struct value_at_key_impl<mpl_sequence_tag>;
+
+        template <>
+        struct value_at_key_impl<std_pair_tag>;
+    }
+    
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct value_at_key
+            : extension::value_at_key_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, N>
+        {};
+    }
+}}
+
+#endif
+

test/external/boost/fusion/sequence/intrinsic_fwd.hpp

@@ -0,0 +1,203 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEQUENCE_INTRINSIC_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_SEQUENCE_INTRINSIC_FWD_HPP_INCLUDED
+
+#include <boost/type_traits/is_const.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl;
+
+        template <typename Tag>
+        struct begin_impl;
+
+        template <typename Tag>
+        struct empty_impl;
+
+        template <typename Tag>
+        struct end_impl;
+
+        template <typename Tag>
+        struct has_key_impl;
+
+        template <typename Tag>
+        struct segments_impl;
+
+        template <typename Tag>
+        struct size_impl;
+
+        template <typename Tag>
+        struct value_at_impl;
+
+        template <typename Tag>
+        struct at_key_impl;
+
+        template <typename Tag>
+        struct value_at_key_impl;
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct at;
+
+        template <typename Sequence, int N>
+        struct at_c;
+
+        template <typename Sequence>
+        struct back;
+
+        template <typename Sequence>
+        struct begin;
+
+        template <typename Sequence>
+        struct empty;
+
+        template <typename Sequence>
+        struct end;
+
+        template <typename Sequence>
+        struct front;
+
+        template <typename Sequence, typename Key>
+        struct has_key;
+
+        template <typename Sequence>
+        struct segments;
+
+        template <typename Sequence>
+        struct size;
+
+        template <typename Sequence, typename N>
+        struct value_at;
+
+        template <typename Sequence, int N>
+        struct value_at_c;
+
+        template <typename Sequence, typename Key>
+        struct at_key;
+
+        template <typename Sequence, typename N>
+        struct value_at_key;
+    }
+
+    template <typename N, typename Sequence>
+    typename 
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at<Sequence, N>
+        >::type
+    at(Sequence& seq);
+
+    template <typename N, typename Sequence>
+    typename result_of::at<Sequence const, N>::type
+    at(Sequence const& seq);
+
+    template <int N, typename Sequence>
+    typename 
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_c<Sequence, N>
+        >::type
+    at_c(Sequence& seq);
+
+    template <int N, typename Sequence>
+    typename result_of::at_c<Sequence const, N>::type
+    at_c(Sequence const& seq);
+
+    template <typename Sequence>
+    typename result_of::back<Sequence>::type
+    back(Sequence& seq);
+
+    template <typename Sequence>
+    typename result_of::back<Sequence const>::type
+    back(Sequence const& seq);
+
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence>
+        >::type const
+    begin(Sequence& seq);
+
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence const>
+        >::type const
+    begin(Sequence const& seq);
+
+    template <typename Sequence>
+    typename result_of::empty<Sequence>::type
+    empty(Sequence const&);
+
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence>
+        >::type const
+    end(Sequence& seq);
+
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence const>
+        >::type const
+    end(Sequence const& seq);
+
+    template <typename Sequence>
+    typename result_of::front<Sequence>::type
+    front(Sequence& seq);
+
+    template <typename Sequence>
+    typename result_of::front<Sequence const>::type
+    front(Sequence const& seq);
+
+    template <typename Key, typename Sequence>
+    typename result_of::has_key<Sequence, Key>::type
+    has_key(Sequence const& seq);
+
+    template <typename Sequence>
+    typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::segments<Sequence>
+        >::type
+    segments(Sequence& seq);
+
+    template <typename Sequence>
+    typename result_of::segments<Sequence const>::type
+    segments(Sequence const& seq);
+
+    template <typename Sequence>
+    typename result_of::size<Sequence>::type
+    size(Sequence const&);
+
+    template <typename Key, typename Sequence>
+    typename 
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_key<Sequence, Key>
+        >::type
+    at_key(Sequence& seq);
+
+    template <typename Key, typename Sequence>
+    typename result_of::at_key<Sequence const, Key>::type
+    at_key(Sequence const& seq);
+}}
+
+#endif

test/external/boost/fusion/sequence/io.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_SEQUENCE_IO_10032005_0836)
+#define FUSION_SEQUENCE_IO_10032005_0836
+
+#include <boost/fusion/sequence/io/in.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+
+#endif

test/external/boost/fusion/sequence/io/detail/in.hpp

@@ -0,0 +1,85 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 1999-2003 Jeremiah Willcock
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_IN_05052005_0121)
+#define FUSION_IN_05052005_0121
+
+#include <istream>
+#include <boost/fusion/sequence/io/detail/manip.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Tag>
+    struct delimiter_in
+    {
+        // read a delimiter
+        template <typename IS>
+        static void
+        read(IS& is, char const* delim, mpl::false_ = mpl::false_())
+        {
+            detail::string_ios_manip<Tag, IS> manip(is);
+            manip.read(delim);
+        }
+
+        template <typename IS>
+        static void
+        read(IS&, char const*, mpl::true_)
+        {
+        }
+    };
+
+    struct read_sequence_loop
+    {
+        template <typename IS, typename First, typename Last>
+        static void
+        call(IS&, First const&, Last const&, mpl::true_)
+        {
+        }
+
+        template <typename IS, typename First, typename Last>
+        static void
+        call(IS& is, First const& first, Last const& last, mpl::false_)
+        {
+            result_of::equal_to<
+                typename result_of::next<First>::type
+              , Last
+            >
+            is_last;
+
+            is >> *first;
+            delimiter_in<tuple_delimiter_tag>::read(is, " ", is_last);
+            call(is, fusion::next(first), last, is_last);
+        }
+
+        template <typename IS, typename First, typename Last>
+        static void
+        call(IS& is, First const& first, Last const& last)
+        {
+            result_of::equal_to<First, Last> eq;
+            call(is, first, last, eq);
+        }
+    };
+
+    template <typename IS, typename Sequence>
+    inline void
+    read_sequence(IS& is, Sequence& seq)
+    {
+        delimiter_in<tuple_open_tag>::read(is, "(");
+        read_sequence_loop::call(is, fusion::begin(seq), fusion::end(seq));
+        delimiter_in<tuple_close_tag>::read(is, ")");
+    }
+}}}
+
+#endif

test/external/boost/fusion/sequence/io/detail/manip.hpp

@@ -0,0 +1,320 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jeremiah Willcock
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_MANIP_05052005_1200)
+#define FUSION_MANIP_05052005_1200
+
+#include <boost/config.hpp>
+#include <string>
+#include <vector>
+#include <cctype>
+
+// Tuple I/O manipulators
+
+#define FUSION_GET_CHAR_TYPE(T) typename T::char_type
+#define FUSION_GET_TRAITS_TYPE(T) typename T::traits_type
+
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+#define FUSION_STRING_OF_STREAM(Stream) std::string
+#else
+#define FUSION_STRING_OF_STREAM(Stream)                                         \
+    std::basic_string<                                                          \
+        FUSION_GET_CHAR_TYPE(Stream)                                            \
+      , FUSION_GET_TRAITS_TYPE(Stream)                                          \
+    >
+#endif
+
+//$$$ these should be part of the public API$$$
+//$$$ rename tuple_open, tuple_close and tuple_delimiter to 
+//    open, close and delimeter and add these synonyms to the
+//    TR1 tuple module.
+
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template <typename Tag>
+        int get_xalloc_index(Tag* = 0)
+        {
+            // each Tag will have a unique index
+            static int index = std::ios::xalloc();
+            return index;
+        }
+
+        template <typename Stream, typename Tag, typename T>
+        struct stream_data
+        {
+            struct arena
+            {
+                ~arena()
+                {
+                    for (
+                        typename std::vector<T*>::iterator i = data.begin()
+                      ; i != data.end()
+                      ; ++i)
+                    {
+                        delete *i;
+                    }
+                }
+
+                std::vector<T*> data;
+            };
+
+            static void attach(Stream& stream, T const& data)
+            {
+                static arena ar; // our arena
+                ar.data.push_back(new T(data));
+                stream.pword(get_xalloc_index<Tag>()) = ar.data.back();
+            }
+
+            static T const* get(Stream& stream)
+            {
+                return (T const*)stream.pword(get_xalloc_index<Tag>());
+            }
+        };
+
+        template <typename Tag, typename Stream>
+        class string_ios_manip
+        {
+        public:
+
+            typedef FUSION_STRING_OF_STREAM(Stream) string_type;
+
+            typedef stream_data<Stream, Tag, string_type> stream_data_t;
+
+            string_ios_manip(Stream& str_)
+                : stream(str_)
+            {}
+
+            void
+            set(string_type const& s)
+            {
+                stream_data_t::attach(stream, s);
+            }
+
+            void
+            print(char const* default_) const
+            {
+                // print a delimiter
+                string_type const* p = stream_data_t::get(stream);
+                if (p)
+                    stream << *p;
+                else
+                    stream << default_;
+            }
+
+            void
+            read(char const* default_) const
+            {
+                // read a delimiter
+                string_type const* p = stream_data_t::get(stream);
+                using namespace std;
+                ws(stream);
+
+                if (p)
+                {
+                    typedef typename string_type::const_iterator iterator;
+                    for (iterator i = p->begin(); i != p->end(); ++i)
+                        check_delim(*i);
+                }
+                else
+                {
+                    while (*default_)
+                        check_delim(*default_++);
+                }
+            }
+
+        private:
+
+            template <typename Char>
+            void
+            check_delim(Char c) const
+            {
+                if (!isspace(c))
+                {
+                    if (stream.get() != c)
+                    {
+                        stream.unget();
+                        stream.setstate(std::ios::failbit);
+                    }
+                }
+            }
+
+            Stream& stream;
+
+        private:
+            // silence MSVC warning C4512: assignment operator could not be generated
+            string_ios_manip& operator= (string_ios_manip const&);
+        };
+
+    } // detail
+
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+
+#define STD_TUPLE_DEFINE_MANIPULATOR(name)                                      \
+    namespace detail                                                            \
+    {                                                                           \
+        struct name##_tag;                                                      \
+                                                                                \
+        struct name##_type                                                      \
+        {                                                                       \
+            typedef std::string string_type;                                    \
+            string_type data;                                                   \
+            name##_type(const string_type& d): data(d) {}                       \
+        };                                                                      \
+                                                                                \
+        template <typename Stream>                                              \
+        Stream& operator>>(Stream& s, const name##_type& m)                     \
+        {                                                                       \
+            string_ios_manip<name##_tag, Stream>(s).set(m.data);                \
+            return s;                                                           \
+        }                                                                       \
+                                                                                \
+        template <typename Stream>                                              \
+        Stream& operator<<(Stream& s, const name##_type& m)                     \
+        {                                                                       \
+            string_ios_manip<name##_tag, Stream>(s).set(m.data);                \
+            return s;                                                           \
+        }                                                                       \
+    }
+
+#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name)                            \
+    inline detail::name##_type                                                  \
+    name(const std::string& s)                                                  \
+    {                                                                           \
+        return detail::name##_type(s);                                          \
+    }                                                                           \
+                                                                                \
+    inline detail::name##_type                                                  \
+    name(const char* s)                                                         \
+    {                                                                           \
+        return detail::name##_type(std::string(s));                             \
+    }                                                                           \
+                                                                                \
+    inline detail::name##_type                                                  \
+    name(char c)                                                                \
+    {                                                                           \
+        return detail::name##_type(std::string(1, c));                          \
+    }
+
+#else // defined(BOOST_NO_TEMPLATED_STREAMS)
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+
+#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name)                            \
+    template <typename Char, typename Traits>                                   \
+    inline detail::name##_type<Char, Traits>                                    \
+    name(const std::basic_string<Char, Traits>& s)                              \
+    {                                                                           \
+        return detail::name##_type<Char, Traits>(s);                            \
+    }                                                                           \
+                                                                                \
+    inline detail::name##_type<char>                                            \
+    name(char const* s)                                                         \
+    {                                                                           \
+        return detail::name##_type<char>(std::basic_string<char>(s));           \
+    }                                                                           \
+                                                                                \
+    inline detail::name##_type<wchar_t>                                         \
+    name(wchar_t const* s)                                                      \
+    {                                                                           \
+        return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(s));     \
+    }                                                                           \
+                                                                                \
+    inline detail::name##_type<char>                                            \
+    name(char c)                                                                \
+    {                                                                           \
+        return detail::name##_type<char>(std::basic_string<char>(1, c));        \
+    }                                                                           \
+                                                                                \
+    inline detail::name##_type<wchar_t>                                         \
+    name(wchar_t c)                                                             \
+    {                                                                           \
+        return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(1, c));  \
+    }
+
+#else // defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+
+#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name)                            \
+    template <typename Char, typename Traits>                                   \
+    inline detail::name##_type<Char, Traits>                                    \
+    name(const std::basic_string<Char, Traits>& s)                              \
+    {                                                                           \
+        return detail::name##_type<Char, Traits>(s);                            \
+    }                                                                           \
+                                                                                \
+    template <typename Char>                                                    \
+    inline detail::name##_type<Char>                                            \
+    name(Char s[])                                                              \
+    {                                                                           \
+        return detail::name##_type<Char>(std::basic_string<Char>(s));           \
+    }                                                                           \
+                                                                                \
+    template <typename Char>                                                    \
+    inline detail::name##_type<Char>                                            \
+    name(Char const s[])                                                        \
+    {                                                                           \
+        return detail::name##_type<Char>(std::basic_string<Char>(s));           \
+    }                                                                           \
+                                                                                \
+    template <typename Char>                                                    \
+    inline detail::name##_type<Char>                                            \
+    name(Char c)                                                                \
+    {                                                                           \
+        return detail::name##_type<Char>(std::basic_string<Char>(1, c));        \
+    }
+
+#endif
+
+#define STD_TUPLE_DEFINE_MANIPULATOR(name)                                      \
+    namespace detail                                                            \
+    {                                                                           \
+        struct name##_tag;                                                      \
+                                                                                \
+        template <typename Char, typename Traits = std::char_traits<Char> >     \
+        struct name##_type                                                      \
+        {                                                                       \
+            typedef std::basic_string<Char, Traits> string_type;                \
+            string_type data;                                                   \
+            name##_type(const string_type& d): data(d) {}                       \
+        };                                                                      \
+                                                                                \
+        template <typename Stream, typename Char, typename Traits>              \
+        Stream& operator>>(Stream& s, const name##_type<Char,Traits>& m)        \
+        {                                                                       \
+            string_ios_manip<name##_tag, Stream>(s).set(m.data);                \
+            return s;                                                           \
+        }                                                                       \
+                                                                                \
+        template <typename Stream, typename Char, typename Traits>              \
+        Stream& operator<<(Stream& s, const name##_type<Char,Traits>& m)        \
+        {                                                                       \
+            string_ios_manip<name##_tag, Stream>(s).set(m.data);                \
+            return s;                                                           \
+        }                                                                       \
+    }                                                                           \
+
+#endif // defined(BOOST_NO_TEMPLATED_STREAMS)
+
+    STD_TUPLE_DEFINE_MANIPULATOR(tuple_open)
+    STD_TUPLE_DEFINE_MANIPULATOR(tuple_close)
+    STD_TUPLE_DEFINE_MANIPULATOR(tuple_delimiter)
+
+    STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_open)
+    STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_close)
+    STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_delimiter)
+
+#undef STD_TUPLE_DEFINE_MANIPULATOR
+#undef STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS
+#undef FUSION_STRING_OF_STREAM
+#undef FUSION_GET_CHAR_TYPE
+#undef FUSION_GET_TRAITS_TYPE
+
+}}
+
+#endif

test/external/boost/fusion/sequence/io/detail/out.hpp

@@ -0,0 +1,85 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 1999-2003 Jeremiah Willcock
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_OUT_05052005_0121)
+#define FUSION_OUT_05052005_0121
+
+#include <ostream>
+#include <boost/fusion/sequence/io/detail/manip.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Tag>
+    struct delimiter_out
+    {
+        // print a delimiter
+        template <typename OS>
+        static void
+        print(OS& os, char const* delim, mpl::false_ = mpl::false_())
+        {
+            detail::string_ios_manip<Tag, OS> manip(os);
+            manip.print(delim);
+        }
+
+        template <typename OS>
+        static void
+        print(OS&, char const*, mpl::true_)
+        {
+        }
+    };
+
+    struct print_sequence_loop
+    {
+        template <typename OS, typename First, typename Last>
+        static void
+        call(OS&, First const&, Last const&, mpl::true_)
+        {
+        }
+
+        template <typename OS, typename First, typename Last>
+        static void
+        call(OS& os, First const& first, Last const& last, mpl::false_)
+        {
+            result_of::equal_to<
+                typename result_of::next<First>::type
+              , Last
+            >
+            is_last;
+
+            os << *first;
+            delimiter_out<tuple_delimiter_tag>::print(os, " ", is_last);
+            call(os, fusion::next(first), last, is_last);
+        }
+
+        template <typename OS, typename First, typename Last>
+        static void
+        call(OS& os, First const& first, Last const& last)
+        {
+            result_of::equal_to<First, Last> eq;
+            call(os, first, last, eq);
+        }
+    };
+
+    template <typename OS, typename Sequence>
+    inline void
+    print_sequence(OS& os, Sequence const& seq)
+    {
+        delimiter_out<tuple_open_tag>::print(os, "(");
+        print_sequence_loop::call(os, fusion::begin(seq), fusion::end(seq));
+        delimiter_out<tuple_close_tag>::print(os, ")");
+    }
+}}}
+
+#endif

test/external/boost/fusion/sequence/io/in.hpp

@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 1999-2003 Jeremiah Willcock
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_IN_05042005_0120)
+#define BOOST_IN_05042005_0120
+
+#include <istream>
+#include <boost/fusion/sequence/io/detail/in.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+
+namespace boost { namespace fusion
+{
+    template <typename Sequence>
+    inline std::istream&
+    in(std::istream& is, Sequence& seq)
+    {
+        detail::read_sequence(is, seq);
+        return is;
+    }
+
+    namespace operators
+    {
+        template <typename Sequence>
+        inline typename
+            enable_if<
+               fusion::traits::is_sequence<Sequence>
+              , std::istream&
+            >::type
+        operator>>(std::istream& is, Sequence& seq)
+        {
+            return fusion::in(is, seq);
+        }
+    }
+    using operators::operator>>;
+}}
+
+#endif

test/external/boost/fusion/sequence/io/out.hpp

@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 1999-2003 Jeremiah Willcock
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_OUT_05042005_0120)
+#define BOOST_OUT_05042005_0120
+
+#include <ostream>
+#include <boost/fusion/sequence/io/detail/out.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/or.hpp>
+
+namespace boost { namespace fusion
+{
+    template <typename Sequence>
+    inline std::ostream&
+    out(std::ostream& os, Sequence& seq)
+    {
+        detail::print_sequence(os, seq);
+        return os;
+    }
+    
+    namespace operators
+    {
+        template <typename Sequence>
+        inline typename
+            enable_if<
+               fusion::traits::is_sequence<Sequence>
+              , std::ostream&
+            >::type
+        operator<<(std::ostream& os, Sequence const& seq)
+        {
+            return fusion::out(os, seq);
+        }
+    }
+    using operators::operator<<;
+}}
+
+#endif

test/external/boost/fusion/sequence/sequence_facade.hpp

@@ -0,0 +1,29 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_SEQUENCE_FACADE_09252006_1044)
+#define FUSION_SEQUENCE_FACADE_09252006_1044
+
+#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+
+    template <typename Derived, typename Category, typename IsView = mpl::false_>
+    struct sequence_facade : sequence_base<Derived>
+    {
+        typedef fusion_sequence_tag tag;
+        typedef sequence_facade_tag fusion_tag;
+        typedef Derived derived_type;
+        typedef Category category;
+        typedef IsView is_view;
+        typedef mpl::false_ is_segmented;
+    };
+}}
+
+#endif