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

23
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)
{}
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

76
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,63 +19,46 @@ 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<
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:
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
{
return state;
}
static type call(Sequence& seq, State const&state, Context const& context, segmented_find_fun)
{
return call_impl(seq, state, context, continue_type());
}
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
{
return fusion::make_segmented_iterator(fusion::find<T>(seq), context);
}
static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
{
return state;
}
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>

78
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,63 +19,46 @@ 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<
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:
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
{
return state;
}
static type call(Sequence& seq, State const&state, Context const& context, segmented_find_if_fun)
{
return call_impl(seq, state, context, continue_type());
}
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
{
return fusion::make_segmented_iterator(fusion::find_if<Pred>(seq), context);
}
static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
{
return state;
}
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>