1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// 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
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_FUNCTIONAL_BIND_HPP
#define BOOST_COMPUTE_FUNCTIONAL_BIND_HPP
#include <boost/mpl/int.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/compute/config.hpp>
#include <boost/compute/detail/meta_kernel.hpp>
namespace boost {
namespace compute {
namespace placeholders {
/// \internal_
template<int I>
struct placeholder : boost::integral_constant<int, I>
{
placeholder() { }
};
placeholder<0> const _1;
placeholder<1> const _2;
} // end placeholders namespace
/// Meta-function returning \c true if \c T is a placeholder type.
template<class T>
struct is_placeholder : boost::false_type
{
};
/// \internal_
template<int I>
struct is_placeholder<placeholders::placeholder<I> > : boost::true_type
{
};
namespace detail {
template<class Function, class BoundArgs, class Args>
struct invoked_bound_function
{
invoked_bound_function(Function f, BoundArgs bound_args, Args args)
: m_function(f),
m_bound_args(bound_args),
m_args(args)
{
}
// meta-function returning true if the N'th argument is a placeholder
template<int N>
struct is_placeholder_arg
{
typedef typename boost::tuples::element<N, BoundArgs>::type nth_bound_arg;
typedef typename is_placeholder<nth_bound_arg>::type type;
static const bool value = is_placeholder<nth_bound_arg>::value;
};
template<class Arg>
struct get_arg_type
{
typedef Arg type;
};
template<int I>
struct get_arg_type<placeholders::placeholder<I> >
{
typedef typename boost::tuples::element<I, Args>::type type;
};
// meta-function returning the type of the N'th argument when invoked
template<int N>
struct get_nth_arg_type
{
typedef typename boost::tuples::element<N, BoundArgs>::type nth_bound_arg;
typedef typename get_arg_type<nth_bound_arg>::type type;
};
template<int N>
typename get_nth_arg_type<N>::type get_nth_arg(
typename boost::enable_if_c<is_placeholder_arg<N>::value>::type* = 0
) const
{
typedef typename boost::tuples::element<N, BoundArgs>::type nth_bound_arg;
return boost::get<nth_bound_arg::value>(m_args);
}
template<int N>
typename get_nth_arg_type<N>::type get_nth_arg(
typename boost::disable_if_c<is_placeholder_arg<N>::value>::type* = 0
) const
{
return boost::get<N>(m_bound_args);
}
Function m_function;
BoundArgs m_bound_args;
Args m_args;
};
template<class Function, class BoundArgs, class Args>
inline meta_kernel& apply_invoked_bound_function(
meta_kernel &k,
const invoked_bound_function<Function, BoundArgs, Args> &expr,
typename boost::enable_if_c<
boost::tuples::length<BoundArgs>::value == 1
>::type* = 0
)
{
return k << expr.m_function(expr.template get_nth_arg<0>());
}
template<class Function, class BoundArgs, class Args>
inline meta_kernel& apply_invoked_bound_function(
meta_kernel &k,
const invoked_bound_function<Function, BoundArgs, Args> &expr,
typename boost::enable_if_c<
boost::tuples::length<BoundArgs>::value == 2
>::type* = 0
)
{
return k << expr.m_function(expr.template get_nth_arg<0>(),
expr.template get_nth_arg<1>());
}
template<class Function, class BoundArgs, class Args>
inline meta_kernel& apply_invoked_bound_function(
meta_kernel &k,
const invoked_bound_function<Function, BoundArgs, Args> &expr,
typename boost::enable_if_c<
boost::tuples::length<BoundArgs>::value == 3
>::type* = 0
)
{
return k << expr.m_function(expr.template get_nth_arg<0>(),
expr.template get_nth_arg<1>(),
expr.template get_nth_arg<2>());
}
template<class Function, class BoundArgs, class Args>
inline meta_kernel& operator<<(
meta_kernel &k,
const invoked_bound_function<Function, BoundArgs, Args> &expr
)
{
return apply_invoked_bound_function(k, expr);
}
template<class Function, class BoundArgs>
struct bound_function
{
typedef int result_type;
bound_function(Function f, BoundArgs args)
: m_function(f),
m_args(args)
{
}
template<class Arg1>
detail::invoked_bound_function<
Function,
BoundArgs,
boost::tuple<Arg1>
>
operator()(const Arg1 &arg1) const
{
return detail::invoked_bound_function<
Function,
BoundArgs,
boost::tuple<Arg1>
>(m_function, m_args, boost::make_tuple(arg1));
}
template<class Arg1, class Arg2>
detail::invoked_bound_function<
Function,
BoundArgs,
boost::tuple<Arg1, Arg2>
>
operator()(const Arg1 &arg1, const Arg2 &arg2) const
{
return detail::invoked_bound_function<
Function,
BoundArgs,
boost::tuple<Arg1, Arg2>
>(m_function, m_args, boost::make_tuple(arg1, arg2));
}
Function m_function;
BoundArgs m_args;
};
} // end detail namespace
#if !defined(BOOST_COMPUTE_NO_VARIADIC_TEMPLATES) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)
/// Returns a function wrapper which invokes \p f with \p args when called.
///
/// For example, to generate a unary function object which returns \c true
/// when its argument is less than \c 7:
/// \code
/// using boost::compute::less;
/// using boost::compute::placeholders::_1;
///
/// auto less_than_seven = boost::compute::bind(less<int>(), _1, 7);
/// \endcode
template<class F, class... Args>
inline detail::bound_function<F, boost::tuple<Args...> >
bind(F f, Args... args)
{
typedef typename boost::tuple<Args...> ArgsTuple;
return detail::bound_function<F, ArgsTuple>(f, boost::make_tuple(args...));
}
#else
template<class F, class A1>
inline detail::bound_function<F, boost::tuple<A1> >
bind(F f, A1 a1)
{
typedef typename boost::tuple<A1> Args;
return detail::bound_function<F, Args>(f, boost::make_tuple(a1));
}
template<class F, class A1, class A2>
inline detail::bound_function<F, boost::tuple<A1, A2> >
bind(F f, A1 a1, A2 a2)
{
typedef typename boost::tuple<A1, A2> Args;
return detail::bound_function<F, Args>(f, boost::make_tuple(a1, a2));
}
template<class F, class A1, class A2, class A3>
inline detail::bound_function<F, boost::tuple<A1, A2, A3> >
bind(F f, A1 a1, A2 a2, A3 a3)
{
typedef typename boost::tuple<A1, A2, A3> Args;
return detail::bound_function<F, Args>(f, boost::make_tuple(a1, a2, a3));
}
#endif // BOOST_COMPUTE_NO_VARIADIC_TEMPLATES
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_FUNCTIONAL_BIND_HPP
|
