add boost on mac

macx64/include/boost/fusion/algorithm/query/all.hpp

@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 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_ALL_05052005_1238)
+#define BOOST_FUSION_ALL_05052005_1238
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/algorithm/query/detail/all.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct all
+        {
+            typedef bool type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    all(Sequence const& seq, F f)
+    {
+        return detail::all(seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/any.hpp

@@ -0,0 +1,37 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005 Eric Niebler
+    Copyright (c) 2007 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_ANY_05052005_1230)
+#define FUSION_ANY_05052005_1230
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/algorithm/query/detail/any.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct any
+        {
+            typedef bool type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    any(Sequence const& seq, F f)
+    {
+        return detail::any(seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/count.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007
+
+    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_COUNT_09162005_0150)
+#define BOOST_FUSION_COUNT_09162005_0150
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/count_if.hpp>
+#include <boost/fusion/algorithm/query/detail/count.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct count
+        {
+            typedef int type;
+        };
+    }
+
+    template <typename Sequence, typename T>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , int
+        >::type
+    count(Sequence const& seq, T const& x)
+    {
+        detail::count_compare<T> f(x);
+        return fusion::count_if(seq, f);
+    }
+}}
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/count_if.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 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_COUNT_IF_09162005_0137)
+#define BOOST_FUSION_COUNT_IF_09162005_0137
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/detail/count_if.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct count_if
+        {
+            typedef int type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , int
+        >::type
+    count_if(Sequence const& seq, F f)
+    {
+        return detail::count_if(
+            seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/detail/all.hpp

@@ -0,0 +1,137 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 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_ALL_05052005_1237)
+#define FUSION_ALL_05052005_1237
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename First, typename Last, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_all(First const&, Last const&, F const&, mpl::true_)
+    {
+        return true;
+    }
+
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_all(First const& first, Last const& last, F& f, mpl::false_)
+    {
+        typename result_of::deref<First>::type x = *first;
+        return f(x) &&
+            detail::linear_all(
+                fusion::next(first)
+              , last
+              , f
+              , result_of::equal_to<typename result_of::next<First>::type, Last>());
+    }
+
+    template <typename Sequence, typename F, typename Tag>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    all(Sequence const& seq, F f, Tag)
+    {
+        return detail::linear_all(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , result_of::equal_to<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>());
+    }
+
+    template<int N>
+    struct unrolled_all
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) &&
+                f(*fusion::advance_c<1>(it))&&
+                f(*fusion::advance_c<2>(it)) &&
+                f(*fusion::advance_c<3>(it)) &&
+                detail::unrolled_all<N-4>::call(fusion::advance_c<4>(it), f);
+        }
+    };
+
+    template<>
+    struct unrolled_all<3>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) &&
+                f(*fusion::advance_c<1>(it)) &&
+                f(*fusion::advance_c<2>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_all<2>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) &&
+                f(*fusion::advance_c<1>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_all<1>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return f(*it);
+        }
+    };
+
+    template<>
+    struct unrolled_all<0>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& /*it*/, F /*f*/)
+        {
+            return true;
+        }
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    all(Sequence const& seq, F f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        return detail::unrolled_all<result_of::distance<begin, end>::type::value>::call(
+            fusion::begin(seq), f);
+    }
+}}}
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/detail/any.hpp

@@ -0,0 +1,140 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005 Eric Niebler
+    Copyright (c) 2007 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_ANY_05052005_1229)
+#define FUSION_ANY_05052005_1229
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+
+namespace boost { namespace fusion { 
+    struct random_access_traversal_tag;
+namespace detail
+{
+    template <typename First, typename Last, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_any(First const&, Last const&, F const&, mpl::true_)
+    {
+        return false;
+    }
+
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_any(First const& first, Last const& last, F& f, mpl::false_)
+    {
+        typename result_of::deref<First>::type x = *first;
+        return f(x) ||
+            detail::linear_any(
+                fusion::next(first)
+              , last
+              , f
+              , result_of::equal_to<typename result_of::next<First>::type, Last>());
+    }
+
+    template <typename Sequence, typename F, typename Tag>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    any(Sequence const& seq, F f, Tag)
+    {
+        return detail::linear_any(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , result_of::equal_to<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>());
+    }
+
+    template<int N>
+    struct unrolled_any
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it))||
+                f(*fusion::advance_c<2>(it)) ||
+                f(*fusion::advance_c<3>(it)) ||
+                detail::unrolled_any<N-4>::call(fusion::advance_c<4>(it), f);
+        }
+    };
+
+    template<>
+    struct unrolled_any<3>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it)) ||
+                f(*fusion::advance_c<2>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_any<2>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_any<1>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return f(*it);
+        }
+    };
+
+    template<>
+    struct unrolled_any<0>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const&, F)
+        {
+            return false;
+        }
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    any(Sequence const& seq, F f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        return detail::unrolled_any<result_of::distance<begin, end>::type::value>::call(
+            fusion::begin(seq), f);
+    }
+}}}
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/detail/count.hpp

@@ -0,0 +1,83 @@
+/*=============================================================================
+    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_COUNT_09162005_0158)
+#define FUSION_COUNT_09162005_0158
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/config.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+namespace boost { namespace fusion { namespace detail
+{ 
+    template <bool is_convertible>
+    struct compare_convertible;
+
+    // T1 is convertible to T2 or vice versa
+    template <>
+    struct compare_convertible<true>
+    {
+        template <typename T1, typename T2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool
+        call(T1 const& x, T2 const& y)
+        {
+            return x == y;
+        }
+    };
+
+    // T1 is NOT convertible to T2 NOR vice versa
+    template <>
+    struct compare_convertible<false>
+    {
+        template <typename T1, typename T2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool
+        call(T1 const&, T2 const&)
+        {
+            return false;
+        }
+    };
+
+    template <typename T1>
+    struct count_compare
+    {
+        typedef typename detail::call_param<T1>::type param;
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        count_compare(param in_x)
+            : x(in_x) {}
+
+        template <typename T2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        bool
+        operator()(T2 const& y) const
+        {
+            return
+                compare_convertible<
+                    mpl::or_<
+                        is_convertible<T1, T2>
+                      , is_convertible<T2, T1> 
+                    >::value
+                >::call(x, y);
+        }
+
+        param x;
+    };
+}}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/detail/count_if.hpp

@@ -0,0 +1,180 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 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_COUNT_IF_09162005_0141)
+#define BOOST_FUSION_COUNT_IF_09162005_0141
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+
+namespace boost { namespace fusion { 
+    struct random_access_traversal_tag;
+namespace detail
+{
+    template <typename First, typename Last, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    linear_count_if(First const&, Last const&, F const&, mpl::true_)
+    {
+        return 0;
+    }
+
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    linear_count_if(First const& first, Last const& last, F& f, mpl::false_)
+    {
+        int n =
+            detail::linear_count_if(
+                fusion::next(first)
+              , last
+              , f
+              , result_of::equal_to<typename result_of::next<First>::type, Last>());
+        if (f(*first))
+            ++n;
+        return n;
+    }
+
+    template <typename Sequence, typename F, typename Tag>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    count_if(Sequence const& seq, F f, Tag)
+    {
+        return detail::linear_count_if(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , result_of::equal_to<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>());
+    }
+
+    template<int n>
+    struct unrolled_count_if
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = unrolled_count_if<n-4>::
+                call(fusion::advance_c<4>(i0), f);
+            if(f(*i0))
+                ++ct;
+
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            if(f(*i1))
+                ++ct;
+
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            if(f(*i2))
+                ++ct;
+
+            typedef typename result_of::next<I2>::type I3;
+            I3 i3(fusion::next(i2));
+            if(f(*i3))
+                ++ct;
+
+            return ct;
+        }
+    };
+
+    template<>
+    struct unrolled_count_if<3>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = 0;
+            if(f(*i0))
+                ++ct;
+
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            if(f(*i1))
+                ++ct;
+
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            if(f(*i2))
+                ++ct;
+
+            return ct;
+        }
+    };
+
+    template<>
+    struct unrolled_count_if<2>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = 0;
+
+            if(f(*i0))
+                ++ct;
+
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            if(f(*i1))
+                ++ct;
+
+            return ct;
+        }
+    };
+
+    template<>
+    struct unrolled_count_if<1>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = 0;
+            if(f(*i0))
+                ++ct;
+            return ct;
+        }
+    };
+
+
+    template<>
+    struct unrolled_count_if<0>
+    {
+        template<typename I0, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const&, F)
+        {
+            return 0;
+        }
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    count_if(Sequence const& seq, F f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        return detail::unrolled_count_if<result_of::distance<begin, end>::type::value>::
+            call(fusion::begin(seq), f);
+    }
+}}}
+
+#endif
+

macx64/include/boost/fusion/algorithm/query/detail/find_if.hpp

@@ -0,0 +1,251 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2009 Christopher Schmidt
+    Copyright (c) 2018 Kohei Takahashi
+
+    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_FIND_IF_05052005_1107)
+#define FUSION_FIND_IF_05052005_1107
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/core/enable_if.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Iterator, typename Pred>
+    struct apply_filter
+    {
+        typedef typename mpl::apply1<
+            Pred, Iterator>::type type;
+        BOOST_STATIC_CONSTANT(int, value = type::value);
+    };
+
+    template <typename First, typename Last, typename Pred>
+    struct main_find_if;
+
+    template <typename First, typename Last, typename Pred>
+    struct recursive_find_if
+    {
+        typedef typename
+            main_find_if<
+                typename result_of::next<First>::type, Last, Pred
+            >::type
+        type;
+    };
+
+    template <typename First, typename Last, typename Pred>
+    struct main_find_if
+    {
+        typedef mpl::or_<
+            result_of::equal_to<First, Last>
+          , apply_filter<First, Pred> >
+        filter;
+
+        typedef typename
+            mpl::eval_if<
+                filter
+              , mpl::identity<First>
+              , recursive_find_if<First, Last, Pred>
+            >::type
+        type;
+    };
+
+    template<
+        typename First, typename Last, 
+        typename Pred, bool>
+    struct choose_find_if;
+
+    template<typename First, typename Last, typename Pred>
+    struct choose_find_if<First, Last, Pred, false>
+        : main_find_if<First, Last, Pred>
+    {};
+
+    template<typename Iter, typename Pred, int n, int unrolling>
+    struct unroll_again;
+
+    template <typename Iter, typename Pred, int offset>
+    struct apply_offset_filter
+    {
+        typedef typename result_of::advance_c<Iter, offset>::type Shifted;
+        typedef typename
+            mpl::apply1<
+                Pred
+              , Shifted
+            >::type
+        type;
+        BOOST_STATIC_CONSTANT(int, value = type::value);
+    };
+
+    template<typename Iter, typename Pred, int n>
+    struct unrolled_find_if
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              mpl::eval_if<
+                apply_offset_filter<Iter, Pred, 2>,
+                result_of::advance_c<Iter, 2>,
+                mpl::eval_if<
+                  apply_offset_filter<Iter, Pred, 3>,
+                  result_of::advance_c<Iter, 3>,
+                  unroll_again<
+                    Iter,
+                    Pred,
+                    n,
+                    4> > > > >::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 3>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              mpl::eval_if<
+                apply_offset_filter<Iter, Pred, 2>,
+                result_of::advance_c<Iter, 2>,
+                result_of::advance_c<Iter, 3> > > >::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 2>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              result_of::advance_c<Iter, 2> > >::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 1>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            result_of::advance_c<Iter, 1> >::type type;
+    };
+
+    template<typename Iter, typename Pred, int n, int unrolling>
+    struct unroll_again
+    {
+        typedef typename unrolled_find_if<
+            typename result_of::advance_c<Iter, unrolling>::type,
+            Pred,
+            n-unrolling>::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 0>
+    {
+        typedef Iter type;
+    };
+
+    template<typename First, typename Last, typename Pred>
+    struct choose_find_if<First, Last, Pred, true>
+    {
+        typedef typename result_of::distance<First, Last>::type N;
+        typedef typename unrolled_find_if<First, Pred, N::value>::type type;
+    };
+
+    template <typename First, typename Last, typename Pred>
+    struct static_find_if
+    {
+        typedef typename
+            choose_find_if<
+                First
+              , Last
+              , Pred
+              , traits::is_random_access<First>::value
+            >::type
+        type;
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        recursive_call(Iterator const& iter, mpl::true_)
+        {
+            return iter;
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        recursive_call(Iterator const& iter, mpl::false_)
+        {
+            return recursive_call(fusion::next(iter));
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        recursive_call(Iterator const& iter)
+        {
+            typedef result_of::equal_to<Iterator, type> found;
+            return recursive_call(iter, found());
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static typename boost::disable_if<traits::is_random_access<Iterator>, type>::type
+        iter_call(Iterator const& iter)
+        {
+            return recursive_call(iter);
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static typename boost::enable_if<traits::is_random_access<Iterator>, type>::type
+        iter_call(Iterator const& iter)
+        {
+            typedef typename result_of::distance<Iterator, type>::type N;
+            return fusion::advance<N>(iter);
+        }
+
+        template <typename Sequence>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        call(Sequence& seq)
+        {
+            return iter_call(fusion::begin(seq));
+        }
+    };
+
+    template <typename Sequence, typename Pred>
+    struct result_of_find_if
+    {
+        typedef
+            static_find_if<
+                typename result_of::begin<Sequence>::type
+              , typename result_of::end<Sequence>::type
+              , Pred
+            >
+        filter;
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif

macx64/include/boost/fusion/algorithm/query/detail/segmented_find.hpp

@@ -0,0 +1,95 @@
+/*=============================================================================
+    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_FIND_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/fusion/algorithm/query/find_fwd.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct segmented_find_fun
+    {
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef
+                typename result_of::find<Sequence, T>::type
+            iterator_type;
+
+            typedef
+                typename result_of::equal_to<
+                    iterator_type
+                  , typename result_of::end<Sequence>::type
+                >::type
+            continue_type;
+
+            typedef
+                typename mpl::eval_if<
+                    continue_type
+                  , mpl::identity<State>
+                  , result_of::make_segmented_iterator<
+                        iterator_type
+                      , Context
+                    >
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq, State const&state, Context const& context, segmented_find_fun)
+            {
+                return call_impl(seq, state, context, continue_type());
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
+            {
+                return state;
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence& seq, State const&, Context const& context, mpl::false_)
+            {
+                return fusion::make_segmented_iterator(fusion::find<T>(seq), context);
+            }
+        };
+    };
+
+    template <typename Sequence, typename T>
+    struct result_of_segmented_find
+    {
+        struct filter
+        {
+            typedef
+                typename result_of::segmented_fold_until<
+                    Sequence
+                  , typename result_of::end<Sequence>::type
+                  , segmented_find_fun<T>
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq)
+            {
+                return fusion::segmented_fold_until(
+                    seq
+                  , fusion::end(seq)
+                  , detail::segmented_find_fun<T>());
+            }
+        };
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif

macx64/include/boost/fusion/algorithm/query/detail/segmented_find_if.hpp

@@ -0,0 +1,95 @@
+/*=============================================================================
+    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_FIND_IF_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_FIND_IF_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Pred>
+    struct segmented_find_if_fun
+    {
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef
+                typename result_of::find_if<Sequence, Pred>::type
+            iterator_type;
+
+            typedef
+                typename result_of::equal_to<
+                    iterator_type
+                  , typename result_of::end<Sequence>::type
+                >::type
+            continue_type;
+
+            typedef
+                typename mpl::eval_if<
+                    continue_type
+                  , mpl::identity<State>
+                  , result_of::make_segmented_iterator<
+                        iterator_type
+                      , Context
+                    >
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq, State const&state, Context const& context, segmented_find_if_fun)
+            {
+                return call_impl(seq, state, context, continue_type());
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
+            {
+                return state;
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence& seq, State const&, Context const& context, mpl::false_)
+            {
+                return fusion::make_segmented_iterator(fusion::find_if<Pred>(seq), context);
+            }
+        };
+    };
+
+    template <typename Sequence, typename Pred>
+    struct result_of_segmented_find_if
+    {
+        struct filter
+        {
+            typedef
+                typename result_of::segmented_fold_until<
+                    Sequence
+                  , typename result_of::end<Sequence>::type
+                  , segmented_find_if_fun<Pred>
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq)
+            {
+                return fusion::segmented_fold_until(
+                    seq
+                  , fusion::end(seq)
+                  , segmented_find_if_fun<Pred>());
+            }
+        };
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif

macx64/include/boost/fusion/algorithm/query/find.hpp

@@ -0,0 +1,72 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    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(FUSION_FIND_05052005_1107)
+#define FUSION_FIND_05052005_1107
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
+#include <boost/fusion/algorithm/query/detail/find_if.hpp>
+#include <boost/fusion/algorithm/query/detail/segmented_find.hpp>
+#include <boost/fusion/iterator/key_of.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct find
+          : mpl::if_<
+                traits::is_segmented<Sequence>
+              , detail::result_of_segmented_find<Sequence, T>
+              , detail::result_of_find_if<
+                    Sequence,
+                    is_same<
+                        typename mpl::if_<
+                            traits::is_associative<Sequence>
+                          , key_of<mpl::_1>
+                          , value_of<mpl::_1>
+                        >::type
+                      , T
+                    >
+                >
+            >::type
+        {};
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find<Sequence, T>
+        >::type const
+    find(Sequence& seq)
+    {
+        typedef typename result_of::find<Sequence, T>::filter filter;
+        return filter::call(seq);
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find<Sequence const, T>::type const
+    find(Sequence const& seq)
+    {
+        typedef typename result_of::find<Sequence const, T>::filter filter;
+        return filter::call(seq);
+    }
+}}
+
+#endif

macx64/include/boost/fusion/algorithm/query/find_fwd.hpp

@@ -0,0 +1,37 @@
+/*=============================================================================
+    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_FIND_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_FIND_FWD_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct find;
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find<Sequence, T>
+        >::type const
+    find(Sequence& seq);
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find<Sequence const, T>::type const
+    find(Sequence const& seq);
+}}
+
+#endif

macx64/include/boost/fusion/algorithm/query/find_if.hpp

@@ -0,0 +1,67 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    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(FUSION_FIND_IF_05052005_1108)
+#define FUSION_FIND_IF_05052005_1108
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
+#include <boost/fusion/algorithm/query/detail/find_if.hpp>
+#include <boost/fusion/algorithm/query/detail/segmented_find_if.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/bind.hpp>
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/quote.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct find_if
+          : mpl::if_<
+                traits::is_segmented<Sequence>
+              , detail::result_of_segmented_find_if<Sequence, Pred>
+              , detail::result_of_find_if<
+                    Sequence,
+                    mpl::bind1<
+                        typename mpl::lambda<Pred>::type
+                      , mpl::bind1<mpl::quote1<value_of>, mpl::_1>
+                    >
+                >
+            >::type
+        {};
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find_if<Sequence, Pred>
+        >::type
+    find_if(Sequence& seq)
+    {
+        typedef typename result_of::find_if<Sequence, Pred>::filter filter;
+        return filter::call(seq);
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find_if<Sequence const, Pred>::type const
+    find_if(Sequence const& seq)
+    {
+        typedef typename result_of::find_if<Sequence const, Pred>::filter filter;
+        return filter::call(seq);
+    }
+}}
+
+#endif

macx64/include/boost/fusion/algorithm/query/find_if_fwd.hpp

@@ -0,0 +1,38 @@
+/*=============================================================================
+    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_FIND_IF_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_FIND_IF_FWD_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+// Forward declaration of find_if algorithm
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct find_if;
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find_if<Sequence, Pred>
+        >::type
+    find_if(Sequence& seq);
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find_if<Sequence const, Pred>::type const
+    find_if(Sequence const& seq);
+}}
+
+#endif

macx64/include/boost/fusion/algorithm/query/none.hpp

@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 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_NONE_07062005_1128)
+#define BOOST_FUSION_NONE_07062005_1128
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/any.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct none
+        {
+            typedef bool type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    none(Sequence const& seq, F f)
+    {
+        return !fusion::any(seq, f);
+    }
+}}
+
+#endif
+