1 // Boost.Function library
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)
9 // For more information, see http://www.boost.org
11 #ifndef BOOST_FUNCTION_BASE_HEADER
12 #define BOOST_FUNCTION_BASE_HEADER
18 #include <boost/config.hpp>
19 #include <boost/detail/sp_typeinfo.hpp>
20 #include <boost/assert.hpp>
21 #include <boost/integer.hpp>
22 #include <boost/type_traits/has_trivial_copy.hpp>
23 #include <boost/type_traits/has_trivial_destructor.hpp>
24 #include <boost/type_traits/is_const.hpp>
25 #include <boost/type_traits/is_integral.hpp>
26 #include <boost/type_traits/is_volatile.hpp>
27 #include <boost/type_traits/composite_traits.hpp>
28 #include <boost/type_traits/ice.hpp>
29 #include <boost/ref.hpp>
30 #include <boost/mpl/if.hpp>
31 #include <boost/detail/workaround.hpp>
32 #include <boost/type_traits/alignment_of.hpp>
33 #ifndef BOOST_NO_SFINAE
34 # include "boost/utility/enable_if.hpp"
36 # include "boost/mpl/bool.hpp"
38 #include <boost/function_equal.hpp>
39 #include <boost/function/function_fwd.hpp>
41 #if defined(BOOST_MSVC)
42 # pragma warning( push )
43 # pragma warning( disable : 4793 ) // complaint about native code generation
44 # pragma warning( disable : 4127 ) // "conditional expression is constant"
47 // Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
48 #ifdef BOOST_NO_STD_TYPEINFO
49 // Embedded VC++ does not have type_info in namespace std
50 # define BOOST_FUNCTION_STD_NS
52 # define BOOST_FUNCTION_STD_NS std
55 // Borrowed from Boost.Python library: determines the cases where we
56 // need to use std::type_info::name to compare instead of operator==.
57 #if defined( BOOST_NO_TYPEID )
58 # define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
59 #elif (defined(__GNUC__) && __GNUC__ >= 3) \
61 || ( defined(__sgi) && defined(__host_mips))
63 # define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
64 (std::strcmp((X).name(),(Y).name()) == 0)
66 # define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
69 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
70 # define BOOST_FUNCTION_TARGET_FIX(x) x
72 # define BOOST_FUNCTION_TARGET_FIX(x)
75 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
76 # define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
77 typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \
78 (::boost::is_integral<Functor>::value)>::value), \
81 // BCC doesn't recognize this depends on a template argument and complains
82 // about the use of 'typename'
83 # define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
84 ::boost::enable_if_c<(::boost::type_traits::ice_not< \
85 (::boost::is_integral<Functor>::value)>::value), \
95 * A buffer used to store small function objects in
96 * boost::function. It is a union containing function pointers,
97 * object pointers, and a structure that resembles a bound
98 * member function pointer.
100 union function_buffer
102 // For pointers to function objects
103 mutable void* obj_ptr;
105 // For pointers to std::type_info objects
107 // (get_functor_type_tag, check_functor_type_tag).
108 const detail::sp_typeinfo* type;
110 // Whether the type is const-qualified.
111 bool const_qualified;
112 // Whether the type is volatile-qualified.
113 bool volatile_qualified;
116 // For function pointers of all kinds
117 mutable void (*func_ptr)();
119 // For bound member pointers
120 struct bound_memfunc_ptr_t {
121 void (X::*memfunc_ptr)(int);
125 // For references to function objects. We explicitly keep
126 // track of the cv-qualifiers on the object referenced.
128 mutable void* obj_ptr;
129 bool is_const_qualified;
130 bool is_volatile_qualified;
133 // To relax aliasing constraints
138 * The unusable class is a placeholder for unused function arguments
139 * It is also completely unusable except that it constructable from
140 * anything. This helps compilers without partial specialization to
141 * handle Boost.Function objects returning void.
146 template<typename T> unusable(const T&) {}
149 /* Determine the return type. This supports compilers that do not support
150 * void returns or partial specialization by silently changing the return
151 * type to "unusable".
153 template<typename T> struct function_return_type { typedef T type; };
156 struct function_return_type<void>
158 typedef unusable type;
161 // The operation type to perform on the given functor/function pointer
162 enum functor_manager_operation_type {
166 check_functor_type_tag,
170 // Tags used to decide between different types of functions
171 struct function_ptr_tag {};
172 struct function_obj_tag {};
173 struct member_ptr_tag {};
174 struct function_obj_ref_tag {};
177 class get_function_tag
179 typedef typename mpl::if_c<(is_pointer<F>::value),
181 function_obj_tag>::type ptr_or_obj_tag;
183 typedef typename mpl::if_c<(is_member_pointer<F>::value),
185 ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
187 typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
188 function_obj_ref_tag,
189 ptr_or_obj_or_mem_tag>::type or_ref_tag;
192 typedef or_ref_tag type;
195 // The trivial manager does nothing but return the same pointer (if we
196 // are cloning) or return the null pointer (if we are deleting).
198 struct reference_manager
201 manage(const function_buffer& in_buffer, function_buffer& out_buffer,
202 functor_manager_operation_type op)
205 case clone_functor_tag:
206 out_buffer.obj_ref = in_buffer.obj_ref;
209 case move_functor_tag:
210 out_buffer.obj_ref = in_buffer.obj_ref;
211 in_buffer.obj_ref.obj_ptr = 0;
214 case destroy_functor_tag:
215 out_buffer.obj_ref.obj_ptr = 0;
218 case check_functor_type_tag:
220 const detail::sp_typeinfo& check_type
221 = *out_buffer.type.type;
223 // Check whether we have the same type. We can add
224 // cv-qualifiers, but we can't take them away.
225 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
226 && (!in_buffer.obj_ref.is_const_qualified
227 || out_buffer.type.const_qualified)
228 && (!in_buffer.obj_ref.is_volatile_qualified
229 || out_buffer.type.volatile_qualified))
230 out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
232 out_buffer.obj_ptr = 0;
236 case get_functor_type_tag:
237 out_buffer.type.type = &BOOST_SP_TYPEID(F);
238 out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
239 out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
246 * Determine if boost::function can use the small-object
247 * optimization with the function object type F.
250 struct function_allows_small_object_optimization
252 BOOST_STATIC_CONSTANT
254 value = ((sizeof(F) <= sizeof(function_buffer) &&
255 (alignment_of<function_buffer>::value
256 % alignment_of<F>::value == 0))));
259 template <typename F,typename A>
260 struct functor_wrapper: public F, public A
262 functor_wrapper( F f, A a ):
268 functor_wrapper(const functor_wrapper& f) :
269 F(static_cast<const F&>(f)),
270 A(static_cast<const A&>(f))
276 * The functor_manager class contains a static function "manage" which
277 * can clone or destroy the given function/function object pointer.
279 template<typename Functor>
280 struct functor_manager_common
282 typedef Functor functor_type;
286 manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
287 functor_manager_operation_type op)
289 if (op == clone_functor_tag)
290 out_buffer.func_ptr = in_buffer.func_ptr;
291 else if (op == move_functor_tag) {
292 out_buffer.func_ptr = in_buffer.func_ptr;
293 in_buffer.func_ptr = 0;
294 } else if (op == destroy_functor_tag)
295 out_buffer.func_ptr = 0;
296 else if (op == check_functor_type_tag) {
297 const detail::sp_typeinfo& check_type
298 = *out_buffer.type.type;
299 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
300 out_buffer.obj_ptr = &in_buffer.func_ptr;
302 out_buffer.obj_ptr = 0;
303 } else /* op == get_functor_type_tag */ {
304 out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
305 out_buffer.type.const_qualified = false;
306 out_buffer.type.volatile_qualified = false;
310 // Function objects that fit in the small-object buffer.
312 manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
313 functor_manager_operation_type op)
315 if (op == clone_functor_tag || op == move_functor_tag) {
316 const functor_type* in_functor =
317 reinterpret_cast<const functor_type*>(&in_buffer.data);
318 new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
320 if (op == move_functor_tag) {
321 functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
322 (void)f; // suppress warning about the value of f not being used (MSVC)
325 } else if (op == destroy_functor_tag) {
326 // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
327 functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
328 (void)f; // suppress warning about the value of f not being used (MSVC)
330 } else if (op == check_functor_type_tag) {
331 const detail::sp_typeinfo& check_type
332 = *out_buffer.type.type;
333 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
334 out_buffer.obj_ptr = &in_buffer.data;
336 out_buffer.obj_ptr = 0;
337 } else /* op == get_functor_type_tag */ {
338 out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
339 out_buffer.type.const_qualified = false;
340 out_buffer.type.volatile_qualified = false;
345 template<typename Functor>
346 struct functor_manager
349 typedef Functor functor_type;
353 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
354 functor_manager_operation_type op, function_ptr_tag)
356 functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
359 // Function objects that fit in the small-object buffer.
361 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
362 functor_manager_operation_type op, mpl::true_)
364 functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
367 // Function objects that require heap allocation
369 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
370 functor_manager_operation_type op, mpl::false_)
372 if (op == clone_functor_tag) {
374 // GCC 2.95.3 gets the CV qualifiers wrong here, so we
375 // can't do the static_cast that we should do.
376 // jewillco: Changing this to static_cast because GCC 2.95.3 is
378 const functor_type* f =
379 static_cast<const functor_type*>(in_buffer.obj_ptr);
380 functor_type* new_f = new functor_type(*f);
381 out_buffer.obj_ptr = new_f;
382 } else if (op == move_functor_tag) {
383 out_buffer.obj_ptr = in_buffer.obj_ptr;
384 in_buffer.obj_ptr = 0;
385 } else if (op == destroy_functor_tag) {
386 /* Cast from the void pointer to the functor pointer type */
388 static_cast<functor_type*>(out_buffer.obj_ptr);
390 out_buffer.obj_ptr = 0;
391 } else if (op == check_functor_type_tag) {
392 const detail::sp_typeinfo& check_type
393 = *out_buffer.type.type;
394 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
395 out_buffer.obj_ptr = in_buffer.obj_ptr;
397 out_buffer.obj_ptr = 0;
398 } else /* op == get_functor_type_tag */ {
399 out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
400 out_buffer.type.const_qualified = false;
401 out_buffer.type.volatile_qualified = false;
405 // For function objects, we determine whether the function
406 // object can use the small-object optimization buffer or
407 // whether we need to allocate it on the heap.
409 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
410 functor_manager_operation_type op, function_obj_tag)
412 manager(in_buffer, out_buffer, op,
413 mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
416 // For member pointers, we use the small-object optimization buffer.
418 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
419 functor_manager_operation_type op, member_ptr_tag)
421 manager(in_buffer, out_buffer, op, mpl::true_());
425 /* Dispatch to an appropriate manager based on whether we have a
426 function pointer or a function object pointer. */
428 manage(const function_buffer& in_buffer, function_buffer& out_buffer,
429 functor_manager_operation_type op)
431 typedef typename get_function_tag<functor_type>::type tag_type;
433 case get_functor_type_tag:
434 out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
435 out_buffer.type.const_qualified = false;
436 out_buffer.type.volatile_qualified = false;
440 manager(in_buffer, out_buffer, op, tag_type());
446 template<typename Functor, typename Allocator>
447 struct functor_manager_a
450 typedef Functor functor_type;
454 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
455 functor_manager_operation_type op, function_ptr_tag)
457 functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
460 // Function objects that fit in the small-object buffer.
462 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
463 functor_manager_operation_type op, mpl::true_)
465 functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
468 // Function objects that require heap allocation
470 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
471 functor_manager_operation_type op, mpl::false_)
473 typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
474 typedef typename Allocator::template rebind<functor_wrapper_type>::other
475 wrapper_allocator_type;
476 typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
478 if (op == clone_functor_tag) {
480 // GCC 2.95.3 gets the CV qualifiers wrong here, so we
481 // can't do the static_cast that we should do.
482 const functor_wrapper_type* f =
483 static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
484 wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
485 wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
486 wrapper_allocator.construct(copy, *f);
488 // Get back to the original pointer type
489 functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
490 out_buffer.obj_ptr = new_f;
491 } else if (op == move_functor_tag) {
492 out_buffer.obj_ptr = in_buffer.obj_ptr;
493 in_buffer.obj_ptr = 0;
494 } else if (op == destroy_functor_tag) {
495 /* Cast from the void pointer to the functor_wrapper_type */
496 functor_wrapper_type* victim =
497 static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
498 wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
499 wrapper_allocator.destroy(victim);
500 wrapper_allocator.deallocate(victim,1);
501 out_buffer.obj_ptr = 0;
502 } else if (op == check_functor_type_tag) {
503 const detail::sp_typeinfo& check_type
504 = *out_buffer.type.type;
505 if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
506 out_buffer.obj_ptr = in_buffer.obj_ptr;
508 out_buffer.obj_ptr = 0;
509 } else /* op == get_functor_type_tag */ {
510 out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
511 out_buffer.type.const_qualified = false;
512 out_buffer.type.volatile_qualified = false;
516 // For function objects, we determine whether the function
517 // object can use the small-object optimization buffer or
518 // whether we need to allocate it on the heap.
520 manager(const function_buffer& in_buffer, function_buffer& out_buffer,
521 functor_manager_operation_type op, function_obj_tag)
523 manager(in_buffer, out_buffer, op,
524 mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
528 /* Dispatch to an appropriate manager based on whether we have a
529 function pointer or a function object pointer. */
531 manage(const function_buffer& in_buffer, function_buffer& out_buffer,
532 functor_manager_operation_type op)
534 typedef typename get_function_tag<functor_type>::type tag_type;
536 case get_functor_type_tag:
537 out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
538 out_buffer.type.const_qualified = false;
539 out_buffer.type.volatile_qualified = false;
543 manager(in_buffer, out_buffer, op, tag_type());
549 // A type that is only used for comparisons against zero
550 struct useless_clear_type {};
552 #ifdef BOOST_NO_SFINAE
553 // These routines perform comparisons between a Boost.Function
554 // object and an arbitrary function object (when the last
555 // parameter is mpl::bool_<false>) or against zero (when the
556 // last parameter is mpl::bool_<true>). They are only necessary
557 // for compilers that don't support SFINAE.
558 template<typename Function, typename Functor>
560 compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
561 { return f.empty(); }
563 template<typename Function, typename Functor>
565 compare_not_equal(const Function& f, const Functor&, int,
567 { return !f.empty(); }
569 template<typename Function, typename Functor>
571 compare_equal(const Function& f, const Functor& g, long,
574 if (const Functor* fp = f.template target<Functor>())
575 return function_equal(*fp, g);
579 template<typename Function, typename Functor>
581 compare_equal(const Function& f, const reference_wrapper<Functor>& g,
582 int, mpl::bool_<false>)
584 if (const Functor* fp = f.template target<Functor>())
585 return fp == g.get_pointer();
589 template<typename Function, typename Functor>
591 compare_not_equal(const Function& f, const Functor& g, long,
594 if (const Functor* fp = f.template target<Functor>())
595 return !function_equal(*fp, g);
599 template<typename Function, typename Functor>
601 compare_not_equal(const Function& f,
602 const reference_wrapper<Functor>& g, int,
605 if (const Functor* fp = f.template target<Functor>())
606 return fp != g.get_pointer();
609 #endif // BOOST_NO_SFINAE
612 * Stores the "manager" portion of the vtable for a
613 * boost::function object.
617 void (*manager)(const function_buffer& in_buffer,
618 function_buffer& out_buffer,
619 functor_manager_operation_type op);
621 } // end namespace function
622 } // end namespace detail
625 * The function_base class contains the basic elements needed for the
626 * function1, function2, function3, etc. classes. It is common to all
627 * functions (and as such can be used to tell if we have one of the
628 * functionN objects).
633 function_base() : vtable(0) { }
635 /** Determine if the function is empty (i.e., has no target). */
636 bool empty() const { return !vtable; }
638 /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
640 const detail::sp_typeinfo& target_type() const
642 if (!vtable) return BOOST_SP_TYPEID(void);
644 detail::function::function_buffer type;
645 get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
646 return *type.type.type;
649 template<typename Functor>
652 if (!vtable) return 0;
654 detail::function::function_buffer type_result;
655 type_result.type.type = &BOOST_SP_TYPEID(Functor);
656 type_result.type.const_qualified = is_const<Functor>::value;
657 type_result.type.volatile_qualified = is_volatile<Functor>::value;
658 get_vtable()->manager(functor, type_result,
659 detail::function::check_functor_type_tag);
660 return static_cast<Functor*>(type_result.obj_ptr);
663 template<typename Functor>
664 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
665 const Functor* target( Functor * = 0 ) const
667 const Functor* target() const
670 if (!vtable) return 0;
672 detail::function::function_buffer type_result;
673 type_result.type.type = &BOOST_SP_TYPEID(Functor);
674 type_result.type.const_qualified = true;
675 type_result.type.volatile_qualified = is_volatile<Functor>::value;
676 get_vtable()->manager(functor, type_result,
677 detail::function::check_functor_type_tag);
678 // GCC 2.95.3 gets the CV qualifiers wrong here, so we
679 // can't do the static_cast that we should do.
680 return static_cast<const Functor*>(type_result.obj_ptr);
684 bool contains(const F& f) const
686 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
687 if (const F* fp = this->target( (F*)0 ))
689 if (const F* fp = this->template target<F>())
692 return function_equal(*fp, f);
698 #if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
699 // GCC 3.3 and newer cannot copy with the global operator==, due to
700 // problems with instantiation of function return types before it
701 // has been verified that the argument types match up.
702 template<typename Functor>
703 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
704 operator==(Functor g) const
706 if (const Functor* fp = target<Functor>())
707 return function_equal(*fp, g);
711 template<typename Functor>
712 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
713 operator!=(Functor g) const
715 if (const Functor* fp = target<Functor>())
716 return !function_equal(*fp, g);
721 public: // should be protected, but GCC 2.95.3 will fail to allow access
722 detail::function::vtable_base* get_vtable() const {
723 return reinterpret_cast<detail::function::vtable_base*>(
724 reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
727 bool has_trivial_copy_and_destroy() const {
728 return reinterpret_cast<std::size_t>(vtable) & 0x01;
731 detail::function::vtable_base* vtable;
732 mutable detail::function::function_buffer functor;
736 * The bad_function_call exception class is thrown when a boost::function
739 class bad_function_call : public std::runtime_error
742 bad_function_call() : std::runtime_error("call to empty boost::function") {}
745 #ifndef BOOST_NO_SFINAE
746 inline bool operator==(const function_base& f,
747 detail::function::useless_clear_type*)
752 inline bool operator!=(const function_base& f,
753 detail::function::useless_clear_type*)
758 inline bool operator==(detail::function::useless_clear_type*,
759 const function_base& f)
764 inline bool operator!=(detail::function::useless_clear_type*,
765 const function_base& f)
771 #ifdef BOOST_NO_SFINAE
772 // Comparisons between boost::function objects and arbitrary function objects
773 template<typename Functor>
774 inline bool operator==(const function_base& f, Functor g)
776 typedef mpl::bool_<(is_integral<Functor>::value)> integral;
777 return detail::function::compare_equal(f, g, 0, integral());
780 template<typename Functor>
781 inline bool operator==(Functor g, const function_base& f)
783 typedef mpl::bool_<(is_integral<Functor>::value)> integral;
784 return detail::function::compare_equal(f, g, 0, integral());
787 template<typename Functor>
788 inline bool operator!=(const function_base& f, Functor g)
790 typedef mpl::bool_<(is_integral<Functor>::value)> integral;
791 return detail::function::compare_not_equal(f, g, 0, integral());
794 template<typename Functor>
795 inline bool operator!=(Functor g, const function_base& f)
797 typedef mpl::bool_<(is_integral<Functor>::value)> integral;
798 return detail::function::compare_not_equal(f, g, 0, integral());
802 # if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
803 // Comparisons between boost::function objects and arbitrary function
804 // objects. GCC 3.3 and before has an obnoxious bug that prevents this
806 template<typename Functor>
807 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
808 operator==(const function_base& f, Functor g)
810 if (const Functor* fp = f.template target<Functor>())
811 return function_equal(*fp, g);
815 template<typename Functor>
816 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
817 operator==(Functor g, const function_base& f)
819 if (const Functor* fp = f.template target<Functor>())
820 return function_equal(g, *fp);
824 template<typename Functor>
825 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
826 operator!=(const function_base& f, Functor g)
828 if (const Functor* fp = f.template target<Functor>())
829 return !function_equal(*fp, g);
833 template<typename Functor>
834 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
835 operator!=(Functor g, const function_base& f)
837 if (const Functor* fp = f.template target<Functor>())
838 return !function_equal(g, *fp);
843 template<typename Functor>
844 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
845 operator==(const function_base& f, reference_wrapper<Functor> g)
847 if (const Functor* fp = f.template target<Functor>())
848 return fp == g.get_pointer();
852 template<typename Functor>
853 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
854 operator==(reference_wrapper<Functor> g, const function_base& f)
856 if (const Functor* fp = f.template target<Functor>())
857 return g.get_pointer() == fp;
861 template<typename Functor>
862 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
863 operator!=(const function_base& f, reference_wrapper<Functor> g)
865 if (const Functor* fp = f.template target<Functor>())
866 return fp != g.get_pointer();
870 template<typename Functor>
871 BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
872 operator!=(reference_wrapper<Functor> g, const function_base& f)
874 if (const Functor* fp = f.template target<Functor>())
875 return g.get_pointer() != fp;
879 #endif // Compiler supporting SFINAE
883 inline bool has_empty_target(const function_base* f)
888 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
889 inline bool has_empty_target(const void*)
894 inline bool has_empty_target(...)
899 } // end namespace function
900 } // end namespace detail
901 } // end namespace boost
903 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
904 #undef BOOST_FUNCTION_COMPARE_TYPE_ID
906 #if defined(BOOST_MSVC)
907 # pragma warning( pop )
910 #endif // BOOST_FUNCTION_BASE_HEADER