simplify segmented_fold_until interface

[SVN r73898]

include/boost/fusion/algorithm/iteration/ext_/fold_s.hpp

@@ -15,34 +15,24 @@ namespace boost { namespace fusion { namespace detail
     template <typename Fun>
     struct segmented_fold_fun
     {
-        template <typename Sig>
-        struct result;
-
-        template <typename This, typename Sequence, typename State, typename Context>
-        struct result<This(Sequence&, State&, Context&)>
-        {
-            typedef
-                fusion::result<
-                    typename result_of::fold<Sequence, State, Fun>::type,
-                    continue_
-                >
-            type;
-        };
-
         explicit segmented_fold_fun(Fun const& f)
           : fun(f)
         {}
 
-        template <typename Sequence, typename State, typename Context>
-        typename result<segmented_fold_fun(Sequence&, State const&, Context const&)>::type
-        operator()(Sequence& seq, State const& state, Context const&) const
-        {
-            return fusion::fold(seq, state, fun);
-        }
-
         Fun const& fun;
-    };
 
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef typename result_of::fold<Sequence, State, Fun>::type type;
+            typedef mpl::true_ continue_type;
+
+            static type call(Sequence& seq, State const& state, Context const&, segmented_fold_fun const& fun)
+            {
+                return fusion::fold(seq, state, fun.fun);
+            }
+        };
+    };
 }}}
 
 namespace boost { namespace fusion

include/boost/fusion/algorithm/iteration/ext_/for_each_s.hpp

@@ -16,22 +16,25 @@ namespace boost { namespace fusion { namespace detail
     template <typename Fun>
     struct segmented_for_each_fun
     {
-        typedef result<void, continue_> result_type;
-
         explicit segmented_for_each_fun(Fun const& f)
           : fun(f)
         {}
 
-        template <typename Sequence, typename State, typename Context>
-        result_type operator()(Sequence& seq, State const&, Context const&) const
-        {
-            fusion::for_each(seq, fun);
-            return void_();
-        }
-
         Fun const& fun;
-    };
 
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef void_ type;
+            typedef mpl::true_ continue_type;
+
+            static type call(Sequence& seq, State const&, Context const&, segmented_for_each_fun const& fun)
+            {
+                fusion::for_each(seq, fun.fun);
+                return void_();
+            }
+        };
+    };
 }}}
 
 namespace boost { namespace fusion

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

@@ -7,7 +7,8 @@
 #if !defined(BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED)
 #define BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED
 
-#include <boost/type_traits/remove_const.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>
@@ -18,63 +19,46 @@ namespace boost { namespace fusion { namespace detail
     template <typename T>
     struct segmented_find_fun
     {
-        template <typename Sig>
+        template <typename Sequence, typename State, typename Context>
-        struct result;
+        struct apply
-
-        template <typename This, typename Sequence, typename State, typename Context>
-        struct result<This(Sequence&, State&, Context&)>
         {
             typedef
                 typename result_of::find<Sequence, T>::type
             iterator_type;
 
-            typedef
-                typename result_of::make_segmented_iterator<
-                    iterator_type
-                  , typename remove_const<Context>::type
-                >::type
-            segmented_iterator_type;
-
-            typedef
-                typename mpl::if_<
-                    result_of::equal_to<
-                        iterator_type
-                      , typename result_of::end<Sequence>::type
-                    >
-                  , fusion::result<typename remove_const<State>::type, continue_>,  // NOT FOUND
-                    fusion::result<segmented_iterator_type, break_>                 // FOUND
-                >::type
-            type;
-        };
-
-        template <typename Sequence, typename State, typename Context>
-        typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
-        operator()(Sequence& seq, State const&state, Context const& context) const
-        {
             typedef
                 typename result_of::equal_to<
-                    typename result_of::find<Sequence, T>::type
+                    iterator_type
                   , typename result_of::end<Sequence>::type
                 >::type
-            not_found;
+            continue_type;
 
-            return call(seq, state, context, not_found());
+            typedef
-        }
+                typename mpl::eval_if<
+                    continue_type
+                  , mpl::identity<State>
+                  , result_of::make_segmented_iterator<
+                        iterator_type
+                      , Context
+                    >
+                >::type
+            type;
 
-    private:
+            static type call(Sequence& seq, State const&state, Context const& context, segmented_find_fun)
-        template <typename Sequence, typename State, typename Context>
+            {
-        typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
+                return call_impl(seq, state, context, continue_type());
-        call(Sequence&, State const&state, Context const&, mpl::true_) const
+            }
-        {
-            return state;
-        }
 
-        template <typename Sequence, typename State, typename Context>
+            static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
-        typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
+            {
-        call(Sequence& seq, State const&, Context const& context, mpl::false_) const
+                return state;
-        {
+            }
-            return fusion::make_segmented_iterator(fusion::find<T>(seq), context);
+
-        }
+            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>

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

@@ -7,9 +7,8 @@
 #if !defined(BOOST_FUSION_SEGMENTED_FIND_IF_HPP_INCLUDED)
 #define BOOST_FUSION_SEGMENTED_FIND_IF_HPP_INCLUDED
 
-#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/eval_if.hpp>
-#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/identity.hpp>
-#include <boost/type_traits/remove_const.hpp>
 #include <boost/fusion/algorithm/query/find_if_fwd.hpp>
 #include <boost/fusion/iterator/equal_to.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
@@ -20,63 +19,46 @@ namespace boost { namespace fusion { namespace detail
     template <typename Pred>
     struct segmented_find_if_fun
     {
-        template <typename Sig>
+        template <typename Sequence, typename State, typename Context>
-        struct result;
+        struct apply
-
-        template <typename This, typename Sequence, typename State, typename Context>
-        struct result<This(Sequence&, State&, Context&)>
         {
             typedef
                 typename result_of::find_if<Sequence, Pred>::type
             iterator_type;
 
-            typedef
-                typename result_of::make_segmented_iterator<
-                    iterator_type
-                  , typename remove_const<Context>::type
-                >::type
-            segmented_iterator_type;
-
-            typedef
-                typename mpl::if_<
-                    result_of::equal_to<
-                        iterator_type
-                      , typename result_of::end<Sequence>::type
-                    >
-                  , fusion::result<typename remove_const<State>::type, continue_>, // NOT FOUND
-                    fusion::result<segmented_iterator_type, break_>                // FOUND
-                >::type
-            type;
-        };
-
-        template <typename Sequence, typename State, typename Context>
-        typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
-        operator()(Sequence& seq, State const& state, Context const& context) const
-        {
             typedef
                 typename result_of::equal_to<
-                    typename result_of::find_if<Sequence, Pred>::type
+                    iterator_type
                   , typename result_of::end<Sequence>::type
                 >::type
-            not_found;
+            continue_type;
 
-            return call(seq, state, context, not_found());
+            typedef
-        }
+                typename mpl::eval_if<
+                    continue_type
+                  , mpl::identity<State>
+                  , result_of::make_segmented_iterator<
+                        iterator_type
+                      , Context
+                    >
+                >::type
+            type;
 
-    private:
+            static type call(Sequence& seq, State const&state, Context const& context, segmented_find_if_fun)
-        template <typename Sequence, typename State, typename Context>
+            {
-        typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
+                return call_impl(seq, state, context, continue_type());
-        call(Sequence&, State const& state, Context const&, mpl::true_) const
+            }
-        {
-            return state;
-        }
 
-        template <typename Sequence, typename State, typename Context>
+            static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
-        typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
+            {
-        call(Sequence& seq, State const&, Context const& context, mpl::false_) const
+                return state;
-        {
+            }
-            return fusion::make_segmented_iterator(fusion::find_if<Pred>(seq), context);
+
-        }
+            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>

include/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp

@@ -24,30 +24,8 @@ namespace boost { namespace fusion { namespace detail
 {
     struct segmented_begin_fun
     {
-        template <typename Sig>
-        struct result;
-    
-        template <typename This, typename Sequence, typename State, typename Context>
-        struct result<This(Sequence&, State&, Context&)>
-        {
-            typedef
-                iterator_range<
-                    typename fusion::result_of::begin<Sequence>::type
-                  , typename fusion::result_of::end<Sequence>::type
-                >
-            range_type;
-
-            typedef
-                fusion::result<
-                    cons<range_type, typename remove_const<Context>::type>
-                  , fusion::break_
-                >
-            type;
-        };
-
         template <typename Sequence, typename State, typename Context>
-        typename result<segmented_begin_fun(Sequence&, State const&, Context const&)>::type
+        struct apply
-        operator()(Sequence& seq, State const&, Context const& context) const
         {
             typedef
                 iterator_range<
@@ -56,8 +34,14 @@ namespace boost { namespace fusion { namespace detail
                 >
             range_type;
 
-            return cons<range_type, Context>(range_type(fusion::begin(seq), fusion::end(seq)), context);
+            typedef cons<range_type, Context> type;
-        }
+            typedef mpl::false_ continue_type;
+
+            static type call(Sequence& seq, State const&, Context const& context, segmented_begin_fun)
+            {
+                return type(range_type(fusion::begin(seq), fusion::end(seq)), context);
+            }
+        };
     };
 
     template <typename Sequence, typename Stack, bool IsSegmented = traits::is_segmented<Sequence>::type::value>
@@ -70,17 +54,17 @@ namespace boost { namespace fusion { namespace detail
         typedef
             segmented_fold_until_impl<
                 Sequence
-              , result<typename end_impl::type, continue_>
+              , typename end_impl::type
               , Stack
               , segmented_begin_fun
             >
         fold_impl;
 
-        typedef typename fold_impl::type::value_type type;
+        typedef typename fold_impl::type type;
 
         static type call(Sequence& seq, Stack const& stack)
         {
-            return fold_impl::call(seq, end_impl::call(seq, stack), stack, segmented_begin_fun()).value;
+            return fold_impl::call(seq, end_impl::call(seq, stack), stack, segmented_begin_fun());
         }
     };
 

include/boost/fusion/support/detail/segmented_fold_until_impl.hpp

@@ -75,46 +75,6 @@ namespace boost { namespace fusion
         return type(cons<range_type, Context>(range_type(cur, fusion::end(*context.car.first)), context));
     }
 
-    typedef mpl::true_  continue_;
-    typedef mpl::false_ break_;
-
-    template <typename Value, typename Continue>
-    struct result
-    {
-        typedef Value value_type;
-        typedef Continue continue_type;
-
-        result(Value const& val)
-          : value(val)
-        {}
-
-        value_type value;
-    };
-
-    template <typename Continue>
-    struct result<void, Continue>
-    {
-        typedef void_ value_type;
-        typedef Continue continue_type;
-
-        result(void_ const&)
-        {}
-
-        value_type value;
-    };
-
-    template <typename Value>
-    result<Value, continue_> make_result_continue(Value const& val)
-    {
-        return result<Value, continue_>(val);
-    }
-
-    template <typename Value>
-    result<Value, break_> make_result_break(Value const& val)
-    {
-        return result<Value, break_>(val);
-    }
-
     namespace detail
     {
         template <
@@ -125,7 +85,8 @@ namespace boost { namespace fusion
           , typename Fun
           , bool IsEmpty = result_of::empty<
                 typename result_of::value_of<Begin>::type
-            >::type::value>
+            >::type::value
+        >
         struct segmented_fold_until_iterate_skip_empty;
 
         template <
@@ -134,7 +95,8 @@ namespace boost { namespace fusion
           , typename State
           , typename Context
           , typename Fun
-          , bool IsDone = result_of::equal_to<Begin, End>::type::value>
+          , bool IsDone = result_of::equal_to<Begin, End>::type::value
+        >
         struct segmented_fold_until_iterate;
 
         template <
@@ -142,7 +104,8 @@ namespace boost { namespace fusion
           , typename State
           , typename Context
           , typename Fun
-          , bool IsSegmented = traits::is_segmented<Sequence>::type::value>
+          , bool IsSegmented = traits::is_segmented<Sequence>::type::value
+        >
         struct segmented_fold_until_impl;
 
         template <typename Segments, typename State, typename Context, typename Fun>
@@ -187,7 +150,8 @@ namespace boost { namespace fusion
           , typename State
           , typename Context
           , typename Fun
-          , bool IsSegmented>
+          , bool IsSegmented
+        >
         struct segmented_fold_until_impl
         {
             typedef
@@ -204,6 +168,7 @@ namespace boost { namespace fusion
             impl;
 
             typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
 
             static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
             {
@@ -215,20 +180,20 @@ namespace boost { namespace fusion
             typename Sequence
           , typename State
           , typename Context
-          , typename Fun>
+          , typename Fun
+        >
         struct segmented_fold_until_impl<Sequence, State, Context, Fun, false>
         {
             typedef
-                typename boost::result_of<Fun(
+                typename Fun::template apply<Sequence, State, Context>
-                    Sequence&
+            apply_type;
-                  , typename add_reference<typename add_const<typename State::value_type>::type>::type
+
-                  , Context const&
+            typedef typename apply_type::type type;
-                )>::type
+            typedef typename apply_type::continue_type continue_type;
-            type;
+
-            
             static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
             {
-                return fun(seq, state.value, context);
+                return apply_type::call(seq, state, context, fun);
             }
         };
 
@@ -246,6 +211,12 @@ namespace boost { namespace fusion
         //  }
         //}
 
+        template <typename Apply>
+        struct continue_wrap
+        {
+            typedef typename Apply::continue_type type;
+        };
+
         template <typename Begin, typename End, typename State, typename Context, typename Fun, bool IsEmpty>
         struct segmented_fold_until_iterate_skip_empty
         {
@@ -287,16 +258,24 @@ namespace boost { namespace fusion
 
             typedef
                 typename mpl::eval_if<
-                    typename next_state_type::continue_type
+                    typename fold_recurse_impl::continue_type
                   , next_iteration_impl
                   , mpl::identity<next_state_type>
                 >::type
             type;
 
+            typedef
+                typename mpl::eval_if<
+                    typename fold_recurse_impl::continue_type
+                  , continue_wrap<next_iteration_impl>
+                  , mpl::identity<mpl::false_>
+                >::type
+            continue_type;
+
             static type call(Begin const& beg, End const& end, State const& state
                            , Context const& context, Fun const& fun)
             {
-                return call(beg, end, state, context, fun, typename next_state_type::continue_type());
+                return call(beg, end, state, context, fun, typename fold_recurse_impl::continue_type());
             }
 
             static type call(Begin const& beg, End const& end, State const& state
@@ -339,6 +318,7 @@ namespace boost { namespace fusion
             impl;
             
             typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
 
             static type call(Begin const& beg, End const& end, State const& state
                            , Context const& context, Fun const& fun)
@@ -355,6 +335,7 @@ namespace boost { namespace fusion
             impl;
             
             typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
 
             static type call(Begin const& beg, End const& end, State const& state
                            , Context const& context, Fun const& fun)
@@ -367,6 +348,7 @@ namespace boost { namespace fusion
         struct segmented_fold_until_iterate<Begin, End, State, Context, Fun, true>
         {
             typedef State type;
+            typedef mpl::true_ continue_type;
 
             static type call(Begin const&, End const&, State const& state
                            , Context const&, Fun const&)
@@ -389,6 +371,7 @@ namespace boost { namespace fusion
             impl;
 
             typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
 
             static type call(Segments& segs, State const& state, Context const& context, Fun const& fun)
             {

include/boost/fusion/support/segmented_fold_until.hpp

@@ -31,14 +31,14 @@ namespace boost { namespace fusion
             typedef
                 detail::segmented_fold_until_impl<
                     Sequence
-                  , result<State, continue_>
+                  , State
                   , fusion::nil
                   , Fun
                 >
             filter;
 
             typedef
-                typename filter::type::value_type
+                typename filter::type
             type;
         };
     }
@@ -55,7 +55,7 @@ namespace boost { namespace fusion
             typename result_of::segmented_fold_until<Sequence, State, Fun>::filter
         filter;
         
-        return filter::call(seq, state, fusion::nil(), fun).value;
+        return filter::call(seq, state, fusion::nil(), fun);
     }
 
     template <typename Sequence, typename State, typename Fun>
@@ -66,7 +66,7 @@ namespace boost { namespace fusion
             typename result_of::segmented_fold_until<Sequence const, State, Fun>::filter
         filter;
         
-        return filter::call(seq, state, fusion::nil(), fun).value;
+        return filter::call(seq, state, fusion::nil(), fun);
     }
 }}