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

make find and find_if algorithms segment-aware, stylistic consistency tweaks

Browse Source 
[SVN r73892]
This commit is contained in:
Eric Niebler
2011-08-18 17:12:05 +00:00
parent 528ad04fdb
commit 9dd14c435e
27 changed files with 623 additions and 539 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -12,18 +12,18 @@
namespace boost { namespace fusion { namespace detail
{
template<typename Fun>
template <typename Fun>
struct segmented_fold_fun
{
template<typename Sig>
template <typename Sig>
struct result;
template<typename This, typename Range, typename State, typename Context>
struct result<This(Range&, State&, Context&)>
template <typename This, typename Sequence, typename State, typename Context>
struct result<This(Sequence&, State&, Context&)>
{
typedef
fusion::result<
typename result_of::fold<Range, State, Fun>::type,
typename result_of::fold<Sequence, State, Fun>::type,
continue_
>
type;
@ -33,11 +33,11 @@ namespace boost { namespace fusion { namespace detail
: fun(f)
{}
template<typename Range, typename State, typename Context>
typename result<segmented_fold_fun(Range&, State const&, Context const&)>::type
operator()(Range& rng, State const& state, Context const&) const
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(rng, state, fun);
return fusion::fold(seq, state, fun);
}
Fun const& fun;

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

@ -13,7 +13,7 @@
namespace boost { namespace fusion { namespace detail
{
template<typename Fun>
template <typename Fun>
struct segmented_for_each_fun
{
typedef result<void, continue_> result_type;
@ -22,10 +22,10 @@ namespace boost { namespace fusion { namespace detail
: fun(f)
{}
template<typename Range, typename State, typename Context>
result_type operator()(Range& rng, State const&, Context const&) const
template <typename Sequence, typename State, typename Context>
result_type operator()(Sequence& seq, State const&, Context const&) const
{
fusion::for_each(rng, fun);
fusion::for_each(seq, fun);
return void_();
}

36
include/boost/fusion/algorithm/query/detail/find_if.hpp
View File

@ -9,19 +9,18 @@
#if !defined(FUSION_FIND_IF_05052005_1107)
#define FUSION_FIND_IF_05052005_1107
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/lambda.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/iterator/advance.hpp>
#include <boost/fusion/iterator/distance.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/support/category_of.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
namespace boost { namespace fusion {
struct random_access_traversal_tag;
@ -222,10 +221,31 @@ namespace detail
template <typename Iterator>
static type
call(Iterator const& iter)
iter_call(Iterator const& iter)
{
return choose_call(iter, typename traits::category_of<Iterator>::type());
}
template <typename Sequence>
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;
};
}}}

106
include/boost/fusion/algorithm/query/detail/segmented_find.hpp Normal file
View File

@ -0,0 +1,106 @@
/*=============================================================================
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/type_traits/remove_const.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 Sig>
struct result;
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
, typename result_of::end<Sequence>::type
>::type
not_found;
return call(seq, state, context, not_found());
}
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;
}
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);
}
};
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;
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

108
include/boost/fusion/algorithm/query/detail/segmented_find_if.hpp Normal file
View File

@ -0,0 +1,108 @@
/*=============================================================================
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/utility/enable_if.hpp>
#include <boost/type_traits/is_const.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>
#include <boost/fusion/support/segmented_fold_until.hpp>
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&)>
{
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
, typename result_of::end<Sequence>::type
>::type
not_found;
return call(seq, state, context, not_found());
}
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;
}
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);
}
};
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;
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

114
include/boost/fusion/algorithm/query/ext_/find_if_s.hpp
View File

@ -1,114 +0,0 @@
/*=============================================================================
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_S_HPP_INCLUDED)
#define BOOST_FUSION_FIND_IF_S_HPP_INCLUDED
#include <boost/type_traits/remove_const.hpp>
#include <boost/fusion/algorithm/query/find_if.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 Sig>
struct result;
template<typename This, typename Range, typename State, typename Context>
struct result<This(Range&, State&, Context&)>
{
typedef
typename result_of::find_if<Range, 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<Range>::type
>,
fusion::result<typename remove_const<State>::type, continue_>, // NOT FOUND
fusion::result<segmented_iterator_type, break_> // FOUND
>::type
type;
};
template<typename Range, typename State, typename Context>
typename result<segmented_find_if_fun(Range&, State const&, Context const&)>::type
operator()(Range& rng, State const& state, Context const& context) const
{
typedef
typename result_of::equal_to<
typename result_of::find_if<Range, Pred>::type,
typename result_of::end<Range>::type
>::type
not_found;
return call(rng, state, context, not_found());
}
private:
template<typename Range, typename State, typename Context>
typename result<segmented_find_if_fun(Range&, State const&, Context const&)>::type
call(Range&, State const& state, Context const&, mpl::true_) const
{
return state;
}
template<typename Range, typename State, typename Context>
typename result<segmented_find_if_fun(Range&, State const&, Context const&)>::type
call(Range& rng, State const&, Context const& context, mpl::false_) const
{
return fusion::make_segmented_iterator(fusion::find_if<Pred>(rng), context);
}
};
}}}
namespace boost { namespace fusion
{
namespace result_of
{
template <typename Sequence, typename Pred>
struct find_if_s
: result_of::segmented_fold_until<
Sequence,
typename result_of::end<Sequence>::type,
detail::segmented_find_if_fun<Pred> >
{};
}
template <typename Pred, typename Sequence>
typename result_of::find_if_s<Sequence, Pred>::type
find_if_s(Sequence& seq)
{
return fusion::segmented_fold_until(
seq,
fusion::end(seq),
detail::segmented_find_if_fun<Pred>());
}
template <typename Pred, typename Sequence>
typename result_of::find_if_s<Sequence const, Pred>::type
find_if_s(Sequence const& seq)
{
return fusion::segmented_fold_until(
seq, fusion::end(seq),
detail::segmented_find_if_fun<Pred>());
}
}}
#endif

115
include/boost/fusion/algorithm/query/ext_/find_s.hpp
View File

@ -1,115 +0,0 @@
/*=============================================================================
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_S_HPP_INCLUDED)
#define BOOST_FUSION_FIND_S_HPP_INCLUDED
#include <boost/type_traits/remove_const.hpp>
#include <boost/fusion/algorithm/query/find.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 Sig>
struct result;
template<typename This, typename Range, typename State, typename Context>
struct result<This(Range&, State&, Context&)>
{
typedef
typename result_of::find<Range, 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<Range>::type
>,
fusion::result<typename remove_const<State>::type, continue_>, // NOT FOUND
fusion::result<segmented_iterator_type, break_> // FOUND
>::type
type;
};
template<typename Range, typename State, typename Context>
typename result<segmented_find_fun(Range&, State const&, Context const&)>::type
operator()(Range& rng, State const&state, Context const& context) const
{
typedef
typename result_of::equal_to<
typename result_of::find<Range, T>::type,
typename result_of::end<Range>::type
>::type
not_found;
return call(rng, state, context, not_found());
}
private:
template<typename Range, typename State, typename Context>
typename result<segmented_find_fun(Range&, State const&, Context const&)>::type
call(Range&, State const&state, Context const&, mpl::true_) const
{
return state;
}
template<typename Range, typename State, typename Context>
typename result<segmented_find_fun(Range&, State const&, Context const&)>::type
call(Range& rng, State const&, Context const& context, mpl::false_) const
{
return fusion::make_segmented_iterator(fusion::find<T>(rng), context);
}
};
}}}
namespace boost { namespace fusion
{
namespace result_of
{
template <typename Sequence, typename T>
struct find_s
: result_of::segmented_fold_until<
Sequence,
typename result_of::end<Sequence>::type,
detail::segmented_find_fun<T> >
{};
}
template <typename T, typename Sequence>
typename result_of::find_s<Sequence, T>::type
find_s(Sequence& seq)
{
return fusion::segmented_fold_until(
seq,
fusion::end(seq),
detail::segmented_find_fun<T>());
}
template <typename T, typename Sequence>
typename result_of::find_s<Sequence const, T>::type
find_s(Sequence const& seq)
{
return fusion::segmented_fold_until(
seq,
fusion::end(seq),
detail::segmented_find_fun<T>());
}
}}
#endif

35
include/boost/fusion/algorithm/query/find.hpp
View File

@ -1,5 +1,6 @@
/*=============================================================================
Copyright (c) 2001-2006 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)
@ -7,13 +8,15 @@
#if !defined(FUSION_FIND_05052005_1107)
#define FUSION_FIND_05052005_1107
#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
#include <boost/fusion/algorithm/query/detail/find_if.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.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>
@ -22,17 +25,14 @@ namespace boost { namespace fusion
{
namespace result_of
{
template <
typename Sequence
, typename T
>
template <typename Sequence, typename T>
struct find
{
typedef
detail::static_find_if<
typename result_of::begin<Sequence>::type
, typename result_of::end<Sequence>::type
, is_same<
: 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>
@ -41,10 +41,8 @@ namespace boost { namespace fusion
, T
>
>
filter;
typedef typename filter::type type;
};
>::type
{};
}
template <typename T, typename Sequence>
@ -56,7 +54,7 @@ namespace boost { namespace fusion
find(Sequence& seq)
{
typedef typename result_of::find<Sequence, T>::filter filter;
return filter::call(fusion::begin(seq));
return filter::call(seq);
}
template <typename T, typename Sequence>
@ -64,9 +62,8 @@ namespace boost { namespace fusion
find(Sequence const& seq)
{
typedef typename result_of::find<Sequence const, T>::filter filter;
return filter::call(fusion::begin(seq));
return filter::call(seq);
}
}}
#endif

34
include/boost/fusion/algorithm/query/find_fwd.hpp Normal file
View File

@ -0,0 +1,34 @@
/*=============================================================================
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/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>
inline typename
lazy_disable_if<
is_const<Sequence>
, result_of::find<Sequence, T>
>::type const
find(Sequence& seq);
template <typename T, typename Sequence>
inline typename result_of::find<Sequence const, T>::type const
find(Sequence const& seq);
}}
#endif

38
include/boost/fusion/algorithm/query/find_if.hpp
View File

@ -1,5 +1,6 @@
/*=============================================================================
Copyright (c) 2001-2006 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)
@ -7,15 +8,17 @@
#if !defined(FUSION_FIND_IF_05052005_1108)
#define FUSION_FIND_IF_05052005_1108
#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
#include <boost/fusion/algorithm/query/detail/find_if.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/algorithm/query/detail/segmented_find_if.hpp>
#include <boost/fusion/iterator/value_of.hpp>
#include <boost/mpl/bind.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/quote.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
{
@ -23,20 +26,18 @@ namespace boost { namespace fusion
{
template <typename Sequence, typename Pred>
struct find_if
{
typedef
detail::static_find_if<
typename result_of::begin<Sequence>::type
, typename result_of::end<Sequence>::type
, mpl::bind1<
: 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>
, mpl::bind1<mpl::quote1<value_of>, mpl::_1>
>
>
filter;
typedef typename filter::type type;
};
>::type
{};
}
template <typename Pred, typename Sequence>
@ -48,7 +49,7 @@ namespace boost { namespace fusion
find_if(Sequence& seq)
{
typedef typename result_of::find_if<Sequence, Pred>::filter filter;
return filter::call(fusion::begin(seq));
return filter::call(seq);
}
template <typename Pred, typename Sequence>
@ -56,9 +57,8 @@ namespace boost { namespace fusion
find_if(Sequence const& seq)
{
typedef typename result_of::find_if<Sequence const, Pred>::filter filter;
return filter::call(fusion::begin(seq));
return filter::call(seq);
}
}}
#endif

35
include/boost/fusion/algorithm/query/find_if_fwd.hpp Normal file
View File

@ -0,0 +1,35 @@
/*=============================================================================
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/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>
typename
lazy_disable_if<
is_const<Sequence>
, result_of::find_if<Sequence, Pred>
>::type
find_if(Sequence& seq);
template <typename Pred, typename Sequence>
typename result_of::find_if<Sequence const, Pred>::type const
find_if(Sequence const& seq);
}}
#endif