Imported existing code

libraries/include/boost/fusion/sequence/comparison.hpp

@@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp

@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/is_sequence.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/support/detail/is_mpl_sequence.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Sequence>
+    struct is_native_fusion_sequence : is_base_of<sequence_root, Sequence> {};
+
+    template <typename Seq1, typename Seq2>
+    struct enable_equality
+        : mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
+    {};
+
+    template <typename Seq1, typename Seq2>
+    struct enable_comparison
+        : mpl::and_<
+            mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
+          , mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> > 
+        >
+    {};
+
+}}}
+
+#endif

libraries/include/boost/fusion/sequence/comparison/detail/equal_to.hpp

@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/comparison/detail/greater.hpp

@@ -0,0 +1,50 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/comparison/detail/greater_equal.hpp

@@ -0,0 +1,49 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/comparison/detail/less.hpp

@@ -0,0 +1,50 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/comparison/detail/less_equal.hpp

@@ -0,0 +1,49 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/comparison/detail/not_equal_to.hpp

@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/comparison/equal_to.hpp

@@ -0,0 +1,46 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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/detail/enable_comparison.hpp>
+
+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<
+                detail::enable_equality<Seq1, Seq2>
+              , bool
+            >::type
+        operator==(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::equal_to(a, b);
+        }
+    }
+    using operators::operator==;
+}}
+
+#endif

libraries/include/boost/fusion/sequence/comparison/greater.hpp

@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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/detail/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<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator>(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::greater(a, b);
+        }
+    }
+    using operators::operator>;
+}}
+
+#endif

libraries/include/boost/fusion/sequence/comparison/greater_equal.hpp

@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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/detail/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<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator>=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::greater_equal(a, b);
+        }
+    }
+    using operators::operator>=;
+}}
+
+#endif

libraries/include/boost/fusion/sequence/comparison/less.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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/detail/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<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator<(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::less(a, b);
+        }
+    }
+    using operators::operator<;
+}}
+
+#endif

libraries/include/boost/fusion/sequence/comparison/less_equal.hpp

@@ -0,0 +1,80 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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/detail/enable_comparison.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<detail::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<detail::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<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator<=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::less_equal(a, b);
+        }
+#endif
+    }
+    using operators::operator<=;
+}}
+
+#endif

libraries/include/boost/fusion/sequence/comparison/not_equal_to.hpp

@@ -0,0 +1,55 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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/detail/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<
+                detail::enable_equality<Seq1, Seq2>
+              , bool
+            >::type
+        operator!=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::not_equal_to(a, b);
+        }
+    }
+    using operators::operator!=;
+}}
+
+#endif

libraries/include/boost/fusion/sequence/convert.hpp

@@ -0,0 +1,48 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/intrinsic.hpp

@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/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

libraries/include/boost/fusion/sequence/intrinsic/at.hpp

@@ -0,0 +1,106 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/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 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_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<array_tag>;
+
+        template <>
+        struct at_impl<mpl_sequence_tag>;
+
+        template <>
+        struct at_impl<std_pair_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 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 at<mpl::int_<N> >(seq);
+    }
+}}
+
+#endif
+

libraries/include/boost/fusion/sequence/intrinsic/at_c.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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
+

libraries/include/boost/fusion/sequence/intrinsic/at_key.hpp

@@ -0,0 +1,77 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/support/tag_of.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct 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 Sequence, typename Key>
+            struct apply;
+        };
+
+        template <>
+        struct at_key_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : Sequence::template at_key<Sequence, Key> {};
+        };
+
+        template <>
+        struct at_key_impl<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

libraries/include/boost/fusion/sequence/intrinsic/back.hpp

@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/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

libraries/include/boost/fusion/sequence/intrinsic/begin.hpp

@@ -0,0 +1,74 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/fusion/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag; // iterator facade tag
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct 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;
+        };
+
+        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<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 result_of::begin<Sequence>::type const
+    begin(Sequence& seq)
+    {
+        return result_of::begin<Sequence>::call(seq);
+    }
+
+    template <typename Sequence>
+    inline typename result_of::begin<Sequence const>::type const
+    begin(Sequence const& seq)
+    {
+        return result_of::begin<Sequence const>::call(seq);
+    }
+}}
+
+#endif

libraries/include/boost/fusion/sequence/intrinsic/empty.hpp

@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/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

libraries/include/boost/fusion/sequence/intrinsic/end.hpp

@@ -0,0 +1,74 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/fusion/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct 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;
+        };
+
+        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<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 result_of::end<Sequence>::type const
+    end(Sequence& seq)
+    {
+        return result_of::end<Sequence>::call(seq);
+    }
+
+    template <typename Sequence>
+    inline typename result_of::end<Sequence const>::type const
+    end(Sequence const& seq)
+    {
+        return result_of::end<Sequence const>::call(seq);
+    }
+}}
+
+#endif

libraries/include/boost/fusion/sequence/intrinsic/ext_/segments.hpp

@@ -0,0 +1,56 @@
+/*=============================================================================
+    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(FUSION_SEGMENTS_04052005_1141)
+#define FUSION_SEGMENTS_04052005_1141
+
+#include <boost/fusion/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // segments: returns a sequence of sequences
+    namespace extension
+    {
+        template <typename Tag>
+        struct segments_impl
+        {
+            template <typename Sequence>
+            struct apply {};
+        };
+    }
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct segments
+        {
+            typedef typename
+                extension::segments_impl<typename traits::tag_of<Sequence>::type>::
+                    template apply<Sequence>::type
+            type;
+        };
+    }
+
+    template <typename Sequence>
+    typename result_of::segments<Sequence>::type
+    segments(Sequence & seq)
+    {
+        return
+            extension::segments_impl<typename traits::tag_of<Sequence>::type>::
+                template apply<Sequence>::call(seq);
+    }
+
+    template <typename Sequence>
+    typename result_of::segments<Sequence const>::type
+    segments(Sequence const& seq)
+    {
+        return
+            extension::segments_impl<typename traits::tag_of<Sequence>::type>::
+                template apply<Sequence const>::call(seq);
+    }
+}}
+
+#endif

libraries/include/boost/fusion/sequence/intrinsic/ext_/size_s.hpp

@@ -0,0 +1,57 @@
+/*=============================================================================
+    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(FUSION_SIZE_S_08112006_1141)
+#define FUSION_SIZE_S_08112006_1141
+
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/size_t.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/algorithm/iteration/fold.hpp>
+#include <boost/fusion/support/ext_/is_segmented.hpp>
+#include <boost/fusion/sequence/intrinsic/ext_/segments.hpp>
+
+namespace boost { namespace fusion
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // calculates the size of any segmented data structure.
+    template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value>
+    struct segmented_size;
+
+    namespace detail
+    {
+        struct size_plus
+        {
+            template<typename Sig>
+            struct result;
+
+            template<typename This, typename Seq, typename State>
+            struct result<This(Seq, State)>
+              : mpl::plus<
+                    segmented_size<typename remove_reference<Seq>::type>
+                  , typename remove_reference<State>::type
+                >
+            {};
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template<typename Sequence, bool IsSegmented>
+    struct segmented_size
+      : result_of::fold<
+            typename result_of::segments<Sequence>::type
+          , mpl::size_t<0>
+          , detail::size_plus
+        >::type
+    {};
+
+    template<typename Sequence>
+    struct segmented_size<Sequence, false>
+      : result_of::size<Sequence>
+    {};
+}}
+
+#endif

libraries/include/boost/fusion/sequence/intrinsic/front.hpp

@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/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

libraries/include/boost/fusion/sequence/intrinsic/has_key.hpp

@@ -0,0 +1,72 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/mpl/not.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    // Special tags:
+    struct sequence_facade_tag;
+    struct 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 Sequence, typename Key>
+            struct apply
+                : mpl::not_<is_same<typename Sequence::
+                    template meta_at_impl<Key>::type, void_> >
+            {};
+        };
+
+        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<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
+

libraries/include/boost/fusion/sequence/intrinsic/size.hpp

@@ -0,0 +1,74 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/mpl/int.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 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 apply : Sequence::size {};
+        };
+
+        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<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

libraries/include/boost/fusion/sequence/intrinsic/swap.hpp

@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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

libraries/include/boost/fusion/sequence/intrinsic/value_at.hpp

@@ -0,0 +1,67 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct boost_tuple_tag; // boost::tuples::tuple tag
+    struct 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<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
+

libraries/include/boost/fusion/sequence/intrinsic/value_at_key.hpp

@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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/support/tag_of.hpp>
+
+namespace boost { namespace fusion
+{
+    // Special tags:
+    struct sequence_facade_tag;
+    struct 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 Sequence, typename Key>
+            struct apply;
+        };
+
+        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<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
+

libraries/include/boost/fusion/sequence/io.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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

libraries/include/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-2006 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& is, char const* delim, mpl::true_)
+        {
+        }
+    };
+
+    struct read_sequence_loop
+    {
+        template <typename IS, typename First, typename Last>
+        static void
+        call(IS& 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

libraries/include/boost/fusion/sequence/io/detail/manip.hpp

@@ -0,0 +1,316 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jeremiah Willcock
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2006 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;
+        };
+
+    } // 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

libraries/include/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-2006 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& os, char const* delim, mpl::true_)
+        {
+        }
+    };
+
+    struct print_sequence_loop
+    {
+        template <typename OS, typename First, typename Last>
+        static void
+        call(OS& 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

libraries/include/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-2006 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

libraries/include/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-2006 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

libraries/include/boost/fusion/sequence/sequence_facade.hpp

@@ -0,0 +1,27 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 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 sequence_facade_tag fusion_tag;
+        typedef Derived derived_type;
+        typedef Category category;
+        typedef IsView is_view;
+    };
+}}
+
+#endif