feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

simplify segmented_fold_until interface

Browse Source 
[SVN r73898]
This commit is contained in:
Eric Niebler
2011-08-18 21:33:39 +00:00
parent 9dd14c435e
commit b8bb98a36b
7 changed files with 139 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
include/boost/fusion/algorithm/iteration/ext_/fold_s.hpp
View File

@ -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

17
include/boost/fusion/algorithm/iteration/ext_/for_each_s.hpp
View File

@ -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)
{}
Fun const& fun;
template <typename Sequence, typename State, typename Context>
result_type operator()(Sequence& seq, State const&, Context const&) const
struct apply
{
fusion::for_each(seq, fun);
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_();
}
Fun const& fun;
};
};
}}}
namespace boost { namespace fusion

56
include/boost/fusion/algorithm/query/detail/segmented_find.hpp
View File

@ -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,64 +19,47 @@ namespace boost { namespace fusion { namespace detail
template <typename T>
struct segmented_find_fun
{
template <typename Sig>
struct result;
template <typename This, typename Sequence, typename State, typename Context>
struct result<This(Sequence&, State&, Context&)>
template <typename Sequence, typename State, typename Context>
struct apply
{
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<
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
>
, 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
static type call(Sequence& seq, State const&state, Context const& context, segmented_find_fun)
{
typedef
typename result_of::equal_to<
typename result_of::find<Sequence, T>::type
, typename result_of::end<Sequence>::type
>::type
not_found;
return call(seq, state, context, not_found());
return call_impl(seq, state, context, continue_type());
}
private:
template <typename Sequence, typename State, typename Context>
typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
call(Sequence&, State const&state, Context const&, mpl::true_) const
static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
{
return state;
}
template <typename Sequence, typename State, typename Context>
typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
call(Sequence& seq, State const&, Context const& context, mpl::false_) const
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

58
include/boost/fusion/algorithm/query/detail/segmented_find_if.hpp
View File

@ -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/type_traits/is_const.hpp>
#include <boost/type_traits/remove_const.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>
@ -20,64 +19,47 @@ namespace boost { namespace fusion { namespace detail
template <typename Pred>
struct segmented_find_if_fun
{
template <typename Sig>
struct result;
template <typename This, typename Sequence, typename State, typename Context>
struct result<This(Sequence&, State&, Context&)>
template <typename Sequence, typename State, typename Context>
struct apply
{
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<
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
>
, 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
static type call(Sequence& seq, State const&state, Context const& context, segmented_find_if_fun)
{
typedef
typename result_of::equal_to<
typename result_of::find_if<Sequence, Pred>::type
, typename result_of::end<Sequence>::type
>::type
not_found;
return call(seq, state, context, not_found());
return call_impl(seq, state, context, continue_type());
}
private:
template <typename Sequence, typename State, typename Context>
typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
call(Sequence&, State const& state, Context const&, mpl::true_) const
static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
{
return state;
}
template <typename Sequence, typename State, typename Context>
typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
call(Sequence& seq, State const&, Context const& context, mpl::false_) const
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

38
include/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp
View File

@ -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
operator()(Sequence& seq, State const&, Context const& context) const
struct apply
{
typedef
iterator_range<
@ -56,9 +34,15 @@ 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>
struct segmented_begin_impl_aux
@ -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());
}
};

91
include/boost/fusion/support/detail/segmented_fold_until_impl.hpp
View File

@ -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(
Sequence&
, typename add_reference<typename add_const<typename State::value_type>::type>::type
, Context const&
)>::type
type;
typename Fun::template apply<Sequence, State, Context>
apply_type;
typedef typename apply_type::type type;
typedef typename apply_type::continue_type continue_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)
{

8
include/boost/fusion/support/segmented_fold_until.hpp
View File

@ -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);
}
}}