1 | // ------------------------------------------------------------------------------ |
2 | // Copyright (c) 2000 Cadenza New Zealand Ltd |
3 | // Distributed under the Boost Software License, Version 1.0. (See accompany- |
4 | // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
5 | // ------------------------------------------------------------------------------ |
6 | // Boost functional.hpp header file |
7 | // See http://www.boost.org/libs/functional for documentation. |
8 | // ------------------------------------------------------------------------------ |
9 | // $Id$ |
10 | // ------------------------------------------------------------------------------ |
11 | |
12 | #ifndef BOOST_FUNCTIONAL_HPP |
13 | #define BOOST_FUNCTIONAL_HPP |
14 | |
15 | #include <boost/config.hpp> |
16 | #include <boost/call_traits.hpp> |
17 | #include <functional> |
18 | |
19 | namespace boost |
20 | { |
21 | #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
22 | // -------------------------------------------------------------------------- |
23 | // The following traits classes allow us to avoid the need for ptr_fun |
24 | // because the types of arguments and the result of a function can be |
25 | // deduced. |
26 | // |
27 | // In addition to the standard types defined in unary_function and |
28 | // binary_function, we add |
29 | // |
30 | // - function_type, the type of the function or function object itself. |
31 | // |
32 | // - param_type, the type that should be used for passing the function or |
33 | // function object as an argument. |
34 | // -------------------------------------------------------------------------- |
35 | namespace detail |
36 | { |
37 | template <class Operation> |
38 | struct unary_traits_imp; |
39 | |
40 | template <class Operation> |
41 | struct unary_traits_imp<Operation*> |
42 | { |
43 | typedef Operation function_type; |
44 | typedef const function_type & param_type; |
45 | typedef typename Operation::result_type result_type; |
46 | typedef typename Operation::argument_type argument_type; |
47 | }; |
48 | |
49 | template <class R, class A> |
50 | struct unary_traits_imp<R(*)(A)> |
51 | { |
52 | typedef R (*function_type)(A); |
53 | typedef R (*param_type)(A); |
54 | typedef R result_type; |
55 | typedef A argument_type; |
56 | }; |
57 | |
58 | template <class Operation> |
59 | struct binary_traits_imp; |
60 | |
61 | template <class Operation> |
62 | struct binary_traits_imp<Operation*> |
63 | { |
64 | typedef Operation function_type; |
65 | typedef const function_type & param_type; |
66 | typedef typename Operation::result_type result_type; |
67 | typedef typename Operation::first_argument_type first_argument_type; |
68 | typedef typename Operation::second_argument_type second_argument_type; |
69 | }; |
70 | |
71 | template <class R, class A1, class A2> |
72 | struct binary_traits_imp<R(*)(A1,A2)> |
73 | { |
74 | typedef R (*function_type)(A1,A2); |
75 | typedef R (*param_type)(A1,A2); |
76 | typedef R result_type; |
77 | typedef A1 first_argument_type; |
78 | typedef A2 second_argument_type; |
79 | }; |
80 | } // namespace detail |
81 | |
82 | template <class Operation> |
83 | struct unary_traits |
84 | { |
85 | typedef typename detail::unary_traits_imp<Operation*>::function_type function_type; |
86 | typedef typename detail::unary_traits_imp<Operation*>::param_type param_type; |
87 | typedef typename detail::unary_traits_imp<Operation*>::result_type result_type; |
88 | typedef typename detail::unary_traits_imp<Operation*>::argument_type argument_type; |
89 | }; |
90 | |
91 | template <class R, class A> |
92 | struct unary_traits<R(*)(A)> |
93 | { |
94 | typedef R (*function_type)(A); |
95 | typedef R (*param_type)(A); |
96 | typedef R result_type; |
97 | typedef A argument_type; |
98 | }; |
99 | |
100 | template <class Operation> |
101 | struct binary_traits |
102 | { |
103 | typedef typename detail::binary_traits_imp<Operation*>::function_type function_type; |
104 | typedef typename detail::binary_traits_imp<Operation*>::param_type param_type; |
105 | typedef typename detail::binary_traits_imp<Operation*>::result_type result_type; |
106 | typedef typename detail::binary_traits_imp<Operation*>::first_argument_type first_argument_type; |
107 | typedef typename detail::binary_traits_imp<Operation*>::second_argument_type second_argument_type; |
108 | }; |
109 | |
110 | template <class R, class A1, class A2> |
111 | struct binary_traits<R(*)(A1,A2)> |
112 | { |
113 | typedef R (*function_type)(A1,A2); |
114 | typedef R (*param_type)(A1,A2); |
115 | typedef R result_type; |
116 | typedef A1 first_argument_type; |
117 | typedef A2 second_argument_type; |
118 | }; |
119 | #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
120 | // -------------------------------------------------------------------------- |
121 | // If we have no partial specialisation available, decay to a situation |
122 | // that is no worse than in the Standard, i.e., ptr_fun will be required. |
123 | // -------------------------------------------------------------------------- |
124 | |
125 | template <class Operation> |
126 | struct unary_traits |
127 | { |
128 | typedef Operation function_type; |
129 | typedef const Operation& param_type; |
130 | typedef typename Operation::result_type result_type; |
131 | typedef typename Operation::argument_type argument_type; |
132 | }; |
133 | |
134 | template <class Operation> |
135 | struct binary_traits |
136 | { |
137 | typedef Operation function_type; |
138 | typedef const Operation & param_type; |
139 | typedef typename Operation::result_type result_type; |
140 | typedef typename Operation::first_argument_type first_argument_type; |
141 | typedef typename Operation::second_argument_type second_argument_type; |
142 | }; |
143 | #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
144 | |
145 | // -------------------------------------------------------------------------- |
146 | // unary_negate, not1 |
147 | // -------------------------------------------------------------------------- |
148 | template <class Predicate> |
149 | class unary_negate |
150 | : public std::unary_function<typename unary_traits<Predicate>::argument_type,bool> |
151 | { |
152 | public: |
153 | explicit unary_negate(typename unary_traits<Predicate>::param_type x) |
154 | : |
155 | pred(x) |
156 | {} |
157 | bool operator()(typename call_traits<typename unary_traits<Predicate>::argument_type>::param_type x) const |
158 | { |
159 | return !pred(x); |
160 | } |
161 | private: |
162 | typename unary_traits<Predicate>::function_type pred; |
163 | }; |
164 | |
165 | template <class Predicate> |
166 | unary_negate<Predicate> not1(const Predicate &pred) |
167 | { |
168 | // The cast is to placate Borland C++Builder in certain circumstances. |
169 | // I don't think it should be necessary. |
170 | return unary_negate<Predicate>((typename unary_traits<Predicate>::param_type)pred); |
171 | } |
172 | |
173 | template <class Predicate> |
174 | unary_negate<Predicate> not1(Predicate &pred) |
175 | { |
176 | return unary_negate<Predicate>(pred); |
177 | } |
178 | |
179 | // -------------------------------------------------------------------------- |
180 | // binary_negate, not2 |
181 | // -------------------------------------------------------------------------- |
182 | template <class Predicate> |
183 | class binary_negate |
184 | : public std::binary_function<typename binary_traits<Predicate>::first_argument_type, |
185 | typename binary_traits<Predicate>::second_argument_type, |
186 | bool> |
187 | { |
188 | public: |
189 | explicit binary_negate(typename binary_traits<Predicate>::param_type x) |
190 | : |
191 | pred(x) |
192 | {} |
193 | bool operator()(typename call_traits<typename binary_traits<Predicate>::first_argument_type>::param_type x, |
194 | typename call_traits<typename binary_traits<Predicate>::second_argument_type>::param_type y) const |
195 | { |
196 | return !pred(x,y); |
197 | } |
198 | private: |
199 | typename binary_traits<Predicate>::function_type pred; |
200 | }; |
201 | |
202 | template <class Predicate> |
203 | binary_negate<Predicate> not2(const Predicate &pred) |
204 | { |
205 | // The cast is to placate Borland C++Builder in certain circumstances. |
206 | // I don't think it should be necessary. |
207 | return binary_negate<Predicate>((typename binary_traits<Predicate>::param_type)pred); |
208 | } |
209 | |
210 | template <class Predicate> |
211 | binary_negate<Predicate> not2(Predicate &pred) |
212 | { |
213 | return binary_negate<Predicate>(pred); |
214 | } |
215 | |
216 | // -------------------------------------------------------------------------- |
217 | // binder1st, bind1st |
218 | // -------------------------------------------------------------------------- |
219 | template <class Operation> |
220 | class binder1st |
221 | : public std::unary_function<typename binary_traits<Operation>::second_argument_type, |
222 | typename binary_traits<Operation>::result_type> |
223 | { |
224 | public: |
225 | binder1st(typename binary_traits<Operation>::param_type x, |
226 | typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type y) |
227 | : |
228 | op(x), value(y) |
229 | {} |
230 | |
231 | typename binary_traits<Operation>::result_type |
232 | operator()(typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type x) const |
233 | { |
234 | return op(value, x); |
235 | } |
236 | |
237 | protected: |
238 | typename binary_traits<Operation>::function_type op; |
239 | typename binary_traits<Operation>::first_argument_type value; |
240 | }; |
241 | |
242 | template <class Operation> |
243 | inline binder1st<Operation> bind1st(const Operation &op, |
244 | typename call_traits< |
245 | typename binary_traits<Operation>::first_argument_type |
246 | >::param_type x) |
247 | { |
248 | // The cast is to placate Borland C++Builder in certain circumstances. |
249 | // I don't think it should be necessary. |
250 | return binder1st<Operation>((typename binary_traits<Operation>::param_type)op, x); |
251 | } |
252 | |
253 | template <class Operation> |
254 | inline binder1st<Operation> bind1st(Operation &op, |
255 | typename call_traits< |
256 | typename binary_traits<Operation>::first_argument_type |
257 | >::param_type x) |
258 | { |
259 | return binder1st<Operation>(op, x); |
260 | } |
261 | |
262 | // -------------------------------------------------------------------------- |
263 | // binder2nd, bind2nd |
264 | // -------------------------------------------------------------------------- |
265 | template <class Operation> |
266 | class binder2nd |
267 | : public std::unary_function<typename binary_traits<Operation>::first_argument_type, |
268 | typename binary_traits<Operation>::result_type> |
269 | { |
270 | public: |
271 | binder2nd(typename binary_traits<Operation>::param_type x, |
272 | typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type y) |
273 | : |
274 | op(x), value(y) |
275 | {} |
276 | |
277 | typename binary_traits<Operation>::result_type |
278 | operator()(typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type x) const |
279 | { |
280 | return op(x, value); |
281 | } |
282 | |
283 | protected: |
284 | typename binary_traits<Operation>::function_type op; |
285 | typename binary_traits<Operation>::second_argument_type value; |
286 | }; |
287 | |
288 | template <class Operation> |
289 | inline binder2nd<Operation> bind2nd(const Operation &op, |
290 | typename call_traits< |
291 | typename binary_traits<Operation>::second_argument_type |
292 | >::param_type x) |
293 | { |
294 | // The cast is to placate Borland C++Builder in certain circumstances. |
295 | // I don't think it should be necessary. |
296 | return binder2nd<Operation>((typename binary_traits<Operation>::param_type)op, x); |
297 | } |
298 | |
299 | template <class Operation> |
300 | inline binder2nd<Operation> bind2nd(Operation &op, |
301 | typename call_traits< |
302 | typename binary_traits<Operation>::second_argument_type |
303 | >::param_type x) |
304 | { |
305 | return binder2nd<Operation>(op, x); |
306 | } |
307 | |
308 | // -------------------------------------------------------------------------- |
309 | // mem_fun, etc |
310 | // -------------------------------------------------------------------------- |
311 | template <class S, class T> |
312 | class mem_fun_t : public std::unary_function<T*, S> |
313 | { |
314 | public: |
315 | explicit mem_fun_t(S (T::*p)()) |
316 | : |
317 | ptr(p) |
318 | {} |
319 | S operator()(T* p) const |
320 | { |
321 | return (p->*ptr)(); |
322 | } |
323 | private: |
324 | S (T::*ptr)(); |
325 | }; |
326 | |
327 | template <class S, class T, class A> |
328 | class mem_fun1_t : public std::binary_function<T*, A, S> |
329 | { |
330 | public: |
331 | explicit mem_fun1_t(S (T::*p)(A)) |
332 | : |
333 | ptr(p) |
334 | {} |
335 | S operator()(T* p, typename call_traits<A>::param_type x) const |
336 | { |
337 | return (p->*ptr)(x); |
338 | } |
339 | private: |
340 | S (T::*ptr)(A); |
341 | }; |
342 | |
343 | template <class S, class T> |
344 | class const_mem_fun_t : public std::unary_function<const T*, S> |
345 | { |
346 | public: |
347 | explicit const_mem_fun_t(S (T::*p)() const) |
348 | : |
349 | ptr(p) |
350 | {} |
351 | S operator()(const T* p) const |
352 | { |
353 | return (p->*ptr)(); |
354 | } |
355 | private: |
356 | S (T::*ptr)() const; |
357 | }; |
358 | |
359 | template <class S, class T, class A> |
360 | class const_mem_fun1_t : public std::binary_function<const T*, A, S> |
361 | { |
362 | public: |
363 | explicit const_mem_fun1_t(S (T::*p)(A) const) |
364 | : |
365 | ptr(p) |
366 | {} |
367 | S operator()(const T* p, typename call_traits<A>::param_type x) const |
368 | { |
369 | return (p->*ptr)(x); |
370 | } |
371 | private: |
372 | S (T::*ptr)(A) const; |
373 | }; |
374 | |
375 | template<class S, class T> |
376 | inline mem_fun_t<S,T> mem_fun(S (T::*f)()) |
377 | { |
378 | return mem_fun_t<S,T>(f); |
379 | } |
380 | |
381 | template<class S, class T, class A> |
382 | inline mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)) |
383 | { |
384 | return mem_fun1_t<S,T,A>(f); |
385 | } |
386 | |
387 | #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST |
388 | template<class S, class T> |
389 | inline const_mem_fun_t<S,T> mem_fun(S (T::*f)() const) |
390 | { |
391 | return const_mem_fun_t<S,T>(f); |
392 | } |
393 | |
394 | template<class S, class T, class A> |
395 | inline const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const) |
396 | { |
397 | return const_mem_fun1_t<S,T,A>(f); |
398 | } |
399 | #endif // BOOST_NO_POINTER_TO_MEMBER_CONST |
400 | |
401 | // -------------------------------------------------------------------------- |
402 | // mem_fun_ref, etc |
403 | // -------------------------------------------------------------------------- |
404 | template <class S, class T> |
405 | class mem_fun_ref_t : public std::unary_function<T&, S> |
406 | { |
407 | public: |
408 | explicit mem_fun_ref_t(S (T::*p)()) |
409 | : |
410 | ptr(p) |
411 | {} |
412 | S operator()(T& p) const |
413 | { |
414 | return (p.*ptr)(); |
415 | } |
416 | private: |
417 | S (T::*ptr)(); |
418 | }; |
419 | |
420 | template <class S, class T, class A> |
421 | class mem_fun1_ref_t : public std::binary_function<T&, A, S> |
422 | { |
423 | public: |
424 | explicit mem_fun1_ref_t(S (T::*p)(A)) |
425 | : |
426 | ptr(p) |
427 | {} |
428 | S operator()(T& p, typename call_traits<A>::param_type x) const |
429 | { |
430 | return (p.*ptr)(x); |
431 | } |
432 | private: |
433 | S (T::*ptr)(A); |
434 | }; |
435 | |
436 | template <class S, class T> |
437 | class const_mem_fun_ref_t : public std::unary_function<const T&, S> |
438 | { |
439 | public: |
440 | explicit const_mem_fun_ref_t(S (T::*p)() const) |
441 | : |
442 | ptr(p) |
443 | {} |
444 | |
445 | S operator()(const T &p) const |
446 | { |
447 | return (p.*ptr)(); |
448 | } |
449 | private: |
450 | S (T::*ptr)() const; |
451 | }; |
452 | |
453 | template <class S, class T, class A> |
454 | class const_mem_fun1_ref_t : public std::binary_function<const T&, A, S> |
455 | { |
456 | public: |
457 | explicit const_mem_fun1_ref_t(S (T::*p)(A) const) |
458 | : |
459 | ptr(p) |
460 | {} |
461 | |
462 | S operator()(const T& p, typename call_traits<A>::param_type x) const |
463 | { |
464 | return (p.*ptr)(x); |
465 | } |
466 | private: |
467 | S (T::*ptr)(A) const; |
468 | }; |
469 | |
470 | template<class S, class T> |
471 | inline mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()) |
472 | { |
473 | return mem_fun_ref_t<S,T>(f); |
474 | } |
475 | |
476 | template<class S, class T, class A> |
477 | inline mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)) |
478 | { |
479 | return mem_fun1_ref_t<S,T,A>(f); |
480 | } |
481 | |
482 | #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST |
483 | template<class S, class T> |
484 | inline const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const) |
485 | { |
486 | return const_mem_fun_ref_t<S,T>(f); |
487 | } |
488 | |
489 | template<class S, class T, class A> |
490 | inline const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const) |
491 | { |
492 | return const_mem_fun1_ref_t<S,T,A>(f); |
493 | } |
494 | #endif // BOOST_NO_POINTER_TO_MEMBER_CONST |
495 | |
496 | // -------------------------------------------------------------------------- |
497 | // ptr_fun |
498 | // -------------------------------------------------------------------------- |
499 | template <class Arg, class Result> |
500 | class pointer_to_unary_function : public std::unary_function<Arg,Result> |
501 | { |
502 | public: |
503 | explicit pointer_to_unary_function(Result (*f)(Arg)) |
504 | : |
505 | func(f) |
506 | {} |
507 | |
508 | Result operator()(typename call_traits<Arg>::param_type x) const |
509 | { |
510 | return func(x); |
511 | } |
512 | |
513 | private: |
514 | Result (*func)(Arg); |
515 | }; |
516 | |
517 | template <class Arg, class Result> |
518 | inline pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)) |
519 | { |
520 | return pointer_to_unary_function<Arg,Result>(f); |
521 | } |
522 | |
523 | template <class Arg1, class Arg2, class Result> |
524 | class pointer_to_binary_function : public std::binary_function<Arg1,Arg2,Result> |
525 | { |
526 | public: |
527 | explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)) |
528 | : |
529 | func(f) |
530 | {} |
531 | |
532 | Result operator()(typename call_traits<Arg1>::param_type x, typename call_traits<Arg2>::param_type y) const |
533 | { |
534 | return func(x,y); |
535 | } |
536 | |
537 | private: |
538 | Result (*func)(Arg1, Arg2); |
539 | }; |
540 | |
541 | template <class Arg1, class Arg2, class Result> |
542 | inline pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2)) |
543 | { |
544 | return pointer_to_binary_function<Arg1,Arg2,Result>(f); |
545 | } |
546 | } // namespace boost |
547 | |
548 | #endif |
549 | |