1/*=============================================================================
2 Copyright (c) 2016 Paul Fultz II
3 limit.h
4 Distributed under the Boost Software License, Version 1.0. (See accompanying
5 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6==============================================================================*/
7
8#ifndef BOOST_HOF_GUARD_LIMIT_H
9#define BOOST_HOF_GUARD_LIMIT_H
10
11/// limit
12/// =====
13///
14/// Description
15/// -----------
16///
17/// The `limit` function decorator annotates the function with the max number
18/// of parameters. The `limit_c` version can be used to give the max number
19/// directly(instead of relying on an integral constant). The parameter limit
20/// can be read by using the [`function_param_limit`](function_param_limit)
21/// trait. Using `limit` is useful to improve error reporting with partially
22/// evaluated functions.
23///
24/// Synopsis
25/// --------
26///
27/// template<class IntegralConstant>
28/// constexpr auto limit(IntegralConstant);
29///
30/// template<std::size_t N, class F>
31/// constexpr auto limit_c(F);
32///
33/// Requirements
34/// ------------
35///
36/// IntegralConstant must be:
37///
38/// * IntegralConstant
39///
40/// F must be:
41///
42/// * [ConstInvocable](ConstInvocable)
43/// * MoveConstructible
44///
45/// Example
46/// -------
47///
48/// #include <boost/hof.hpp>
49/// #include <cassert>
50/// using namespace boost::hof;
51///
52/// struct sum_f
53/// {
54/// template<class T>
55/// int operator()(T x, T y) const
56/// {
57/// return x+y;
58/// }
59/// };
60/// BOOST_HOF_STATIC_FUNCTION(sum) = limit_c<2>(sum_f());
61///
62/// int main() {
63/// assert(3 == sum(1, 2));
64/// }
65///
66/// See Also
67/// --------
68///
69/// * [Partial function evaluation](<Partial function evaluation>)
70/// * [function_param_limit](function_param_limit)
71///
72
73#include <boost/hof/detail/callable_base.hpp>
74#include <boost/hof/detail/forward.hpp>
75#include <boost/hof/detail/delegate.hpp>
76#include <boost/hof/detail/move.hpp>
77#include <boost/hof/detail/static_const_var.hpp>
78#include <boost/hof/always.hpp>
79#include <boost/hof/function_param_limit.hpp>
80
81namespace boost { namespace hof {
82
83namespace detail {
84// TODO: Make this work with fit_rewritable1_tag
85template<std::size_t N, class F>
86struct limit_adaptor : detail::callable_base<F>
87{
88 typedef std::integral_constant<std::size_t, N> fit_function_param_limit;
89 BOOST_HOF_INHERIT_CONSTRUCTOR(limit_adaptor, detail::callable_base<F>)
90
91 template<class... Ts>
92 constexpr const detail::callable_base<F>& base_function(Ts&&... xs) const
93 {
94 return boost::hof::always_ref(*this)(xs...);
95 }
96
97 BOOST_HOF_RETURNS_CLASS(limit_adaptor);
98
99 template<class... Ts, class=typename std::enable_if<(sizeof...(Ts) <= N)>::type>
100 constexpr BOOST_HOF_SFINAE_RESULT(const detail::callable_base<F>&, id_<Ts>...)
101 operator()(Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS
102 (
103 (BOOST_HOF_MANGLE_CAST(const detail::callable_base<F>&)(BOOST_HOF_CONST_THIS->base_function(xs...)))
104 (BOOST_HOF_FORWARD(Ts)(xs)...)
105 );
106
107};
108
109template<std::size_t N>
110struct make_limit_f
111{
112 constexpr make_limit_f()
113 {}
114 template<class F>
115 constexpr limit_adaptor<N, F> operator()(F f) const
116 {
117 return limit_adaptor<N, F>(static_cast<F&&>(f));
118 }
119};
120
121struct limit_f
122{
123 template<class IntegralConstant, std::size_t N=IntegralConstant::type::value>
124 constexpr make_limit_f<N> operator()(IntegralConstant) const
125 {
126 return {};
127 }
128};
129
130}
131
132template<std::size_t N, class F>
133constexpr detail::limit_adaptor<N, F> limit_c(F f)
134{
135 return detail::limit_adaptor<N, F>(static_cast<F&&>(f));
136}
137
138BOOST_HOF_DECLARE_STATIC_VAR(limit, detail::limit_f);
139
140}} // namespace boost::hof
141
142#endif
143

source code of boost/libs/hof/include/boost/hof/limit.hpp