|
1 // Boost.Function library |
|
2 |
|
3 // Copyright Douglas Gregor 2001-2006 |
|
4 // Copyright Emil Dotchevski 2007 |
|
5 // Use, modification and distribution is subject to the Boost Software License, Version 1.0. |
|
6 // (See accompanying file LICENSE_1_0.txt or copy at |
|
7 // http://www.boost.org/LICENSE_1_0.txt) |
|
8 |
|
9 // For more information, see http://www.boost.org |
|
10 |
|
11 #ifndef BOOST_FUNCTION_BASE_HEADER |
|
12 #define BOOST_FUNCTION_BASE_HEADER |
|
13 |
|
14 #include <stdexcept> |
|
15 #include <string> |
|
16 #include <memory> |
|
17 #include <new> |
|
18 #include <typeinfo> |
|
19 #include <boost/config.hpp> |
|
20 #include <boost/assert.hpp> |
|
21 #include <boost/type_traits/is_const.hpp> |
|
22 #include <boost/type_traits/is_integral.hpp> |
|
23 #include <boost/type_traits/is_volatile.hpp> |
|
24 #include <boost/type_traits/composite_traits.hpp> |
|
25 #include <boost/type_traits/ice.hpp> |
|
26 #include <boost/ref.hpp> |
|
27 #include <boost/mpl/if.hpp> |
|
28 #include <boost/detail/workaround.hpp> |
|
29 #include <boost/type_traits/alignment_of.hpp> |
|
30 #ifndef BOOST_NO_SFINAE |
|
31 # include "boost/utility/enable_if.hpp" |
|
32 #else |
|
33 # include "boost/mpl/bool.hpp" |
|
34 #endif |
|
35 #include <boost/function_equal.hpp> |
|
36 #include <boost/function/function_fwd.hpp> |
|
37 |
|
38 #if defined(BOOST_MSVC) |
|
39 # pragma warning( push ) |
|
40 # pragma warning( disable : 4793 ) // complaint about native code generation |
|
41 # pragma warning( disable : 4127 ) // "conditional expression is constant" |
|
42 #endif |
|
43 |
|
44 // Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info. |
|
45 #ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE |
|
46 // Embedded VC++ does not have type_info in namespace std |
|
47 # define BOOST_FUNCTION_STD_NS |
|
48 #else |
|
49 # define BOOST_FUNCTION_STD_NS std |
|
50 #endif |
|
51 |
|
52 // Borrowed from Boost.Python library: determines the cases where we |
|
53 // need to use std::type_info::name to compare instead of operator==. |
|
54 # if (defined(__GNUC__) && __GNUC__ >= 3) \ |
|
55 || defined(_AIX) \ |
|
56 || ( defined(__sgi) && defined(__host_mips)) |
|
57 # include <cstring> |
|
58 # define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \ |
|
59 (std::strcmp((X).name(),(Y).name()) == 0) |
|
60 # else |
|
61 # define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y)) |
|
62 #endif |
|
63 |
|
64 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG) |
|
65 # define BOOST_FUNCTION_TARGET_FIX(x) x |
|
66 #else |
|
67 # define BOOST_FUNCTION_TARGET_FIX(x) |
|
68 #endif // not MSVC |
|
69 |
|
70 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) |
|
71 # define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \ |
|
72 typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \ |
|
73 (::boost::is_integral<Functor>::value)>::value), \ |
|
74 Type>::type |
|
75 #else |
|
76 // BCC doesn't recognize this depends on a template argument and complains |
|
77 // about the use of 'typename' |
|
78 # define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \ |
|
79 ::boost::enable_if_c<(::boost::type_traits::ice_not< \ |
|
80 (::boost::is_integral<Functor>::value)>::value), \ |
|
81 Type>::type |
|
82 #endif |
|
83 |
|
84 namespace boost { |
|
85 namespace detail { |
|
86 namespace function { |
|
87 class X; |
|
88 |
|
89 /** |
|
90 * A buffer used to store small function objects in |
|
91 * boost::function. It is a union containing function pointers, |
|
92 * object pointers, and a structure that resembles a bound |
|
93 * member function pointer. |
|
94 */ |
|
95 union function_buffer |
|
96 { |
|
97 // For pointers to function objects |
|
98 mutable void* obj_ptr; |
|
99 |
|
100 // For pointers to std::type_info objects |
|
101 struct type_t { |
|
102 // (get_functor_type_tag, check_functor_type_tag). |
|
103 const BOOST_FUNCTION_STD_NS::type_info* type; |
|
104 |
|
105 // Whether the type is const-qualified. |
|
106 bool const_qualified; |
|
107 // Whether the type is volatile-qualified. |
|
108 bool volatile_qualified; |
|
109 } type; |
|
110 |
|
111 // For function pointers of all kinds |
|
112 mutable void (*func_ptr)(); |
|
113 |
|
114 // For bound member pointers |
|
115 struct bound_memfunc_ptr_t { |
|
116 void (X::*memfunc_ptr)(int); |
|
117 void* obj_ptr; |
|
118 } bound_memfunc_ptr; |
|
119 |
|
120 // For references to function objects. We explicitly keep |
|
121 // track of the cv-qualifiers on the object referenced. |
|
122 struct obj_ref_t { |
|
123 mutable void* obj_ptr; |
|
124 bool is_const_qualified; |
|
125 bool is_volatile_qualified; |
|
126 } obj_ref; |
|
127 |
|
128 // To relax aliasing constraints |
|
129 mutable char data; |
|
130 }; |
|
131 |
|
132 /** |
|
133 * The unusable class is a placeholder for unused function arguments |
|
134 * It is also completely unusable except that it constructable from |
|
135 * anything. This helps compilers without partial specialization to |
|
136 * handle Boost.Function objects returning void. |
|
137 */ |
|
138 struct unusable |
|
139 { |
|
140 unusable() {} |
|
141 template<typename T> unusable(const T&) {} |
|
142 }; |
|
143 |
|
144 /* Determine the return type. This supports compilers that do not support |
|
145 * void returns or partial specialization by silently changing the return |
|
146 * type to "unusable". |
|
147 */ |
|
148 template<typename T> struct function_return_type { typedef T type; }; |
|
149 |
|
150 template<> |
|
151 struct function_return_type<void> |
|
152 { |
|
153 typedef unusable type; |
|
154 }; |
|
155 |
|
156 // The operation type to perform on the given functor/function pointer |
|
157 enum functor_manager_operation_type { |
|
158 clone_functor_tag, |
|
159 move_functor_tag, |
|
160 destroy_functor_tag, |
|
161 check_functor_type_tag, |
|
162 get_functor_type_tag |
|
163 }; |
|
164 |
|
165 // Tags used to decide between different types of functions |
|
166 struct function_ptr_tag {}; |
|
167 struct function_obj_tag {}; |
|
168 struct member_ptr_tag {}; |
|
169 struct function_obj_ref_tag {}; |
|
170 |
|
171 template<typename F> |
|
172 class get_function_tag |
|
173 { |
|
174 typedef typename mpl::if_c<(is_pointer<F>::value), |
|
175 function_ptr_tag, |
|
176 function_obj_tag>::type ptr_or_obj_tag; |
|
177 |
|
178 typedef typename mpl::if_c<(is_member_pointer<F>::value), |
|
179 member_ptr_tag, |
|
180 ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag; |
|
181 |
|
182 typedef typename mpl::if_c<(is_reference_wrapper<F>::value), |
|
183 function_obj_ref_tag, |
|
184 ptr_or_obj_or_mem_tag>::type or_ref_tag; |
|
185 |
|
186 public: |
|
187 typedef or_ref_tag type; |
|
188 }; |
|
189 |
|
190 // The trivial manager does nothing but return the same pointer (if we |
|
191 // are cloning) or return the null pointer (if we are deleting). |
|
192 template<typename F> |
|
193 struct reference_manager |
|
194 { |
|
195 static inline void |
|
196 manage(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
197 functor_manager_operation_type op) |
|
198 { |
|
199 switch (op) { |
|
200 case clone_functor_tag: |
|
201 out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr; |
|
202 return; |
|
203 |
|
204 case move_functor_tag: |
|
205 out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr; |
|
206 in_buffer.obj_ref.obj_ptr = 0; |
|
207 return; |
|
208 |
|
209 case destroy_functor_tag: |
|
210 out_buffer.obj_ref.obj_ptr = 0; |
|
211 return; |
|
212 |
|
213 case check_functor_type_tag: |
|
214 { |
|
215 const BOOST_FUNCTION_STD_NS::type_info& check_type |
|
216 = *out_buffer.type.type; |
|
217 |
|
218 // Check whether we have the same type. We can add |
|
219 // cv-qualifiers, but we can't take them away. |
|
220 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)) |
|
221 && (!in_buffer.obj_ref.is_const_qualified |
|
222 || out_buffer.type.const_qualified) |
|
223 && (!in_buffer.obj_ref.is_volatile_qualified |
|
224 || out_buffer.type.volatile_qualified)) |
|
225 out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr; |
|
226 else |
|
227 out_buffer.obj_ptr = 0; |
|
228 } |
|
229 return; |
|
230 |
|
231 case get_functor_type_tag: |
|
232 out_buffer.type.type = &typeid(F); |
|
233 out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified; |
|
234 out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified; |
|
235 return; |
|
236 } |
|
237 } |
|
238 }; |
|
239 |
|
240 /** |
|
241 * Determine if boost::function can use the small-object |
|
242 * optimization with the function object type F. |
|
243 */ |
|
244 template<typename F> |
|
245 struct function_allows_small_object_optimization |
|
246 { |
|
247 BOOST_STATIC_CONSTANT |
|
248 (bool, |
|
249 value = ((sizeof(F) <= sizeof(function_buffer) && |
|
250 (alignment_of<function_buffer>::value |
|
251 % alignment_of<F>::value == 0)))); |
|
252 }; |
|
253 |
|
254 template <typename F,typename A> |
|
255 struct functor_wrapper: public F, public A |
|
256 { |
|
257 functor_wrapper( F f, A a ): |
|
258 F(f), |
|
259 A(a) |
|
260 { |
|
261 } |
|
262 }; |
|
263 |
|
264 /** |
|
265 * The functor_manager class contains a static function "manage" which |
|
266 * can clone or destroy the given function/function object pointer. |
|
267 */ |
|
268 template<typename Functor> |
|
269 struct functor_manager_common |
|
270 { |
|
271 typedef Functor functor_type; |
|
272 |
|
273 // Function pointers |
|
274 static inline void |
|
275 manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
276 functor_manager_operation_type op) |
|
277 { |
|
278 if (op == clone_functor_tag) |
|
279 out_buffer.func_ptr = in_buffer.func_ptr; |
|
280 else if (op == move_functor_tag) { |
|
281 out_buffer.func_ptr = in_buffer.func_ptr; |
|
282 in_buffer.func_ptr = 0; |
|
283 } else if (op == destroy_functor_tag) |
|
284 out_buffer.func_ptr = 0; |
|
285 else if (op == check_functor_type_tag) { |
|
286 const BOOST_FUNCTION_STD_NS::type_info& check_type |
|
287 = *out_buffer.type.type; |
|
288 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor))) |
|
289 out_buffer.obj_ptr = &in_buffer.func_ptr; |
|
290 else |
|
291 out_buffer.obj_ptr = 0; |
|
292 } else /* op == get_functor_type_tag */ { |
|
293 out_buffer.type.type = &typeid(Functor); |
|
294 out_buffer.type.const_qualified = false; |
|
295 out_buffer.type.volatile_qualified = false; |
|
296 } |
|
297 } |
|
298 |
|
299 // Function objects that fit in the small-object buffer. |
|
300 static inline void |
|
301 manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
302 functor_manager_operation_type op) |
|
303 { |
|
304 if (op == clone_functor_tag || op == move_functor_tag) { |
|
305 const functor_type* in_functor = |
|
306 reinterpret_cast<const functor_type*>(&in_buffer.data); |
|
307 new ((void*)&out_buffer.data) functor_type(*in_functor); |
|
308 |
|
309 if (op == move_functor_tag) { |
|
310 reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor(); |
|
311 } |
|
312 } else if (op == destroy_functor_tag) { |
|
313 // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type. |
|
314 reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor(); |
|
315 } else if (op == check_functor_type_tag) { |
|
316 const BOOST_FUNCTION_STD_NS::type_info& check_type |
|
317 = *out_buffer.type.type; |
|
318 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor))) |
|
319 out_buffer.obj_ptr = &in_buffer.data; |
|
320 else |
|
321 out_buffer.obj_ptr = 0; |
|
322 } else /* op == get_functor_type_tag */ { |
|
323 out_buffer.type.type = &typeid(Functor); |
|
324 out_buffer.type.const_qualified = false; |
|
325 out_buffer.type.volatile_qualified = false; |
|
326 } |
|
327 } |
|
328 }; |
|
329 |
|
330 template<typename Functor> |
|
331 struct functor_manager |
|
332 { |
|
333 private: |
|
334 typedef Functor functor_type; |
|
335 |
|
336 // Function pointers |
|
337 static inline void |
|
338 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
339 functor_manager_operation_type op, function_ptr_tag) |
|
340 { |
|
341 functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op); |
|
342 } |
|
343 |
|
344 // Function objects that fit in the small-object buffer. |
|
345 static inline void |
|
346 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
347 functor_manager_operation_type op, mpl::true_) |
|
348 { |
|
349 functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op); |
|
350 } |
|
351 |
|
352 // Function objects that require heap allocation |
|
353 static inline void |
|
354 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
355 functor_manager_operation_type op, mpl::false_) |
|
356 { |
|
357 if (op == clone_functor_tag) { |
|
358 // Clone the functor |
|
359 // GCC 2.95.3 gets the CV qualifiers wrong here, so we |
|
360 // can't do the static_cast that we should do. |
|
361 const functor_type* f = |
|
362 (const functor_type*)(in_buffer.obj_ptr); |
|
363 functor_type* new_f = new functor_type(*f); |
|
364 out_buffer.obj_ptr = new_f; |
|
365 } else if (op == move_functor_tag) { |
|
366 out_buffer.obj_ptr = in_buffer.obj_ptr; |
|
367 in_buffer.obj_ptr = 0; |
|
368 } else if (op == destroy_functor_tag) { |
|
369 /* Cast from the void pointer to the functor pointer type */ |
|
370 functor_type* f = |
|
371 static_cast<functor_type*>(out_buffer.obj_ptr); |
|
372 delete f; |
|
373 out_buffer.obj_ptr = 0; |
|
374 } else if (op == check_functor_type_tag) { |
|
375 const BOOST_FUNCTION_STD_NS::type_info& check_type |
|
376 = *out_buffer.type.type; |
|
377 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor))) |
|
378 out_buffer.obj_ptr = in_buffer.obj_ptr; |
|
379 else |
|
380 out_buffer.obj_ptr = 0; |
|
381 } else /* op == get_functor_type_tag */ { |
|
382 out_buffer.type.type = &typeid(Functor); |
|
383 out_buffer.type.const_qualified = false; |
|
384 out_buffer.type.volatile_qualified = false; |
|
385 } |
|
386 } |
|
387 |
|
388 // For function objects, we determine whether the function |
|
389 // object can use the small-object optimization buffer or |
|
390 // whether we need to allocate it on the heap. |
|
391 static inline void |
|
392 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
393 functor_manager_operation_type op, function_obj_tag) |
|
394 { |
|
395 manager(in_buffer, out_buffer, op, |
|
396 mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>()); |
|
397 } |
|
398 |
|
399 // For member pointers, we use the small-object optimization buffer. |
|
400 static inline void |
|
401 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
402 functor_manager_operation_type op, member_ptr_tag) |
|
403 { |
|
404 manager(in_buffer, out_buffer, op, mpl::true_()); |
|
405 } |
|
406 |
|
407 public: |
|
408 /* Dispatch to an appropriate manager based on whether we have a |
|
409 function pointer or a function object pointer. */ |
|
410 static inline void |
|
411 manage(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
412 functor_manager_operation_type op) |
|
413 { |
|
414 typedef typename get_function_tag<functor_type>::type tag_type; |
|
415 switch (op) { |
|
416 case get_functor_type_tag: |
|
417 out_buffer.type.type = &typeid(functor_type); |
|
418 out_buffer.type.const_qualified = false; |
|
419 out_buffer.type.volatile_qualified = false; |
|
420 return; |
|
421 |
|
422 default: |
|
423 manager(in_buffer, out_buffer, op, tag_type()); |
|
424 return; |
|
425 } |
|
426 } |
|
427 }; |
|
428 |
|
429 template<typename Functor, typename Allocator> |
|
430 struct functor_manager_a |
|
431 { |
|
432 private: |
|
433 typedef Functor functor_type; |
|
434 |
|
435 // Function pointers |
|
436 static inline void |
|
437 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
438 functor_manager_operation_type op, function_ptr_tag) |
|
439 { |
|
440 functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op); |
|
441 } |
|
442 |
|
443 // Function objects that fit in the small-object buffer. |
|
444 static inline void |
|
445 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
446 functor_manager_operation_type op, mpl::true_) |
|
447 { |
|
448 functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op); |
|
449 } |
|
450 |
|
451 // Function objects that require heap allocation |
|
452 static inline void |
|
453 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
454 functor_manager_operation_type op, mpl::false_) |
|
455 { |
|
456 typedef functor_wrapper<Functor,Allocator> functor_wrapper_type; |
|
457 typedef typename Allocator::template rebind<functor_wrapper_type>::other |
|
458 wrapper_allocator_type; |
|
459 typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type; |
|
460 |
|
461 if (op == clone_functor_tag) { |
|
462 // Clone the functor |
|
463 // GCC 2.95.3 gets the CV qualifiers wrong here, so we |
|
464 // can't do the static_cast that we should do. |
|
465 const functor_wrapper_type* f = |
|
466 (const functor_wrapper_type*)(in_buffer.obj_ptr); |
|
467 wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f)); |
|
468 wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); |
|
469 wrapper_allocator.construct(copy, *f); |
|
470 |
|
471 // Get back to the original pointer type |
|
472 functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy); |
|
473 out_buffer.obj_ptr = new_f; |
|
474 } else if (op == move_functor_tag) { |
|
475 out_buffer.obj_ptr = in_buffer.obj_ptr; |
|
476 in_buffer.obj_ptr = 0; |
|
477 } else if (op == destroy_functor_tag) { |
|
478 /* Cast from the void pointer to the functor_wrapper_type */ |
|
479 functor_wrapper_type* victim = |
|
480 static_cast<functor_wrapper_type*>(in_buffer.obj_ptr); |
|
481 wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim)); |
|
482 wrapper_allocator.destroy(victim); |
|
483 wrapper_allocator.deallocate(victim,1); |
|
484 out_buffer.obj_ptr = 0; |
|
485 } else if (op == check_functor_type_tag) { |
|
486 const BOOST_FUNCTION_STD_NS::type_info& check_type |
|
487 = *out_buffer.type.type; |
|
488 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor))) |
|
489 out_buffer.obj_ptr = in_buffer.obj_ptr; |
|
490 else |
|
491 out_buffer.obj_ptr = 0; |
|
492 } else /* op == get_functor_type_tag */ { |
|
493 out_buffer.type.type = &typeid(Functor); |
|
494 out_buffer.type.const_qualified = false; |
|
495 out_buffer.type.volatile_qualified = false; |
|
496 } |
|
497 } |
|
498 |
|
499 // For function objects, we determine whether the function |
|
500 // object can use the small-object optimization buffer or |
|
501 // whether we need to allocate it on the heap. |
|
502 static inline void |
|
503 manager(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
504 functor_manager_operation_type op, function_obj_tag) |
|
505 { |
|
506 manager(in_buffer, out_buffer, op, |
|
507 mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>()); |
|
508 } |
|
509 |
|
510 public: |
|
511 /* Dispatch to an appropriate manager based on whether we have a |
|
512 function pointer or a function object pointer. */ |
|
513 static inline void |
|
514 manage(const function_buffer& in_buffer, function_buffer& out_buffer, |
|
515 functor_manager_operation_type op) |
|
516 { |
|
517 typedef typename get_function_tag<functor_type>::type tag_type; |
|
518 switch (op) { |
|
519 case get_functor_type_tag: |
|
520 out_buffer.type.type = &typeid(functor_type); |
|
521 out_buffer.type.const_qualified = false; |
|
522 out_buffer.type.volatile_qualified = false; |
|
523 return; |
|
524 |
|
525 default: |
|
526 manager(in_buffer, out_buffer, op, tag_type()); |
|
527 return; |
|
528 } |
|
529 } |
|
530 }; |
|
531 |
|
532 // A type that is only used for comparisons against zero |
|
533 struct useless_clear_type {}; |
|
534 |
|
535 #ifdef BOOST_NO_SFINAE |
|
536 // These routines perform comparisons between a Boost.Function |
|
537 // object and an arbitrary function object (when the last |
|
538 // parameter is mpl::bool_<false>) or against zero (when the |
|
539 // last parameter is mpl::bool_<true>). They are only necessary |
|
540 // for compilers that don't support SFINAE. |
|
541 template<typename Function, typename Functor> |
|
542 bool |
|
543 compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>) |
|
544 { return f.empty(); } |
|
545 |
|
546 template<typename Function, typename Functor> |
|
547 bool |
|
548 compare_not_equal(const Function& f, const Functor&, int, |
|
549 mpl::bool_<true>) |
|
550 { return !f.empty(); } |
|
551 |
|
552 template<typename Function, typename Functor> |
|
553 bool |
|
554 compare_equal(const Function& f, const Functor& g, long, |
|
555 mpl::bool_<false>) |
|
556 { |
|
557 if (const Functor* fp = f.template target<Functor>()) |
|
558 return function_equal(*fp, g); |
|
559 else return false; |
|
560 } |
|
561 |
|
562 template<typename Function, typename Functor> |
|
563 bool |
|
564 compare_equal(const Function& f, const reference_wrapper<Functor>& g, |
|
565 int, mpl::bool_<false>) |
|
566 { |
|
567 if (const Functor* fp = f.template target<Functor>()) |
|
568 return fp == g.get_pointer(); |
|
569 else return false; |
|
570 } |
|
571 |
|
572 template<typename Function, typename Functor> |
|
573 bool |
|
574 compare_not_equal(const Function& f, const Functor& g, long, |
|
575 mpl::bool_<false>) |
|
576 { |
|
577 if (const Functor* fp = f.template target<Functor>()) |
|
578 return !function_equal(*fp, g); |
|
579 else return true; |
|
580 } |
|
581 |
|
582 template<typename Function, typename Functor> |
|
583 bool |
|
584 compare_not_equal(const Function& f, |
|
585 const reference_wrapper<Functor>& g, int, |
|
586 mpl::bool_<false>) |
|
587 { |
|
588 if (const Functor* fp = f.template target<Functor>()) |
|
589 return fp != g.get_pointer(); |
|
590 else return true; |
|
591 } |
|
592 #endif // BOOST_NO_SFINAE |
|
593 |
|
594 /** |
|
595 * Stores the "manager" portion of the vtable for a |
|
596 * boost::function object. |
|
597 */ |
|
598 struct vtable_base |
|
599 { |
|
600 void (*manager)(const function_buffer& in_buffer, |
|
601 function_buffer& out_buffer, |
|
602 functor_manager_operation_type op); |
|
603 }; |
|
604 } // end namespace function |
|
605 } // end namespace detail |
|
606 |
|
607 /** |
|
608 * The function_base class contains the basic elements needed for the |
|
609 * function1, function2, function3, etc. classes. It is common to all |
|
610 * functions (and as such can be used to tell if we have one of the |
|
611 * functionN objects). |
|
612 */ |
|
613 class function_base |
|
614 { |
|
615 public: |
|
616 function_base() : vtable(0) { } |
|
617 |
|
618 /** Determine if the function is empty (i.e., has no target). */ |
|
619 bool empty() const { return !vtable; } |
|
620 |
|
621 /** Retrieve the type of the stored function object, or typeid(void) |
|
622 if this is empty. */ |
|
623 const BOOST_FUNCTION_STD_NS::type_info& target_type() const |
|
624 { |
|
625 if (!vtable) return typeid(void); |
|
626 |
|
627 detail::function::function_buffer type; |
|
628 vtable->manager(functor, type, detail::function::get_functor_type_tag); |
|
629 return *type.type.type; |
|
630 } |
|
631 |
|
632 template<typename Functor> |
|
633 Functor* target() |
|
634 { |
|
635 if (!vtable) return 0; |
|
636 |
|
637 detail::function::function_buffer type_result; |
|
638 type_result.type.type = &typeid(Functor); |
|
639 type_result.type.const_qualified = is_const<Functor>::value; |
|
640 type_result.type.volatile_qualified = is_volatile<Functor>::value; |
|
641 vtable->manager(functor, type_result, |
|
642 detail::function::check_functor_type_tag); |
|
643 return static_cast<Functor*>(type_result.obj_ptr); |
|
644 } |
|
645 |
|
646 template<typename Functor> |
|
647 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300) |
|
648 const Functor* target( Functor * = 0 ) const |
|
649 #else |
|
650 const Functor* target() const |
|
651 #endif |
|
652 { |
|
653 if (!vtable) return 0; |
|
654 |
|
655 detail::function::function_buffer type_result; |
|
656 type_result.type.type = &typeid(Functor); |
|
657 type_result.type.const_qualified = true; |
|
658 type_result.type.volatile_qualified = is_volatile<Functor>::value; |
|
659 vtable->manager(functor, type_result, |
|
660 detail::function::check_functor_type_tag); |
|
661 // GCC 2.95.3 gets the CV qualifiers wrong here, so we |
|
662 // can't do the static_cast that we should do. |
|
663 return (const Functor*)(type_result.obj_ptr); |
|
664 } |
|
665 |
|
666 template<typename F> |
|
667 bool contains(const F& f) const |
|
668 { |
|
669 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300) |
|
670 if (const F* fp = this->target( (F*)0 )) |
|
671 #else |
|
672 if (const F* fp = this->template target<F>()) |
|
673 #endif |
|
674 { |
|
675 return function_equal(*fp, f); |
|
676 } else { |
|
677 return false; |
|
678 } |
|
679 } |
|
680 |
|
681 #if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3 |
|
682 // GCC 3.3 and newer cannot copy with the global operator==, due to |
|
683 // problems with instantiation of function return types before it |
|
684 // has been verified that the argument types match up. |
|
685 template<typename Functor> |
|
686 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
687 operator==(Functor g) const |
|
688 { |
|
689 if (const Functor* fp = target<Functor>()) |
|
690 return function_equal(*fp, g); |
|
691 else return false; |
|
692 } |
|
693 |
|
694 template<typename Functor> |
|
695 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
696 operator!=(Functor g) const |
|
697 { |
|
698 if (const Functor* fp = target<Functor>()) |
|
699 return !function_equal(*fp, g); |
|
700 else return true; |
|
701 } |
|
702 #endif |
|
703 |
|
704 public: // should be protected, but GCC 2.95.3 will fail to allow access |
|
705 detail::function::vtable_base* vtable; |
|
706 mutable detail::function::function_buffer functor; |
|
707 }; |
|
708 |
|
709 /** |
|
710 * The bad_function_call exception class is thrown when a boost::function |
|
711 * object is invoked |
|
712 */ |
|
713 class bad_function_call : public std::runtime_error |
|
714 { |
|
715 public: |
|
716 bad_function_call() : std::runtime_error("call to empty boost::function") {} |
|
717 }; |
|
718 |
|
719 #ifndef BOOST_NO_SFINAE |
|
720 inline bool operator==(const function_base& f, |
|
721 detail::function::useless_clear_type*) |
|
722 { |
|
723 return f.empty(); |
|
724 } |
|
725 |
|
726 inline bool operator!=(const function_base& f, |
|
727 detail::function::useless_clear_type*) |
|
728 { |
|
729 return !f.empty(); |
|
730 } |
|
731 |
|
732 inline bool operator==(detail::function::useless_clear_type*, |
|
733 const function_base& f) |
|
734 { |
|
735 return f.empty(); |
|
736 } |
|
737 |
|
738 inline bool operator!=(detail::function::useless_clear_type*, |
|
739 const function_base& f) |
|
740 { |
|
741 return !f.empty(); |
|
742 } |
|
743 #endif |
|
744 |
|
745 #ifdef BOOST_NO_SFINAE |
|
746 // Comparisons between boost::function objects and arbitrary function objects |
|
747 template<typename Functor> |
|
748 inline bool operator==(const function_base& f, Functor g) |
|
749 { |
|
750 typedef mpl::bool_<(is_integral<Functor>::value)> integral; |
|
751 return detail::function::compare_equal(f, g, 0, integral()); |
|
752 } |
|
753 |
|
754 template<typename Functor> |
|
755 inline bool operator==(Functor g, const function_base& f) |
|
756 { |
|
757 typedef mpl::bool_<(is_integral<Functor>::value)> integral; |
|
758 return detail::function::compare_equal(f, g, 0, integral()); |
|
759 } |
|
760 |
|
761 template<typename Functor> |
|
762 inline bool operator!=(const function_base& f, Functor g) |
|
763 { |
|
764 typedef mpl::bool_<(is_integral<Functor>::value)> integral; |
|
765 return detail::function::compare_not_equal(f, g, 0, integral()); |
|
766 } |
|
767 |
|
768 template<typename Functor> |
|
769 inline bool operator!=(Functor g, const function_base& f) |
|
770 { |
|
771 typedef mpl::bool_<(is_integral<Functor>::value)> integral; |
|
772 return detail::function::compare_not_equal(f, g, 0, integral()); |
|
773 } |
|
774 #else |
|
775 |
|
776 # if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3) |
|
777 // Comparisons between boost::function objects and arbitrary function |
|
778 // objects. GCC 3.3 and before has an obnoxious bug that prevents this |
|
779 // from working. |
|
780 template<typename Functor> |
|
781 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
782 operator==(const function_base& f, Functor g) |
|
783 { |
|
784 if (const Functor* fp = f.template target<Functor>()) |
|
785 return function_equal(*fp, g); |
|
786 else return false; |
|
787 } |
|
788 |
|
789 template<typename Functor> |
|
790 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
791 operator==(Functor g, const function_base& f) |
|
792 { |
|
793 if (const Functor* fp = f.template target<Functor>()) |
|
794 return function_equal(g, *fp); |
|
795 else return false; |
|
796 } |
|
797 |
|
798 template<typename Functor> |
|
799 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
800 operator!=(const function_base& f, Functor g) |
|
801 { |
|
802 if (const Functor* fp = f.template target<Functor>()) |
|
803 return !function_equal(*fp, g); |
|
804 else return true; |
|
805 } |
|
806 |
|
807 template<typename Functor> |
|
808 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
809 operator!=(Functor g, const function_base& f) |
|
810 { |
|
811 if (const Functor* fp = f.template target<Functor>()) |
|
812 return !function_equal(g, *fp); |
|
813 else return true; |
|
814 } |
|
815 # endif |
|
816 |
|
817 template<typename Functor> |
|
818 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
819 operator==(const function_base& f, reference_wrapper<Functor> g) |
|
820 { |
|
821 if (const Functor* fp = f.template target<Functor>()) |
|
822 return fp == g.get_pointer(); |
|
823 else return false; |
|
824 } |
|
825 |
|
826 template<typename Functor> |
|
827 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
828 operator==(reference_wrapper<Functor> g, const function_base& f) |
|
829 { |
|
830 if (const Functor* fp = f.template target<Functor>()) |
|
831 return g.get_pointer() == fp; |
|
832 else return false; |
|
833 } |
|
834 |
|
835 template<typename Functor> |
|
836 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
837 operator!=(const function_base& f, reference_wrapper<Functor> g) |
|
838 { |
|
839 if (const Functor* fp = f.template target<Functor>()) |
|
840 return fp != g.get_pointer(); |
|
841 else return true; |
|
842 } |
|
843 |
|
844 template<typename Functor> |
|
845 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) |
|
846 operator!=(reference_wrapper<Functor> g, const function_base& f) |
|
847 { |
|
848 if (const Functor* fp = f.template target<Functor>()) |
|
849 return g.get_pointer() != fp; |
|
850 else return true; |
|
851 } |
|
852 |
|
853 #endif // Compiler supporting SFINAE |
|
854 |
|
855 namespace detail { |
|
856 namespace function { |
|
857 inline bool has_empty_target(const function_base* f) |
|
858 { |
|
859 return f->empty(); |
|
860 } |
|
861 |
|
862 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1310) |
|
863 inline bool has_empty_target(const void*) |
|
864 { |
|
865 return false; |
|
866 } |
|
867 #else |
|
868 inline bool has_empty_target(...) |
|
869 { |
|
870 return false; |
|
871 } |
|
872 #endif |
|
873 } // end namespace function |
|
874 } // end namespace detail |
|
875 } // end namespace boost |
|
876 |
|
877 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL |
|
878 #undef BOOST_FUNCTION_COMPARE_TYPE_ID |
|
879 |
|
880 #endif // BOOST_FUNCTION_BASE_HEADER |