Edit: /usr/include/boost/hof/capture.hpp (5419B)
/*=============================================================================
Copyright (c) 2015 Paul Fultz II
capture.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_CAPTURE_H
#define BOOST_HOF_GUARD_CAPTURE_H
#include
#include
#include
#include
#include
#include
#include
/// capture
/// =======
///
/// Description
/// -----------
///
/// The `capture` function decorator is used to capture values in a function.
/// It provides more flexibility in capturing than the lambda capture list in
/// C++. It provides a way to do move and perfect capturing. The values
/// captured are prepended to the argument list of the function that will be
/// called.
///
/// Synopsis
/// --------
///
/// // Capture by decaying each value
/// template
/// constexpr auto capture(Ts&&... xs);
///
/// // Capture lvalues by reference and rvalue reference by reference
/// template
/// constexpr auto capture_forward(Ts&&... xs);
///
/// // Capture lvalues by reference and rvalues by value.
/// template
/// constexpr auto capture_basic(Ts&&... xs);
///
/// Semantics
/// ---------
///
/// assert(capture(xs...)(f)(ys...) == f(xs..., ys...));
///
///
/// Example
/// -------
///
/// #include
/// #include
///
/// struct sum_f
/// {
/// template
/// T operator()(T x, U y) const
/// {
/// return x+y;
/// }
/// };
///
/// int main() {
/// auto add_one = boost::hof::capture(1)(sum_f());
/// assert(add_one(2) == 3);
/// }
///
namespace boost { namespace hof {
namespace detail {
template
struct capture_invoke : detail::compressed_pair, Pack>, detail::function_result_type
{
typedef capture_invoke fit_rewritable1_tag;
typedef detail::compressed_pair, Pack> base;
BOOST_HOF_INHERIT_CONSTRUCTOR(capture_invoke, base)
template
constexpr const detail::callable_base& base_function(Ts&&... xs) const noexcept
{
return this->first(xs...);
}
template
constexpr const Pack& get_pack(Ts&&...xs) const noexcept
{
return this->second(xs...);
}
template
struct unpack_capture_failure
{
template
struct apply
{
typedef typename Failure::template of type;
};
};
struct capture_failure
{
template
struct apply
{
template
struct of
: Pack::template apply>::type
{};
};
};
struct failure
: failure_map>
{};
BOOST_HOF_RETURNS_CLASS(capture_invoke);
template
constexpr BOOST_HOF_SFINAE_RESULT
(
typename result_of,
result_of...>
>::type,
id_&&>
)
operator()(Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS
(
boost::hof::pack_join
(
BOOST_HOF_MANGLE_CAST(const Pack&)(BOOST_HOF_CONST_THIS->get_pack(xs...)),
boost::hof::pack_forward(BOOST_HOF_FORWARD(Ts)(xs)...)
)
(BOOST_HOF_RETURNS_C_CAST(detail::callable_base&&)(BOOST_HOF_CONST_THIS->base_function(xs...)))
);
};
template
struct capture_pack : Pack
{
BOOST_HOF_INHERIT_CONSTRUCTOR(capture_pack, Pack);
BOOST_HOF_RETURNS_CLASS(capture_pack);
// TODO: Should use rvalue ref qualifier
template
constexpr auto operator()(F f) const BOOST_HOF_SFINAE_RETURNS
(
capture_invoke(BOOST_HOF_RETURNS_STATIC_CAST(F&&)(f),
BOOST_HOF_RETURNS_C_CAST(Pack&&)(
BOOST_HOF_RETURNS_STATIC_CAST(const Pack&)(*boost::hof::always(BOOST_HOF_CONST_THIS)(f))
)
)
);
};
struct make_capture_pack_f
{
template
constexpr capture_pack operator()(Pack p) const
BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(capture_pack, Pack&&)
{
return capture_pack(static_cast(p));
}
};
template
struct capture_f
{
template
constexpr auto operator()(Ts&&... xs) const BOOST_HOF_RETURNS
(
BOOST_HOF_RETURNS_CONSTRUCT(make_capture_pack_f)()(BOOST_HOF_RETURNS_CONSTRUCT(F)()(BOOST_HOF_FORWARD(Ts)(xs)...))
);
};
}
BOOST_HOF_DECLARE_STATIC_VAR(capture_basic, detail::capture_f);
BOOST_HOF_DECLARE_STATIC_VAR(capture_forward, detail::capture_f);
BOOST_HOF_DECLARE_STATIC_VAR(capture, detail::capture_f);
}} // namespace boost::hof
#endif