You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
402 lines
13 KiB
402 lines
13 KiB
/*=============================================================================
|
|
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_FOLD_UNTIL_IMPL_HPP_INCLUDED)
|
|
#define BOOST_FUSION_SEGMENTED_FOLD_UNTIL_IMPL_HPP_INCLUDED
|
|
|
|
#include <boost/fusion/support/config.hpp>
|
|
#include <boost/mpl/bool.hpp>
|
|
#include <boost/mpl/eval_if.hpp>
|
|
#include <boost/mpl/identity.hpp>
|
|
#include <boost/utility/result_of.hpp>
|
|
#include <boost/type_traits/add_const.hpp>
|
|
#include <boost/type_traits/remove_reference.hpp>
|
|
|
|
#include <boost/fusion/support/void.hpp>
|
|
#include <boost/fusion/container/list/cons_fwd.hpp>
|
|
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
|
#include <boost/fusion/iterator/equal_to.hpp>
|
|
#include <boost/fusion/iterator/deref.hpp>
|
|
#include <boost/fusion/iterator/next.hpp>
|
|
#include <boost/fusion/support/is_segmented.hpp>
|
|
#include <boost/fusion/sequence/intrinsic/segments.hpp>
|
|
|
|
// fun(seq, state, context)
|
|
// seq: a non-segmented range
|
|
// state: the state of the fold so far
|
|
// context: the path to the current range
|
|
//
|
|
// returns: (state', fcontinue)
|
|
|
|
namespace boost { namespace fusion
|
|
{
|
|
template <typename First, typename Last>
|
|
struct iterator_range;
|
|
|
|
template <typename Context>
|
|
struct segmented_iterator;
|
|
|
|
namespace result_of
|
|
{
|
|
template <typename Cur, typename Context>
|
|
struct make_segmented_iterator
|
|
{
|
|
typedef
|
|
iterator_range<
|
|
Cur
|
|
, typename result_of::end<
|
|
typename remove_reference<
|
|
typename add_const<
|
|
typename result_of::deref<
|
|
typename Context::car_type::begin_type
|
|
>::type
|
|
>::type
|
|
>::type
|
|
>::type
|
|
>
|
|
range_type;
|
|
|
|
typedef
|
|
segmented_iterator<cons<range_type, Context> >
|
|
type;
|
|
};
|
|
}
|
|
|
|
template <typename Cur, typename Context>
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
inline typename result_of::make_segmented_iterator<Cur, Context>::type
|
|
make_segmented_iterator(Cur const& cur, Context const& context)
|
|
{
|
|
typedef result_of::make_segmented_iterator<Cur, Context> impl_type;
|
|
typedef typename impl_type::type type;
|
|
typedef typename impl_type::range_type range_type;
|
|
return type(cons<range_type, Context>(range_type(cur, fusion::end(*context.car.first)), context));
|
|
}
|
|
|
|
namespace detail
|
|
{
|
|
template <
|
|
typename Begin
|
|
, typename End
|
|
, typename State
|
|
, typename Context
|
|
, typename Fun
|
|
, bool IsEmpty
|
|
>
|
|
struct segmented_fold_until_iterate_skip_empty;
|
|
|
|
template <
|
|
typename Begin
|
|
, typename End
|
|
, typename State
|
|
, typename Context
|
|
, typename Fun
|
|
, bool IsDone = result_of::equal_to<Begin, End>::type::value
|
|
>
|
|
struct segmented_fold_until_iterate;
|
|
|
|
template <
|
|
typename Sequence
|
|
, typename State
|
|
, typename Context
|
|
, typename Fun
|
|
, bool IsSegmented = traits::is_segmented<Sequence>::type::value
|
|
>
|
|
struct segmented_fold_until_impl;
|
|
|
|
template <typename Segments, typename State, typename Context, typename Fun>
|
|
struct segmented_fold_until_on_segments;
|
|
|
|
//auto push_context(cur, end, context)
|
|
//{
|
|
// return push_back(context, segment_sequence(iterator_range(cur, end)));
|
|
//}
|
|
|
|
template <typename Cur, typename End, typename Context>
|
|
struct push_context
|
|
{
|
|
typedef iterator_range<Cur, End> range_type;
|
|
typedef cons<range_type, Context> type;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Cur const& cur, End const& end, Context const& context)
|
|
{
|
|
return cons<range_type, Context>(range_type(cur, end), context);
|
|
}
|
|
};
|
|
|
|
//auto make_segmented_iterator(cur, end, context)
|
|
//{
|
|
// return segmented_iterator(push_context(cur, end, context));
|
|
//}
|
|
//
|
|
//auto segmented_fold_until_impl(seq, state, context, fun)
|
|
//{
|
|
// if (is_segmented(seq))
|
|
// {
|
|
// segmented_fold_until_on_segments(segments(seq), state, context, fun);
|
|
// }
|
|
// else
|
|
// {
|
|
// return fun(seq, state, context);
|
|
// }
|
|
//}
|
|
|
|
template <
|
|
typename Sequence
|
|
, typename State
|
|
, typename Context
|
|
, typename Fun
|
|
, bool IsSegmented
|
|
>
|
|
struct segmented_fold_until_impl
|
|
{
|
|
typedef
|
|
segmented_fold_until_on_segments<
|
|
typename remove_reference<
|
|
typename add_const<
|
|
typename result_of::segments<Sequence>::type
|
|
>::type
|
|
>::type
|
|
, State
|
|
, Context
|
|
, Fun
|
|
>
|
|
impl;
|
|
|
|
typedef typename impl::type type;
|
|
typedef typename impl::continue_type continue_type;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
|
|
{
|
|
return impl::call(fusion::segments(seq), state, context, fun);
|
|
}
|
|
};
|
|
|
|
template <
|
|
typename Sequence
|
|
, typename State
|
|
, typename Context
|
|
, typename Fun
|
|
>
|
|
struct segmented_fold_until_impl<Sequence, State, Context, Fun, false>
|
|
{
|
|
typedef
|
|
typename Fun::template apply<Sequence, State, Context>
|
|
apply_type;
|
|
|
|
typedef typename apply_type::type type;
|
|
typedef typename apply_type::continue_type continue_type;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
|
|
{
|
|
return apply_type::call(seq, state, context, fun);
|
|
}
|
|
};
|
|
|
|
//auto segmented_fold_until_on_segments(segs, state, context, fun)
|
|
//{
|
|
// auto cur = begin(segs), end = end(segs);
|
|
// for (; cur != end; ++cur)
|
|
// {
|
|
// if (empty(*cur))
|
|
// continue;
|
|
// auto context` = push_context(cur, end, context);
|
|
// state = segmented_fold_until_impl(*cur, state, context`, fun);
|
|
// if (!second(state))
|
|
// return state;
|
|
// }
|
|
//}
|
|
|
|
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
|
|
{
|
|
// begin != end and !empty(*begin)
|
|
typedef
|
|
push_context<Begin, End, Context>
|
|
push_context_impl;
|
|
|
|
typedef
|
|
typename push_context_impl::type
|
|
next_context_type;
|
|
|
|
typedef
|
|
segmented_fold_until_impl<
|
|
typename remove_reference<
|
|
typename add_const<
|
|
typename result_of::deref<Begin>::type
|
|
>::type
|
|
>::type
|
|
, State
|
|
, next_context_type
|
|
, Fun
|
|
>
|
|
fold_recurse_impl;
|
|
|
|
typedef
|
|
typename fold_recurse_impl::type
|
|
next_state_type;
|
|
|
|
typedef
|
|
segmented_fold_until_iterate<
|
|
typename result_of::next<Begin>::type
|
|
, End
|
|
, next_state_type
|
|
, Context
|
|
, Fun
|
|
>
|
|
next_iteration_impl;
|
|
|
|
typedef
|
|
typename mpl::eval_if<
|
|
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;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
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 fold_recurse_impl::continue_type());
|
|
}
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Begin const& beg, End const& end, State const& state
|
|
, Context const& context, Fun const& fun, mpl::true_) // continue
|
|
{
|
|
return next_iteration_impl::call(
|
|
fusion::next(beg)
|
|
, end
|
|
, fold_recurse_impl::call(
|
|
*beg
|
|
, state
|
|
, push_context_impl::call(beg, end, context)
|
|
, fun)
|
|
, context
|
|
, fun);
|
|
}
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Begin const& beg, End const& end, State const& state
|
|
, Context const& context, Fun const& fun, mpl::false_) // break
|
|
{
|
|
return fold_recurse_impl::call(
|
|
*beg
|
|
, state
|
|
, push_context_impl::call(beg, end, context)
|
|
, fun);
|
|
}
|
|
};
|
|
|
|
template <typename Begin, typename End, typename State, typename Context, typename Fun>
|
|
struct segmented_fold_until_iterate_skip_empty<Begin, End, State, Context, Fun, true>
|
|
{
|
|
typedef
|
|
segmented_fold_until_iterate<
|
|
typename result_of::next<Begin>::type
|
|
, End
|
|
, State
|
|
, Context
|
|
, Fun
|
|
>
|
|
impl;
|
|
|
|
typedef typename impl::type type;
|
|
typedef typename impl::continue_type continue_type;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Begin const& beg, End const& end, State const& state
|
|
, Context const& context, Fun const& fun)
|
|
{
|
|
return impl::call(fusion::next(beg), end, state, context, fun);
|
|
}
|
|
};
|
|
|
|
template <typename Begin, typename End, typename State, typename Context, typename Fun, bool IsDone>
|
|
struct segmented_fold_until_iterate
|
|
{
|
|
typedef
|
|
typename result_of::empty<
|
|
typename remove_reference<
|
|
typename result_of::deref<Begin>::type
|
|
>::type
|
|
>::type
|
|
empty_type;
|
|
|
|
typedef
|
|
segmented_fold_until_iterate_skip_empty<Begin, End, State, Context, Fun, empty_type::value>
|
|
impl;
|
|
|
|
typedef typename impl::type type;
|
|
typedef typename impl::continue_type continue_type;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Begin const& beg, End const& end, State const& state
|
|
, Context const& context, Fun const& fun)
|
|
{
|
|
return impl::call(beg, end, state, context, fun);
|
|
}
|
|
};
|
|
|
|
template <typename Begin, typename End, typename State, typename Context, typename Fun>
|
|
struct segmented_fold_until_iterate<Begin, End, State, Context, Fun, true>
|
|
{
|
|
typedef State type;
|
|
typedef mpl::true_ continue_type;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Begin const&, End const&, State const& state
|
|
, Context const&, Fun const&)
|
|
{
|
|
return state;
|
|
}
|
|
};
|
|
|
|
template <typename Segments, typename State, typename Context, typename Fun>
|
|
struct segmented_fold_until_on_segments
|
|
{
|
|
typedef
|
|
segmented_fold_until_iterate<
|
|
typename result_of::begin<Segments>::type
|
|
, typename result_of::end<Segments>::type
|
|
, State
|
|
, Context
|
|
, Fun
|
|
>
|
|
impl;
|
|
|
|
typedef typename impl::type type;
|
|
typedef typename impl::continue_type continue_type;
|
|
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
|
static type call(Segments& segs, State const& state, Context const& context, Fun const& fun)
|
|
{
|
|
return impl::call(fusion::begin(segs), fusion::end(segs), state, context, fun);
|
|
}
|
|
};
|
|
}
|
|
}}
|
|
|
|
#endif
|