Edit: /usr/include/boost/hof/repeat_while.hpp (5154B)
/*=============================================================================
Copyright (c) 2015 Paul Fultz II
repeat_while.h
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)
==============================================================================*/
#ifndef BOOST_HOF_GUARD_REPEAT_WHILE_H
#define BOOST_HOF_GUARD_REPEAT_WHILE_H
/// repeat_while
/// ======
///
/// Description
/// -----------
///
/// The `repeat_while` function decorator will repeatedly apply a function while
/// the predicate returns a boolean that is true. If the predicate returns an
/// `IntergralConstant` then the predicate is only evaluated at compile-time.
///
///
/// Synopsis
/// --------
///
/// template
/// constexpr auto repeat_while(Predicate predicate);
///
/// Requirements
/// ------------
///
/// Predicate must be:
///
/// * [ConstFunctionObject](ConstFunctionObject)
/// * MoveConstructible
///
/// Example
/// -------
///
/// #include
/// #include
///
/// struct increment
/// {
/// template
/// constexpr std::integral_constant operator()(T) const
/// {
/// return std::integral_constant();
/// }
/// };
///
/// struct not_6
/// {
/// template
/// constexpr std::integral_constant
/// operator()(T) const
/// {
/// return std::integral_constant();
/// }
/// };
///
/// typedef std::integral_constant one;
/// typedef std::integral_constant six;
///
/// int main() {
/// auto increment_until_6 = boost::hof::repeat_while(not_6())(increment());
/// static_assert(std::is_same::value, "Error");
/// }
///
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace hof { namespace detail {
template
struct compute_predicate
{
typedef decltype(std::declval()(std::declval()...)) type;
};
template
struct while_repeater
{
template
constexpr BOOST_HOF_SFINAE_RESULT(while_repeater<
compute_predicate...>::type>::type::value
>, id_, id_, result_of...>)
operator()(const F& f, const P& p, Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS
(
while_repeater<
compute_predicate::type::value
>()(f, p, f(BOOST_HOF_FORWARD(Ts)(xs)...))
);
};
template<>
struct while_repeater
{
template
constexpr T operator()(const F&, const P&, T&& x) const
BOOST_HOF_RETURNS_DEDUCE_NOEXCEPT(x)
{
return x;
}
};
struct repeat_while_constant_decorator
{
template
constexpr auto operator()(const P& p, const F& f, Ts&&... xs) const BOOST_HOF_RETURNS
(
detail::while_repeater<
detail::compute_predicate()(BOOST_HOF_FORWARD(Ts)(xs)...))>::type::value
>()
(
f,
p,
BOOST_HOF_FORWARD(Ts)(xs)...
)
);
};
template
struct repeat_while_integral_decorator
{
template>
constexpr auto operator()(const P& p, const F& f, T&& x, Ts&&... xs) const BOOST_HOF_RETURNS
(
(p(x, BOOST_HOF_FORWARD(Ts)(xs)...)) ?
Self()(
p,
f,
f(x, BOOST_HOF_FORWARD(Ts)(xs)...)
) :
BOOST_HOF_FORWARD(T)(x)
);
};
template<>
struct repeat_while_integral_decorator<0>
{
template>
#if BOOST_HOF_HAS_RELAXED_CONSTEXPR
constexpr
#endif
auto operator()(const P& p, const F& f, T x) const
BOOST_HOF_RETURNS_DEDUCE_NOEXCEPT((p(x), f(x)))
-> decltype(f(x))
{
while(p(x))
{
// TODO: Should move?
x = f(x);
}
return x;
}
};
}
#if BOOST_HOF_HAS_RELAXED_CONSTEXPR
#define BOOST_HOF_REPEAT_WHILE_CONSTEXPR_DEPTH 1
#else
#define BOOST_HOF_REPEAT_WHILE_CONSTEXPR_DEPTH BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH
#endif
BOOST_HOF_DECLARE_STATIC_VAR(repeat_while, decorate_adaptor<
boost::hof::first_of_adaptor<
detail::repeat_while_constant_decorator,
detail::repeat_while_integral_decorator
>
>);
}} // namespace boost::hof
#endif